transfer_learning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "transfer_learning.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [
        "W_tvPdyfA-BL"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.9"
    }
  },
  "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/transfer_learning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W_tvPdyfA-BL"
      },
      "source": [
        "##### Copyright - The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0O_LFhwSBCjm"
      },
      "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": "E9Us3uPqzzl8"
      },
      "source": [
        "Επιμέλεια: Κ.Μούτσελος Παν/μιο Πειραιώς"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LlMcTwY3CpQU"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PWUmcKKjtwXL"
      },
      "source": [
        "# Μεταφορά Μάθησης -Transfer learning (με TensorFlow Hub)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "crU-iluJIEzw"
      },
      "source": [
        "\n",
        "Το [TensorFlow Hub](http://tensorflow.org/hub) είναι ένα αποθετήριο προκατασκευασμένων μοντέλων. Ανατρέξτε στο [TensorFlow Module Hub](https://tfhub.dev/) για μια λίστα με προ-εκπαιδευμένα μοντέλα με δυνατότητα αναζήτησης. Σε αυτόν τον οδηγό θα δούμε:\n",
        "\n",
        "1. Πώς να χρησιμοποιήσουμε το TensorFlow Hub με το `tf.keras`.\n",
        "1. Ταξινόμηση εικόνας χρησιμοποιώντας ένα μοντέλο από το TensorFlow Hub.\n",
        "1. Πώς πραγματοποιείται μια απλή εκπαίδευση με μεταφορά μάθησης."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKFUvuEho9Th"
      },
      "source": [
        "## Αρχικές ρυθμίσεις"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kg21yecW8sUN"
      },
      "source": [
        "import numpy as np\n",
        "import time\n",
        "\n",
        "import PIL.Image as Image\n",
        "import matplotlib.pylab as plt\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s4YuF5HvpM1W"
      },
      "source": [
        "## Ένας ταξινομητής της ImageNet"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xEY_Ow5loN6q"
      },
      "source": [
        "### Κατεβάστε τον ταξινομητή\n",
        "Χρησιμοποιούμε το `hub.module` για να φορτώσουμε ένα μοντέλο mobilenet και το `tf.keras.layers.Lambda` για να το τυλίξουμε (wrap) ως ένα επίπεδο στο keras. Μπορούμε να βάλουμε οποιοδήποτε [URL που να περιέχει ταξινομητή εικόνας με TensorFlow 2](https://tfhub.dev/s?q=tf2&module-type=image-classification) από το tfhub.dev."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "feiXojVXAbI9",
        "cellView": "form"
      },
      "source": [
        "classifier_url =\"https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2\" #@param {type:\"string\"}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y_6bGjoPtzau"
      },
      "source": [
        "IMAGE_SHAPE = (224, 224)\n",
        "\n",
        "classifier = tf.keras.Sequential([\n",
        "    hub.KerasLayer(classifier_url, input_shape=IMAGE_SHAPE+(3,))\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pwZXaoV0uXp2"
      },
      "source": [
        "### Ας το τρέξουμε σε μία μόνο εικόνα"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TQItP1i55-di"
      },
      "source": [
        "Κατεβάζουμε μία εικόνα για να δοκιμάσουμε το μοντέλο."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w5wDjXNjuXGD"
      },
      "source": [
        "import numpy as np\n",
        "import PIL.Image as Image\n",
        "\n",
        "# surfer = tf.keras.utils.get_file('image.png','https://www.tensorflow.org/tutorials/images/transfer_learning_with_hub_files/output_w5wDjXNjuXGD_0.png')\n",
        "corona = tf.keras.utils.get_file('image3.jpg','https://image.shutterstock.com/image-photo/specialist-hazmat-suits-cleaning-disinfecting-600w-1679265442.jpg')\n",
        "corona = Image.open(corona).resize(IMAGE_SHAPE)\n",
        "corona"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BEmmBnGbLxPp"
      },
      "source": [
        "corona = np.array(corona)/255.0\n",
        "corona.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "36uObfWB9EzD"
      },
      "source": [
        "Προσθέτουμε μια διάσταση παρτίδας (batch) στην αρχή του πίνακα της εικόνας:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lJW_mfM49VWV"
      },
      "source": [
        "coronab = corona[np.newaxis, ...]\n",
        "coronab.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Ic8OEEo2b73"
      },
      "source": [
        "Στέλνουμε την εικόνα στο μοντέλο για πρόβλεψη:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EMquyn29v8q3"
      },
      "source": [
        "result = classifier.predict(coronab)\n",
        "result.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NKzjqENF6jDF"
      },
      "source": [
        "Το αποτέλεσμα είναι ένα άνυσμα 1001 στοιχείων με logits, ο οποίος βαθμολογεί την πιθανότητα κάθε κλάσης για την εικόνα.\n",
        "\n",
        "Το ID της κορυφαίας κατηγορίας μπορεί να βρεθεί με το argmax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rgXb44vt6goJ"
      },
      "source": [
        "predicted_class = np.argmax(result[0], axis=-1)\n",
        "predicted_class"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YrxLMajMoxkf"
      },
      "source": [
        "### Aποκωδικοποίηση της πρόβλεψης\n",
        "\n",
        "Έχουμε το ID της κλάσης που προβλέφθηκε, οπότε λαμβάνουμε όες τις ετικέτες ImageNet και αποκωδικοποιούμε την πρόβλεψη."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ij6SrDxcxzry"
      },
      "source": [
        "labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')\n",
        "imagenet_labels = np.array(open(labels_path).read().splitlines())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uzziRK3Z2VQo"
      },
      "source": [
        "plt.imshow(corona)\n",
        "plt.axis('off')\n",
        "predicted_class_name = imagenet_labels[predicted_class]\n",
        "_ = plt.title(\"Prediction: \" + predicted_class_name.title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "amfzqn1Oo7Om"
      },
      "source": [
        "## Απλή μεταφορά μάθησης"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K-nIpVJ94xrw"
      },
      "source": [
        "Χρησιμοποιώντας το TF Hub είναι απλό να επανεκπαιδεύσουμε το τελευταίο (top) επίπεδο του μοντέλου για να αναγνωρίζει τις κλάσεις στα δικά μας δεδομένα. Εδώ θα χρησιμοποιήσουμε ένα dataset με φωτογραφίες **λουλουδιών** που ανήκουν σε **5 κλάσεις** ( Daisy, Dandelion, Roses, Sunflowers, Tulips)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z93vvAdGxDMD"
      },
      "source": [
        "### Dataset\n",
        "\n",
        "Σε αυτό το παράδειγμα θα χρησιμοποιήσουμε το TensorFlow flowers dataset:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DrIUV3V0xDL_"
      },
      "source": [
        "data_root = tf.keras.utils.get_file(\n",
        "  'flower_photos','https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',\n",
        "   untar=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jFHdp18ccah7"
      },
      "source": [
        "Ο απλούστερος τρόπος φόρτωσης αυτών των δεδομένων στο μοντέλο μας είναι με χρήση του `tf.keras.preprocessing.image.ImageDataGenerator`,\n",
        "\n",
        "Όλες τα μοντέλα εικόνων στο TensorFlow Hub παίρνουν ως είσοδο  δεκαδικούς αριθμούς στην περιοχή [0, 1]. Για το σκοπό αυτό χρησιμοποιούμε τη παράμετρο `rescale` του `ImageDataGenerator`.\n",
        "\n",
        "Το μέγεθος της εικόνας θα το χειριστούμε αργότερα."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2PwQ_wYDcii9"
      },
      "source": [
        "image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1/255)\n",
        "image_data = image_generator.flow_from_directory(str(data_root), target_size=IMAGE_SHAPE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wdms9xuJsu28"
      },
      "source": [
        "Classes: 'Daisy', 'Dandelion', 'Roses', 'Sunflowers', 'Tulips'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0p7iDOhIcqY2"
      },
      "source": [
        "Το αντικείμενο που προκύπτει είναι μια γεννήτρια iterator που επιστρέφει ζεύγη: `image_batch, label_batch`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W4lDPkn2cpWZ"
      },
      "source": [
        "for image_batch, label_batch in image_data:\n",
        "  print(\"Image batch shape: \", image_batch.shape)\n",
        "  print(\"Label batch shape: \", label_batch.shape)\n",
        "  break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0gTN7M_GxDLx"
      },
      "source": [
        "### Τρέξιμο του ταξινομητή σε μια παρτίδα εικόνων"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O3fvrZR8xDLv"
      },
      "source": [
        "Ας προβλέψει ο ταξινομητής τις κλάσεις σε μια παρτίδα εικόνων."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nbyg6tcyxDLh"
      },
      "source": [
        "result_batch = classifier.predict(image_batch)\n",
        "result_batch.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kv7ZwuR4xDLc"
      },
      "source": [
        "predicted_class_names = imagenet_labels[np.argmax(result_batch, axis=-1)]\n",
        "predicted_class_names"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QmvSWg9nxDLa"
      },
      "source": [
        "Ας ελέγξουμε πώς αυτές οι προβλέψεις ταιριάζουμε με τις εικόνες:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IXTB22SpxDLP"
      },
      "source": [
        "plt.figure(figsize=(10,9))\n",
        "plt.subplots_adjust(hspace=0.5)\n",
        "for n in range(30):\n",
        "  plt.subplot(6,5,n+1)\n",
        "  plt.imshow(image_batch[n])\n",
        "  plt.title(predicted_class_names[n])\n",
        "  plt.axis('off')\n",
        "_ = plt.suptitle(\"ImageNet predictions\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FUa3YkvhxDLM"
      },
      "source": [
        "Τα αποτελέσματα δεν είναι σε καμιά περίπτωση τέλεια, αλλά είναι λογικά, δεδομένου ότι δεν συμπίπτουν με τις κλάσεις που εκπαιδεύτηκε το μοντέλο (εκτός από τη \"daisy\")."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JzV457OXreQP"
      },
      "source": [
        "### Κατεβάστε το μοντέλο χωρίς το τελευταίο επίπεδο (headless)\n",
        "\n",
        "Το TensorFlow Hub διανέμει επίσης μοντέλα χωρίς το τελευταίο επίπεδο ταξινόμησης. Αυτά μπορούν να χρησιμοποιηθούν για εύκολη μεταφορά μάθησης.\n",
        "\n",
        "Οποιοδήποτε συμβατό [URL Tensorflow 2](https://tfhub.dev/s?module-type=image-feature-vector&q=tf2) από το tfhub.dev θα λειτουργεί."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4bw8Jf94DSnP"
      },
      "source": [
        "feature_extractor_url = \"https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2\" #@param {type:\"string\"}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sgwmHugQF-PD"
      },
      "source": [
        "Δημιουργήστε το επίπεδο εξαγωγής χαρακτηριστικών."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5wB030nezBwI"
      },
      "source": [
        "feature_extractor_layer = hub.KerasLayer(feature_extractor_url,\n",
        "                                         input_shape=(224,224,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0QzVdu4ZhcDE"
      },
      "source": [
        "Για κάθε εικόνα επιστρέφει ένα διάνυσμα μήκους 1280 στοιχείων:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Of7i-35F09ls"
      },
      "source": [
        "feature_batch = feature_extractor_layer(image_batch)\n",
        "print(feature_batch.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CtFmF7A5E4tk"
      },
      "source": [
        "Παγώστε τις μεταβλητές στο επίπεδο εξαγωγής χαρακτηριστικών, ώστε η εκπαίδευση να τροποποιεί μόνο το νέο επίπεδο του ταξινομητή."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jg5ar6rcE4H-"
      },
      "source": [
        "feature_extractor_layer.trainable = False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RPVeouTksO9q"
      },
      "source": [
        "### Πρόσθεση κεφαλής ταξινόμησης (classification head)\n",
        "\n",
        "Τώρα τυλίγουμε το  hub  σε ένα σειριακό μοντέλο `tf.keras.Sequential` και προσθέτουμε ένα νέο επίπεδο ταξινόμησης."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mGcY27fY1q3Q"
      },
      "source": [
        "model = tf.keras.Sequential([\n",
        "  feature_extractor_layer,\n",
        "  tf.keras.layers.Dense(image_data.num_classes)\n",
        "])\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G9VkAz00HOJx"
      },
      "source": [
        "predictions = model(image_batch)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sB7sVGJ23vrY"
      },
      "source": [
        "predictions.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OHbXQqIquFxQ"
      },
      "source": [
        "### Εκπαίδευση του μοντέλου\n",
        "\n",
        "Χρησιμοποιούμε τη συνάρτηση compile για να διαμορφώσουμε τη διαδικασία εκπαίδευσης:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3n0Wb9ylKd8R"
      },
      "source": [
        "model.compile(\n",
        "  optimizer=tf.keras.optimizers.Adam(),\n",
        "  loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),\n",
        "  metrics=['acc'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "58-BLV7dupJA"
      },
      "source": [
        "Και τώρα χρησιμοποιούμε τη μέθοδο `.fit` method για να εκπαιδεύσουμε το μοντέλο.\n",
        "\n",
        "Για να διατηρήσουμε αυτό το παράδειγμα σύντομο, ας το τρέξουμε μόνο για 2 εποχές. Για να απεικονίσουμε την πρόοδο της εκπαίδευσης, ας χρησιμοποιούσουμε μια προσαρμοσμένη συνάρτηση callback για να καταγράφει την απώλεια (loss) και την ακρίβεια (accuracy) κάθε παρτίδας ξεχωριστά, αντί για τον μέσο όρο της εποχής."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gkzA7xPj5g7m"
      },
      "source": [
        "class CollectBatchStats(tf.keras.callbacks.Callback):\n",
        "  def __init__(self):\n",
        "    self.batch_losses = []\n",
        "    self.batch_acc = []\n",
        "\n",
        "  def on_train_batch_end(self, batch, logs=None):\n",
        "    self.batch_losses.append(logs['loss'])\n",
        "    self.batch_acc.append(logs['acc'])\n",
        "    self.model.reset_metrics()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EyMDJxt2HdHr"
      },
      "source": [
        "steps_per_epoch = np.ceil(image_data.samples/image_data.batch_size)\n",
        "\n",
        "batch_stats_callback = CollectBatchStats()\n",
        "\n",
        "history = model.fit(image_data, epochs=2,\n",
        "                    steps_per_epoch=steps_per_epoch,\n",
        "                    callbacks = [batch_stats_callback])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kd0N272B9Q0b"
      },
      "source": [
        "Aκόμη και με τόσο λίγες επαναλήψεις εκπαίδευσης, μπορούμε  να δούμε ήδη ότι το μοντέλο σημειώνει πρόοδο."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A5RfS1QIIP-P"
      },
      "source": [
        "plt.figure()\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Training Steps\")\n",
        "plt.ylim([0,2])\n",
        "plt.plot(batch_stats_callback.batch_losses)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3uvX11avTiDg"
      },
      "source": [
        "plt.figure()\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.xlabel(\"Training Steps\")\n",
        "plt.ylim([0,1])\n",
        "plt.plot(batch_stats_callback.batch_acc)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kb__ZN8uFn-D"
      },
      "source": [
        "### Έλεγχος προβλέψεων\n",
        "\n",
        "Για να ξανατρέξουμε το προηγούμενο γράφημα, πρώτα παίρνουμε μια ταξινομημένη λίστα των ονομάτων των κλάσεων:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JGbEf5l1I4jz"
      },
      "source": [
        "class_names = sorted(image_data.class_indices.items(), key=lambda pair:pair[1])\n",
        "class_names = np.array([key.title() for key, value in class_names])\n",
        "class_names"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Olg6MsNGJTL"
      },
      "source": [
        "Τρέχουμε τη παρτίδα εικόνων από το μοντέλο και μετατρέπουμε τους αριθμούς σε ονόματα κλάσεων."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fCLVCpEjJ_VP"
      },
      "source": [
        "predicted_batch = model.predict(image_batch)\n",
        "predicted_id = np.argmax(predicted_batch, axis=-1)\n",
        "predicted_label_batch = class_names[predicted_id]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CkGbZxl9GZs-"
      },
      "source": [
        "Ας δούμε τα αποτελέσματα:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rpFQR1MPMtT1"
      },
      "source": [
        "label_id = np.argmax(label_batch, axis=-1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wC_AYRJU9NQe"
      },
      "source": [
        "plt.figure(figsize=(10,9))\n",
        "plt.subplots_adjust(hspace=0.5)\n",
        "for n in range(30):\n",
        "  plt.subplot(6,5,n+1)\n",
        "  plt.imshow(image_batch[n])\n",
        "  color = \"green\" if predicted_id[n] == label_id[n] else \"red\"\n",
        "  plt.title(predicted_label_batch[n].title(), color=color)\n",
        "  plt.axis('off')\n",
        "_ = plt.suptitle(\"Model predictions (green: correct, red: incorrect)\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uRcJnAABr22x"
      },
      "source": [
        "## Εξαγωγή μοντέλου\n",
        "\n",
        "Τώρα που έχετε εκπαιδεύσει το μοντέλο, μπορείτε να το εξαχθεί και να αποθηκευτεί:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PLcqg-RmsLno"
      },
      "source": [
        "import time\n",
        "t = time.time()\n",
        "\n",
        "export_path = \"/tmp/saved_models/{}\".format(int(t))\n",
        "model.save(export_path, save_format='tf')\n",
        "\n",
        "export_path"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AhQ9liIUsPsi"
      },
      "source": [
        "Ας επιβεβαιώσουμε ότι μπορούμε να το ξαναφορτώσουμε και ότι εξακολουθεί να δίνει τα ίδια αποτελέσματα:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7nI5fvkAQvbS"
      },
      "source": [
        "reloaded = tf.keras.models.load_model(export_path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jor83-LqI8xW"
      },
      "source": [
        "result_batch = model.predict(image_batch)\n",
        "reloaded_result_batch = reloaded.predict(image_batch)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dnZO14taYPH6"
      },
      "source": [
        "abs(reloaded_result_batch - result_batch).max()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TYZd4MNiV3Rc"
      },
      "source": [
        "Αυτό το αποθηκευμένο μοντέλο μπορεί να φορτωθεί για προγνώσεις αργότερα ή να μετατραπεί σε [TFLite](https://www.tensorflow.org/lite/convert/) ή [TFjs](https://github.com/tensorflow/tfjs-converter).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BGMjP4ckDJFC"
      },
      "source": [
        "## Συνέχεια εξερεύνησης...\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZznuF0VpL1hR"
      },
      "source": [
        "### Γραφική επόπτευση\n",
        "\n",
        "Όταν κατασκευάζουμε μοντέλα, είναι πολύ χρήσιμο να έχουμε μια οπτική της όλης αρχιτεκτονικής. \n",
        "\n",
        "Η συνάρτηση `plot_model` από το `tensorflow.keras.utils` μπορεί να χρησιμοποιηθεί για να έχουμε μια οπτική σύνοψη του μοντέλου:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Gon0EAlDOhO"
      },
      "source": [
        "from tensorflow.keras.utils import plot_model\n",
        "\n",
        "plot_model(model, to_file='conv_base.png', show_shapes=True)\n",
        "from IPython.display import Image\n",
        "Image(filename='conv_base.png')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "otoOzPyDI6b_"
      },
      "source": [
        "Για να επιβεβαιώσουμε ποιά επίπεδα μπορούν να εκπαιδευτούν, μπορούμε να ελέγξουμε την ιδιότητα `trainable` του κάθε επιπέδου:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "itatg4dEI8FC"
      },
      "source": [
        "    # Check the trainable status of the individual layers\n",
        "for layer in model.layers:\n",
        "  print(layer, layer.trainable)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--wKM5jmKpmg"
      },
      "source": [
        "Με μια ανάλογη επανάληψη, μπορούμε να επιτρέπουμε ή όχι την εκπαίδευση κάποιου επιπέδου, θέτοντας πχ `layer.trainable = False` ή `True` αντίστοιχα."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tMqYojVILOGF"
      },
      "source": [
        "Δοκιμάστε να ξαναεκπαιδεύσετε το μοντέλο, ξαπαγώνοντας όλα του τα επίπεδα. Είναι καλύτερα τα αποτελέσματα πρόβλεψης;"
      ]
    }
  ]
}