6.1.2-Tuning-an-autoencoder-model-for-unsupervised-learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "!pip install -r https://raw.githubusercontent.com/datamllab/automl-in-action-notebooks/master/requirements.txt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.datasets import fashion_mnist\n",
    "\n",
    "(x_train, _), (x_test, _) = fashion_mnist.load_data()\n",
    "\n",
    "x_train = x_train.astype(\"float32\") / 255.0\n",
    "x_test = x_test.astype(\"float32\") / 255.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras import layers, losses\n",
    "\n",
    "\n",
    "class AutoencoderModel(Model):\n",
    "    def __init__(self, latent_dim):\n",
    "        super().__init__()\n",
    "        self.latent_dim = latent_dim\n",
    "        self.encoder_layer = layers.Dense(latent_dim, activation=\"relu\")\n",
    "        self.decoder_layer = layers.Dense(784, activation=\"sigmoid\")\n",
    "\n",
    "    def encode(self, encoder_input):\n",
    "        encoder_output = layers.Flatten()(encoder_input)\n",
    "        encoder_output = self.encoder_layer(encoder_output)\n",
    "        return encoder_output\n",
    "\n",
    "    def decode(self, decoder_input):\n",
    "        decoder_output = decoder_input\n",
    "        decoder_output = self.decoder_layer(decoder_output)\n",
    "        decoder_output = layers.Reshape((28, 28))(decoder_output)\n",
    "        return decoder_output\n",
    "\n",
    "    def call(self, x):\n",
    "        return self.decode(self.encode(x))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "tf.random.set_seed(5)\n",
    "np.random.seed(5)\n",
    "autoencoder = AutoencoderModel(64)\n",
    "autoencoder.compile(optimizer=\"adam\", loss=\"mse\")\n",
    "autoencoder.fit(\n",
    "    x_train, x_train, epochs=10, shuffle=True, validation_data=(x_test, x_test)\n",
    ")\n",
    "\n",
    "autoencoder.evaluate(x_test, x_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "autoencoder.encode(x_test[:1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def show_images(model, images):\n",
    "    encoded_imgs = model.encode(images).numpy()\n",
    "    decoded_imgs = model.decode(encoded_imgs).numpy()\n",
    "\n",
    "    n = 10\n",
    "    plt.figure(figsize=(20, 4))\n",
    "    for i in range(n):\n",
    "        ax = plt.subplot(2, n, i + 1)\n",
    "        plt.imshow(images[i])\n",
    "        plt.title(\"original\")\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "\n",
    "        ax = plt.subplot(2, n, i + 1 + n)\n",
    "        plt.imshow(decoded_imgs[i])\n",
    "        plt.title(\"reconstructed\")\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "show_images(autoencoder, x_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import keras_tuner\n",
    "from tensorflow import keras\n",
    "from keras_tuner import RandomSearch\n",
    "\n",
    "\n",
    "class AutoencoderBlock(keras.Model):\n",
    "    def __init__(self, latent_dim, hp):\n",
    "        super().__init__()\n",
    "        self.latent_dim = latent_dim\n",
    "        self.encoder_layers = []\n",
    "        for i in range(\n",
    "            hp.Int(\"encoder_layers\", min_value=0, max_value=2, step=1, default=0)\n",
    "        ):\n",
    "            self.encoder_layers.append(\n",
    "                layers.Dense(\n",
    "                    units=hp.Choice(\"encoder_layers_{i}\".format(i=i), [64, 128, 256]),\n",
    "                    activation=\"relu\",\n",
    "                )\n",
    "            )\n",
    "        self.encoder_layers.append(layers.Dense(latent_dim, activation=\"relu\"))\n",
    "        self.decoder_layers = []\n",
    "        for i in range(\n",
    "            hp.Int(\"decoder_layers\", min_value=0, max_value=2, step=1, default=0)\n",
    "        ):\n",
    "            self.decoder_layers.append(\n",
    "                layers.Dense(\n",
    "                    units=hp.Choice(\"decoder_layers_{i}\".format(i=i), [64, 128, 256]),\n",
    "                    activation=\"relu\",\n",
    "                )\n",
    "            )\n",
    "        self.decoder_layers.append(layers.Dense(784, activation=\"sigmoid\"))\n",
    "\n",
    "    def encode(self, encoder_input):\n",
    "        encoder_output = layers.Flatten()(encoder_input)\n",
    "        for layer in self.encoder_layers:\n",
    "            encoder_output = layer(encoder_output)\n",
    "        return encoder_output\n",
    "\n",
    "    def decode(self, decoder_input):\n",
    "        decoder_output = decoder_input\n",
    "        for layer in self.decoder_layers:\n",
    "            decoder_output = layer(decoder_output)\n",
    "        decoder_output = layers.Reshape((28, 28))(decoder_output)\n",
    "        return decoder_output\n",
    "\n",
    "    def call(self, x):\n",
    "        return self.decode(self.encode(x))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "\n",
    "def build_model(hp):\n",
    "    latent_dim = 20\n",
    "    autoencoder = AutoencoderBlock(latent_dim, hp)\n",
    "    autoencoder.compile(optimizer=\"adam\", loss=\"mse\")\n",
    "    return autoencoder\n",
    "\n",
    "\n",
    "tuner = RandomSearch(\n",
    "    build_model,\n",
    "    objective=\"val_loss\",\n",
    "    max_trials=10,\n",
    "    overwrite=True,\n",
    "    directory=\"my_dir\",\n",
    "    project_name=\"helloworld\",\n",
    ")\n",
    "\n",
    "tuner.search(x_train, x_train, epochs=10, validation_data=(x_test, x_test))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "autoencoder = tuner.get_best_models(num_models=1)[0]\n",
    "tuner.results_summary(1)\n",
    "autoencoder.evaluate(x_test, x_test)\n",
    "\n",
    "show_images(autoencoder, x_test)\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "6.1.2-Tuning-an-autoencoder-model-for-unsupervised-learning",
   "private_outputs": false,
   "provenance": [],
   "toc_visible": true
  },
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}