{"cells":[{"cell_type":"markdown","metadata":{},"source":["# AutoEncoders"]},{"cell_type":"markdown","metadata":{},"source":["### In this notebook you will learn the definition of an autoencoder, how it works, and see an implementation in TensorFlow.\n","---\n","### Table of Contents\n","1. Introduction\n","2. Feature Extraction and Dimensionality Reduction\n","3. Autoencoder Structure\n","4. Performance\n","5. Training: Loss Function\n","6. Code\n","---\n","#### By the end of this notebook, you should be able to create simple autoencoders apply them to problems in the field of unsupervised learning.\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","## Introduction\n","---\n","An autoencoder, also known as autoassociator or Diabolo networks, is an artificial neural network employed to recreate the given input.\n","It takes a set of <b>unlabeled</b> inputs, encodes them and then tries to extract the most valuable information from them.\n","They are used for feature extraction, learning generative models of data, dimensionality reduction and can be used for compression. \n","\n","A 2006 paper named *[Reducing the Dimensionality of Data with Neural Networks](https://www.cs.toronto.edu/~hinton/science.pdf)*, done by G. E. Hinton and R. R. Salakhutdinov, showed better results than years of refining other types of network, and was a breakthrough in the field of Neural Networks, a field that was \"stagnant\" for 10 years.\n","\n","Now, autoencoders, based on Restricted Boltzmann Machines, are employed in some of the largest deep learning applications. They are the building blocks of Deep Belief Networks (DBN).\n","\n","<p align=\"center\">\n","  <img src=\"../images/DBNpic.png\">\n","</p>\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","## Feature Extraction and Dimensionality Reduction\n","---\n","An example given by Nikhil Buduma in KdNuggets *[(link)](\"http://www.kdnuggets.com/2015/03/deep-learning-curse-dimensionality-autoencoders.html\")* gives an excellent explanation of the utility of this type of Neural Network.\n","\n","Say that you want to extract the emotion that a person in a photograph is feeling. Take the following 256x256 pixel grayscale picture as an example:\n","\n","<p align=\"center\">\n","  <img src=\"../images/examplePFP.png\">\n","</p>\n","\n","If we just use the raw image, we have too many dimensions to analyze.  This image is 256x256 pixels, which corresponds to an input vector of 65536 dimensions! Conventional cell phones can produce images in the  4000 x 3000 pixels range, which gives us 12 million dimensions to analyze.\n","\n","This is particularly problematic, since the difficulty of a machine learning problem is vastly increased as more dimensions are involved. According to a 1982 study by C.J. Stone *[(link)](\"http://www-personal.umich.edu/~jizhu/jizhu/wuke/Stone-AoS82.pdf\")*, the time to fit a model, is optimal if:\n","\n","$ m^{-p/(2p+d)} $\n","\n","Where:\n","* m: Number of data points\n","* d: Dimensionality of the data\n","* p: Number of Parameters in the model\n","\n","As you can see, it increases exponentially!\n","\n","Returning to our example, we don't need to use all of the 65,536 dimensions to classify an emotion.\n","A human identifies emotions according to specific facial expressions, and some **key features**, like the shape of the mouth and eyebrows.\n","\n","<p align=\"center\">\n"," <img src=\"../images/examplePFPMarked.png\" height=\"256\" width=\"256\">\n","</p>\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","## Autoencoder Structure\n","---\n","<p align=\"center\">\n"," <img src=\"../images/encoderDecoder.png\" style=\"width: 400px;\">\n","</p>\n","\n","An autoencoder can be divided in two parts, the **encoder** and the **decoder**.\n","\n","The *encoder* needs to compress the representation of an input. In this case, we are going to reduce the dimensions of the image of the example face from 2000 dimensions to only 30 dimensions.  We will acomplish this by running the data through the layers of our encoder.\n","\n","The *decoder* works like encoder network in reverse. It works to recreate the input as closely as possible.  The training procedure produces at the center of the network a compressed, low dimensional representation that can be decoded to obtain the higher dimensional representation with minimal loss of information between the input and the output.\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","## Performance\n","---\n","After training has been completed, you can use the encoded data as a reliable low dimensional representation of the data.  This can be applied to many problems where dimensionality reduction seems appropriate.\n","\n","<img src=\"../images/dimensionalityPic.png\">\n","\n","This image was extracted from the G. E. Hinton and R. R. Salakhutdinovcomparing's <a href=\"https://www.cs.toronto.edu/~hinton/science.pdf\">paper</a>, on the two-dimensional reduction for 500 digits of the MNIST, with PCA (Principal Component Analysis) on the left and autoencoder on the right. We can see that the autoencoder provided us with a better separation of data.\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","## Training: Loss function\n","---\n","An autoencoder uses the <b>Loss</b> function to properly train the network. The Loss function will calculate the differences between our output and the expected results. After that, we can minimize this error with gradient descent. There are many types of Loss functions, and it is important to consider the type of problem (classification, regression, etc.) when choosing this funtion.\n"]},{"cell_type":"markdown","metadata":{},"source":["### Binary Values:\n","$$L(W) = -\\sum_{k} (x_k log(\\hat{x}_k) + (1 - x_k) \\log (1 - \\hat{x}_k)) $$\n"]},{"cell_type":"markdown","metadata":{},"source":["For binary values, we can use an equation based on the sum of Bernoulli's cross-entropy.  This loss function is best for binary classification problems.\n","\n","$x_k$ is one of our inputs and $\\hat{x}\\_k $ is the respective output.  Note that:\n","\n","$$\\hat{x} = f(x,W) $$\n","\n","Where $W$ is the full parameter set of the neural network.\n","\n","We use this function so that when $x_k=1$, we want the calculated value of $\\hat{x}_k $ to be very close to one, and likewise if $x_k=0$.\n","\n","If the value is one, we just need to calculate the first part of the formula, that is, $-x_klog(\\hat{x}_k)$. Which, turns out to just calculate $-log(\\hat{x}_k)$.  \n","\n","We explicitly exclude the second term to avoid numerical difficulties when computing the logarithm of very small numbers.\n","\n","Likewise, if the value is zero, we need to calculate just the second part, $(1 - x_k)log(1 - \\hat{x}_k)$, which turns out to be $log(1 - \\hat{x}_k)$.\n"]},{"cell_type":"markdown","metadata":{},"source":["### Real values:\n","$$L(W) = - \\frac{1}{2}\\sum_{k} (\\hat{x}_k- x_k \\ )^2$$\n"]},{"cell_type":"markdown","metadata":{},"source":["For data where the value (not category) is important to reproduce, we can use the sum of squared errors (SSE) for our *Loss* function. This function is usually used in regressions.\n","\n","As it was with the above example, $x_k$ is one of our inputs and $\\hat{x}_k$ is the respective output, and we want to make our output as similar as possible to our input.\n"]},{"cell_type":"markdown","metadata":{},"source":["### Computing Gradient\n","\n","The gradient of the loss function is an important and complex function.  It is defined as:\n","    $$\\nabla_{W} L(W)_j = \\frac{\\partial f(x,W)}{\\partial{W_j}}$$\n","\n","Fortunately for us, TensorFlow computes these complex functions automatically when we define our functions that are used to compute loss!  They automatically manage the backpropagation algorithm, which is an efficient way of computing the gradients in complex neural networks.\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","## Code\n","---\n"," We are going to use the MNIST dataset for our example.\n","The following code was created by Aymeric Damien. You can find some of his code in <a href=\"https://github.com/aymericdamien\">here</a>. We made some modifications which allow us to import the datasets to Jupyter Notebooks.\n"]},{"cell_type":"markdown","metadata":{},"source":["Let's call our imports and make the MNIST data available to use.\n"]},{"cell_type":"code","execution_count":1,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["/opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages/secretstorage/dhcrypto.py:16: CryptographyDeprecationWarning: int_from_bytes is deprecated, use int.from_bytes instead\n","  from cryptography.utils import int_from_bytes\n","/opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages/secretstorage/util.py:25: CryptographyDeprecationWarning: int_from_bytes is deprecated, use int.from_bytes instead\n","  from cryptography.utils import int_from_bytes\n","Collecting tensorflow==2.2.0rc0\n","  Downloading tensorflow-2.2.0rc0-cp37-cp37m-manylinux2010_x86_64.whl (515.9 MB)\n","\u001b[K     |████████████████████████████████| 515.9 MB 37 kB/s s eta 0:00:01\n","\u001b[?25hCollecting astunparse==1.6.3\n","  Downloading astunparse-1.6.3-py2.py3-none-any.whl (12 kB)\n","Requirement already satisfied: six>=1.12.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (1.15.0)\n","Requirement already satisfied: grpcio>=1.8.6 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (1.27.2)\n","Collecting gast==0.3.3\n","  Downloading gast-0.3.3-py2.py3-none-any.whl (9.7 kB)\n","Requirement already satisfied: absl-py>=0.7.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (0.9.0)\n","Requirement already satisfied: protobuf>=3.8.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (3.12.3)\n","Requirement already satisfied: opt-einsum>=2.3.2 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (3.1.0)\n","Requirement already satisfied: tensorboard<2.2.0,>=2.1.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (2.1.0)\n","Requirement already satisfied: tensorflow-estimator<2.2.0,>=2.1.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (2.1.0)\n","Requirement already satisfied: google-pasta>=0.1.8 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (0.2.0)\n","Requirement already satisfied: h5py<2.11.0,>=2.10.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (2.10.0)\n","Requirement already satisfied: wheel>=0.26; python_version >= \"3\" in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (0.34.2)\n","Collecting scipy==1.4.1; python_version >= \"3\"\n","  Downloading scipy-1.4.1-cp37-cp37m-manylinux1_x86_64.whl (26.1 MB)\n","\u001b[K     |████████████████████████████████| 26.1 MB 38.3 MB/s eta 0:00:01\n","\u001b[?25hRequirement already satisfied: wrapt>=1.11.1 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (1.12.1)\n","Requirement already satisfied: termcolor>=1.1.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (1.1.0)\n","Requirement already satisfied: keras-preprocessing>=1.1.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (1.1.0)\n","Requirement already satisfied: numpy<2.0,>=1.16.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorflow==2.2.0rc0) (1.18.5)\n","Requirement already satisfied: setuptools in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from protobuf>=3.8.0->tensorflow==2.2.0rc0) (47.3.1.post20200622)\n","Requirement already satisfied: werkzeug>=0.11.15 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (1.0.1)\n","Requirement already satisfied: requests<3,>=2.21.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (2.24.0)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (0.4.1)\n","Requirement already satisfied: google-auth<2,>=1.6.3 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (1.22.0)\n","Requirement already satisfied: markdown>=2.6.8 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (3.1.1)\n","Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (1.25.9)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (3.0.4)\n","Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (2021.5.30)\n","Requirement already satisfied: idna<3,>=2.5 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (2.9)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (1.3.0)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (4.1.1)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3.5\" in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (4.6)\n","Requirement already satisfied: aiohttp<4.0.0dev,>=3.6.2; python_version >= \"3.6\" in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (3.6.2)\n","Requirement already satisfied: oauthlib>=3.0.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (3.1.0)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from pyasn1-modules>=0.2.1->google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (0.4.8)\n","Requirement already satisfied: multidict<5.0,>=4.5 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from aiohttp<4.0.0dev,>=3.6.2; python_version >= \"3.6\"->google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (4.7.6)\n","Requirement already satisfied: attrs>=17.3.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from aiohttp<4.0.0dev,>=3.6.2; python_version >= \"3.6\"->google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (19.3.0)\n","Requirement already satisfied: async-timeout<4.0,>=3.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from aiohttp<4.0.0dev,>=3.6.2; python_version >= \"3.6\"->google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (3.0.1)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from aiohttp<4.0.0dev,>=3.6.2; python_version >= \"3.6\"->google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (1.5.1)\n","Requirement already satisfied: typing-extensions>=3.7.4; python_version < \"3.8\" in /opt/conda/envs/Python-3.7-main/lib/python3.7/site-packages (from yarl<2.0,>=1.0->aiohttp<4.0.0dev,>=3.6.2; python_version >= \"3.6\"->google-auth<2,>=1.6.3->tensorboard<2.2.0,>=2.1.0->tensorflow==2.2.0rc0) (3.7.4.2)\n","Installing collected packages: astunparse, gast, scipy, tensorflow\n","  Attempting uninstall: gast\n","    Found existing installation: gast 0.2.2\n","    Uninstalling gast-0.2.2:\n","      Successfully uninstalled gast-0.2.2\n","  Attempting uninstall: scipy\n","    Found existing installation: scipy 1.5.0\n","    Uninstalling scipy-1.5.0:\n","      Successfully uninstalled scipy-1.5.0\n","  Attempting uninstall: tensorflow\n","    Found existing installation: tensorflow 2.1.0\n"]},{"name":"stdout","output_type":"stream","text":["    Uninstalling tensorflow-2.1.0:\n","      Successfully uninstalled tensorflow-2.1.0\n","Successfully installed astunparse-1.6.3 gast-0.3.3 scipy-1.4.1 tensorflow-2.2.0rc0\n"]}],"source":["!pip install tensorflow==2.2.0rc0"]},{"cell_type":"markdown","metadata":{},"source":["Once tensorflow, numpy and matplotlib have been succesfully imported, the data set must be imported to the environment."]},{"cell_type":"code","execution_count":2,"metadata":{},"outputs":[],"source":["#from __future__ import division, print_function, absolute_import\n","\n","import tensorflow as tf\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline\n","\n","if not tf.__version__ == '2.2.0-rc0':\n","    print(tf.__version__)\n","    raise ValueError('please upgrade to TensorFlow 2.2.0-rc0, or restart your Kernel (Kernel->Restart & Clear Output)')\n","\n"]},{"cell_type":"markdown","metadata":{},"source":["Load the imported data using tensor flow (tf)."]},{"cell_type":"code","execution_count":3,"metadata":{"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n","11493376/11490434 [==============================] - 0s 0us/step\n"]}],"source":["# Import MINST data\n","mnist = tf.keras.datasets.mnist\n","(x_train, y_train), (x_test, y_test) = mnist.load_data()"]},{"cell_type":"markdown","metadata":{},"source":["When training a neural network, it is popular practice to use 32 bit precision. The newly configured type is then divided by 255 because that is the maximum value of a byte. By doing so, we will get an output that is between 0.0 and 1.0, which normalizes the data and allows for it to be scaled."]},{"cell_type":"code","execution_count":4,"metadata":{"tags":[]},"outputs":[],"source":["x_train = x_train.astype('float32') / 255.\n","x_test = x_test.astype('float32') / 255."]},{"cell_type":"code","execution_count":5,"metadata":{},"outputs":[],"source":["y_train = y_train.astype('float32') / 255.\n","y_test = y_test.astype('float32') / 255."]},{"cell_type":"markdown","metadata":{},"source":["Using -1 for the first dimension means that it is inferred using Tensor, based on the number of elements. "]},{"cell_type":"code","execution_count":6,"metadata":{},"outputs":[],"source":["x_image_train = tf.reshape(x_train, [-1,28,28,1])  \n","x_image_train = tf.cast(x_image_train, 'float32') \n","\n","x_image_test = tf.reshape(x_test, [-1,28,28,1]) \n","x_image_test = tf.cast(x_image_test, 'float32') "]},{"cell_type":"markdown","metadata":{},"source":["Print the newly trained shape."]},{"cell_type":"code","execution_count":7,"metadata":{"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 28, 28)\n"]}],"source":["print(x_train.shape)"]},{"cell_type":"markdown","metadata":{},"source":["We use the tf.keras.layers.Flatten() function to prepare the training data to be compatible with the encoding and decoding layer\n"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[],"source":["flatten_layer = tf.keras.layers.Flatten()\n","x_train = flatten_layer(x_train)"]},{"cell_type":"markdown","metadata":{},"source":["Notice how the <code>x_train.shape</code>  changes from (60000,28,28) to (60000, 784)\n"]},{"cell_type":"code","execution_count":9,"metadata":{"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["(60000, 784)\n"]}],"source":["print(x_train.shape)"]},{"cell_type":"markdown","metadata":{},"source":["Now, let's give the parameters that are going to be used by our NN.\n"]},{"cell_type":"code","execution_count":10,"metadata":{},"outputs":[],"source":["learning_rate = 0.01\n","training_epochs = 20\n","batch_size = 256\n","display_step = 1\n","examples_to_show = 10\n","global_step = tf.Variable(0)\n","total_batch = int(len(x_train) / batch_size)\n","\n","# Network Parameters\n","n_hidden_1 = 256 # 1st layer num features\n","n_hidden_2 = 128 # 2nd layer num features\n","encoding_layer = 32 # final encoding bottleneck features\n","n_input = 784 # MNIST data input (img shape: 28*28)\n","\n"]},{"cell_type":"markdown","metadata":{},"source":["### Encoder \n","---\n","Now we need to create our encoder. For this, we are going to use tf.keras.layers.Dense with sigmoidal activation functions. Sigmoidal functions delivers great results with this type of network. This is due to having a good derivative that is well-suited to backpropagation. We can create our encoder using the sigmoidal function like this:\n"]},{"cell_type":"code","execution_count":11,"metadata":{},"outputs":[],"source":["\n","enocoding_1 = tf.keras.layers.Dense(n_hidden_1, activation=tf.nn.sigmoid)\n","encoding_2 = tf.keras.layers.Dense(n_hidden_2, activation=tf.nn.sigmoid)\n","encoding_final = tf.keras.layers.Dense(encoding_layer, activation=tf.nn.relu)\n","\n","# Building the encoder\n","def encoder(x):\n","    x_reshaped = flatten_layer(x)\n","    # Encoder first layer with sigmoid activation #1\n","    layer_1 = enocoding_1(x_reshaped)\n","    # Encoder second layer with sigmoid activation #2\n","    layer_2 = encoding_2(layer_1)\n","    code = encoding_final(layer_2)\n","    return code"]},{"cell_type":"markdown","metadata":{},"source":["### Decoder\n","--- \n","\n","You can see that the layer_1 in the encoder is the layer_2 in the decoder and vice-versa.\n"]},{"cell_type":"code","execution_count":12,"metadata":{},"outputs":[],"source":["decoding_1 = tf.keras.layers.Dense(n_hidden_2, activation=tf.nn.sigmoid)\n","decoding_2 = tf.keras.layers.Dense(n_hidden_1, activation=tf.nn.sigmoid)\n","decoding_final = tf.keras.layers.Dense(n_input)\n","# Building the decoder\n","def decoder(x):\n","    # Decoder first layer with sigmoid activation #1\n","    layer_1 = decoding_1(x)\n","    # Decoder second layer with sigmoid activation #2\n","    layer_2 = decoding_2(layer_1)\n","    decode = self.decoding_final(layer_2)\n","    return decode"]},{"cell_type":"markdown","metadata":{},"source":["### Model Building \n","---"]},{"cell_type":"markdown","metadata":{},"source":["Let's construct our model.\n","We  define a <code>cost</code> function to calculate the loss  and a <code>grad</code> function to calculate gradients that will be used in backpropagation.\n"]},{"cell_type":"code","execution_count":13,"metadata":{},"outputs":[],"source":["class AutoEncoder(tf.keras.Model):\n","    def __init__(self):\n","        super(AutoEncoder, self).__init__()\n","\n","        self.n_hidden_1 = n_hidden_1 # 1st layer num features\n","        self.n_hidden_2 = n_hidden_2 # 2nd layer num features\n","        self.encoding_layer = encoding_layer\n","        self.n_input = n_input # MNIST data input (img shape: 28*28)\n","\n","        self.flatten_layer = tf.keras.layers.Flatten()\n","        self.enocoding_1 = tf.keras.layers.Dense(self.n_hidden_1, activation=tf.nn.sigmoid)\n","        self.encoding_2 = tf.keras.layers.Dense(self.n_hidden_2, activation=tf.nn.sigmoid)\n","        self.encoding_final = tf.keras.layers.Dense(self.encoding_layer, activation=tf.nn.relu)\n","        self.decoding_1 = tf.keras.layers.Dense(self.n_hidden_2, activation=tf.nn.sigmoid)\n","        self.decoding_2 = tf.keras.layers.Dense(self.n_hidden_1, activation=tf.nn.sigmoid)\n","        self.decoding_final = tf.keras.layers.Dense(self.n_input)\n","\n","\n","    # Building the encoder\n","    def encoder(self,x):\n","        #x = self.flatten_layer(x)\n","        layer_1 = self.enocoding_1(x)\n","        layer_2 = self.encoding_2(layer_1)\n","        code = self.encoding_final(layer_2)\n","        return code\n","        \n","\n","    # Building the decoder\n","    def decoder(self, x):\n","        layer_1 = self.decoding_1(x)\n","        layer_2 = self.decoding_2(layer_1)\n","        decode = self.decoding_final(layer_2)\n","        return decode\n","\n","        \n","    def call(self, x):\n","        encoder_op  = self.encoder(x)\n","        # Reconstructed Images\n","        y_pred = self.decoder(encoder_op)\n","        return y_pred\n","        \n","def cost(y_true, y_pred):\n","    loss = tf.losses.mean_squared_error(y_true, y_pred)\n","    cost = tf.reduce_mean(loss)\n","    return cost\n","\n","def grad(model, inputs, targets):\n","    #print('shape of inputs : ',inputs.shape)\n","    #targets = flatten_layer(targets)\n","    with tf.GradientTape() as tape:    \n","        reconstruction = model(inputs)\n","        loss_value = cost(targets, reconstruction)\n","    return loss_value, tape.gradient(loss_value, model.trainable_variables),reconstruction"]},{"cell_type":"markdown","metadata":{},"source":["### Model Training\n","---"]},{"cell_type":"markdown","metadata":{},"source":["For training we will run for 20 epochs.\n"]},{"cell_type":"code","execution_count":14,"metadata":{"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch: 0001 cost= 0.047383860\n","Epoch: 0002 cost= 0.034424357\n","Epoch: 0003 cost= 0.026695287\n","Epoch: 0004 cost= 0.021944303\n","Epoch: 0005 cost= 0.018585758\n","Epoch: 0006 cost= 0.017007928\n","Epoch: 0007 cost= 0.014737891\n","Epoch: 0008 cost= 0.013177762\n","Epoch: 0009 cost= 0.012001665\n","Epoch: 0010 cost= 0.010665350\n","Epoch: 0011 cost= 0.010004511\n","Epoch: 0012 cost= 0.009467856\n","Epoch: 0013 cost= 0.008427640\n","Epoch: 0014 cost= 0.008222684\n","Epoch: 0015 cost= 0.007554033\n","Epoch: 0016 cost= 0.007430729\n","Epoch: 0017 cost= 0.006798379\n","Epoch: 0018 cost= 0.006933126\n","Epoch: 0019 cost= 0.006883329\n","Epoch: 0020 cost= 0.007033682\n","Optimization Finished!\n"]}],"source":["model = AutoEncoder()\n","optimizer = tf.keras.optimizers.RMSprop(learning_rate)\n","\n","for epoch in range(training_epochs):\n","    for i in range(total_batch):\n","        x_inp = x_train[i : i + batch_size]\n","        loss_value, grads, reconstruction = grad(model, x_inp, x_inp)\n","        optimizer.apply_gradients(zip(grads, model.trainable_variables))\n","    # Display logs per epoch step\n","    if epoch % display_step == 0:\n","        print(\"Epoch:\", '%04d' % (epoch+1),\n","              \"cost=\", \"{:.9f}\".format(loss_value))\n","\n","print(\"Optimization Finished!\")"]},{"cell_type":"markdown","metadata":{},"source":["### Model Testing\n","---\n","Now, let's apply encoder and decoder for our tests.\n"]},{"cell_type":"code","execution_count":15,"metadata":{},"outputs":[],"source":["# Applying encode and decode over test set\n","encode_decode = model(flatten_layer(x_image_test[:examples_to_show]))"]},{"cell_type":"markdown","metadata":{},"source":["Let's simply visualize our graphs!\n"]},{"cell_type":"code","execution_count":16,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 720x144 with 20 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["# Compare original images with their reconstructions\n","f, a = plt.subplots(2, 10, figsize=(10, 2))\n","for i in range(examples_to_show):\n","    a[0][i].imshow(np.reshape(x_image_test[i], (28, 28)))\n","    a[1][i].imshow(np.reshape(encode_decode[i], (28, 28)))"]},{"cell_type":"markdown","metadata":{},"source":["As you can see, the reconstructions were successful. It can be seen that some noise were added to the image.\n"]},{"cell_type":"markdown","metadata":{},"source":["<hr>\n"]},{"cell_type":"markdown","metadata":{},"source":["## Want to learn more?\n","\n","Running deep learning programs usually needs a high performance platform. **PowerAI** speeds up deep learning and AI. Built on IBM’s Power Systems, **PowerAI** is a scalable software platform that accelerates deep learning and AI with blazing performance for individual users or enterprises. The **PowerAI** platform supports popular machine learning libraries and dependencies including TensorFlow, Caffe, Torch, and Theano. You can use [PowerAI on IMB Cloud](https://cocl.us/ML0120EN_PAI).\n","\n","Also, you can use **Watson Studio** to run these notebooks faster with bigger datasets. **Watson Studio** is IBM’s leading cloud solution for data scientists, built by data scientists. With Jupyter notebooks, RStudio, Apache Spark and popular libraries pre-packaged in the cloud, **Watson Studio** enables data scientists to collaborate on their projects without having to install anything. Join the fast-growing community of **Watson Studio** users today with a free account at [Watson Studio](https://cocl.us/ML0120EN_DSX). This is the end of this lesson. Thank you for reading this notebook, and good luck!\n"]},{"cell_type":"markdown","metadata":{},"source":["### Thanks for completing this lesson!\n"]},{"cell_type":"markdown","metadata":{},"source":["Created by <a href=\"https://www.linkedin.com/in/franciscomagioli\">Francisco Magioli</a>, <a href=\"https://ca.linkedin.com/in/erich-natsubori-sato\">Erich Natsubori Sato</a>, <a href=\"https://ca.linkedin.com/in/saeedaghabozorgi\">Saeed Aghabozorgi</a>\n","\n","Updated to TF 2.X by  <a href=\"https://www.linkedin.com/in/samaya-madhavan\"> Samaya Madhavan </a> \n","\n","Added to IBM Developer by [Dhivya Lakshminarayanan](https://www.linkedin.com/in/dhivya-lak/)\n"]},{"cell_type":"markdown","metadata":{},"source":["### References:\n","\n","-   [https://en.wikipedia.org/wiki/Autoencoder](https://en.wikipedia.org/wiki/Autoencoder?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [http://www.slideshare.net/billlangjun/simple-introduction-to-autoencoder](http://www.slideshare.net/billlangjun/simple-introduction-to-autoencoder?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [http://www.slideshare.net/danieljohnlewis/piotr-mirowski-review-autoencoders-deep-learning-ciuuk14](http://www.slideshare.net/danieljohnlewis/piotr-mirowski-review-autoencoders-deep-learning-ciuuk14?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [https://cs.stanford.edu/~quocle/tutorial2.pdf](https://cs.stanford.edu/~quocle/tutorial2.pdf?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   <https://gist.github.com/hussius/1534135a419bb0b957b9>\n","-   [http://www.deeplearningbook.org/contents/autoencoders.html](http://www.deeplearningbook.org/contents/autoencoders.html?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [http://www.kdnuggets.com/2015/03/deep-learning-curse-dimensionality-autoencoders.html/](http://www.kdnuggets.com/2015/03/deep-learning-curse-dimensionality-autoencoders.html?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [https://www.youtube.com/watch?v=xTU79Zs4XKY](https://www.youtube.com/watch?v=xTU79Zs4XKY&cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n","-   [http://www-personal.umich.edu/~jizhu/jizhu/wuke/Stone-AoS82.pdf](http://www-personal.umich.edu/~jizhu/jizhu/wuke/Stone-AoS82.pdf?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ)\n"]},{"cell_type":"markdown","metadata":{},"source":["<hr>\n","\n","Copyright © 2018 [Cognitive Class](https://cocl.us/DX0108EN_CC). This notebook and its source code are released under the terms of the [MIT License](https://bigdatauniversity.com/mit-license?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ&cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-DL0120EN-SkillsNetwork-20629446&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ).\n"]}],"metadata":{"interpreter":{"hash":"31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"},"kernelspec":{"display_name":"Python 3.7","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.10"},"widgets":{"state":{},"version":"1.1.2"}},"nbformat":4,"nbformat_minor":4}