5.0-GAIA-fashion-mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xRTcUSEcTw_2"
   },
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/timsainb/tensorflow2-generative-models/blob/master/5.0-GAIA-fashion-mnist.ipynb)\n",
    "\n",
    "## Generative adversarial interpolative autoencoder (GAIA) ([article](https://arxiv.org/abs/1807.06650)) \n",
    "GAIA is an autoencoder trained to learn convex latent representations by adversarially training on interpolations in latent space projections of real data. \n",
    "\n",
    "![generative adversarial interpolative autoencoding network](https://github.com/timsainb/tensorflow2-generative-models/blob/64fc8d699fc093cd6e8e2da689bd77db0c52f577/imgs/gaia.png?raw=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EqJby4CNTw_-"
   },
   "source": [
    "### Install packages if in colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5OS1jEoNTxAA"
   },
   "outputs": [],
   "source": [
    "### install necessary packages if in colab\n",
    "def run_subprocess_command(cmd):\n",
    "    process = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\n",
    "    for line in process.stdout:\n",
    "        print(line.decode().strip())\n",
    "\n",
    "\n",
    "import sys, subprocess\n",
    "\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "colab_requirements = [\"pip install tf-nightly-gpu-2.0-preview==2.0.0.dev20190513\",\n",
    "                     \"pip install tfp-nightly==0.7.0.dev20190508\",\n",
    "                     ]\n",
    "if IN_COLAB:\n",
    "    for i in colab_requirements:\n",
    "        run_subprocess_command(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8vi5CAnfTxAx"
   },
   "source": [
    "#### Note: This is a modified version of GAIA from the [original manuscript](https://arxiv.org/abs/1807.06650). It's been simplified significantly and no longer requires any hyperparameters (other than learning rate)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xBfoZFlGTxA0"
   },
   "source": [
    "### load packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:53.080422Z",
     "start_time": "2019-05-10T23:02:48.695964Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "9YdL0K5xTxA2",
    "outputId": "c869609a-7d77-41c9-b4c3-0880ddf23bb3"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/cube/tsainbur/conda_envs/tpy3/lib/python3.6/site-packages/tqdm/autonotebook/__init__.py:14: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
      "  \" (e.g. in jupyter console)\", TqdmExperimentalWarning)\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm.autonotebook import tqdm\n",
    "%matplotlib inline\n",
    "from IPython import display\n",
    "import pandas as pd\n",
    "from tensorflow_probability.python.distributions import Chi2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:53.085836Z",
     "start_time": "2019-05-10T23:02:53.082662Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "Vo19TAeVTxBI",
    "outputId": "57385c69-319e-4c14-8baf-b8fcb1d00603"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0-dev20190510\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LM1xalhkTxBR"
   },
   "source": [
    "### Create a fashion-MNIST dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:53.176505Z",
     "start_time": "2019-05-10T23:02:53.087656Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "GC0gNAvHTxBU"
   },
   "outputs": [],
   "source": [
    "TRAIN_BUF=60000\n",
    "BATCH_SIZE=64\n",
    "TEST_BUF=10000\n",
    "DIMS = (28,28,1)\n",
    "N_TRAIN_BATCHES =int(TRAIN_BUF/BATCH_SIZE)\n",
    "N_TEST_BATCHES = int(TEST_BUF/BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:58.612141Z",
     "start_time": "2019-05-10T23:02:53.179752Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "aOfDZYTxTxBb"
   },
   "outputs": [],
   "source": [
    "# load dataset\n",
    "(train_images, _), (test_images, _) = tf.keras.datasets.fashion_mnist.load_data()\n",
    "\n",
    "# split dataset\n",
    "train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype(\n",
    "    \"float32\"\n",
    ") / 255.0\n",
    "test_images = test_images.reshape(test_images.shape[0], 28, 28, 1).astype(\"float32\") / 255.0\n",
    "\n",
    "# batch datasets\n",
    "train_dataset = (\n",
    "    tf.data.Dataset.from_tensor_slices(train_images)\n",
    "    .shuffle(TRAIN_BUF)\n",
    "    .batch(BATCH_SIZE)\n",
    ")\n",
    "test_dataset = (\n",
    "    tf.data.Dataset.from_tensor_slices(test_images)\n",
    "    .shuffle(TEST_BUF)\n",
    "    .batch(BATCH_SIZE)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KimCFUI_TxBh"
   },
   "source": [
    "### Define the network as tf.keras.model object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:58.638319Z",
     "start_time": "2019-05-10T23:02:58.614106Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "nSqSteVYTxBj"
   },
   "outputs": [],
   "source": [
    "class GAIA(tf.keras.Model):\n",
    "    \"\"\"a basic gaia class for tensorflow\n",
    "\n",
    "    Extends:\n",
    "        tf.keras.Model\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GAIA, self).__init__()\n",
    "        self.__dict__.update(kwargs)\n",
    "\n",
    "        self.enc = tf.keras.Sequential(self.enc)\n",
    "        self.dec = tf.keras.Sequential(self.dec)\n",
    "\n",
    "        inputs, outputs = self.unet_function()\n",
    "        self.disc = tf.keras.Model(inputs=[inputs], outputs=[outputs])\n",
    "\n",
    "    def encode(self, x):\n",
    "        return self.enc(x)\n",
    "\n",
    "    def decode(self, z):\n",
    "        return self.dec(z)\n",
    "\n",
    "    def discriminate(self, x):\n",
    "        return self.disc(x)\n",
    "\n",
    "    def regularization(self, x1, x2):\n",
    "        return tf.reduce_mean(tf.square(x1 - x2))\n",
    "\n",
    "    @tf.function\n",
    "    def network_pass(self, x):\n",
    "        z = self.encode(x)\n",
    "        xg = self.decode(z)\n",
    "        zi = self._interpolate_z(z)\n",
    "        xi = self.decode(zi)\n",
    "        d_xi = self.discriminate(xi)\n",
    "        d_x = self.discriminate(x)\n",
    "        d_xg = self.discriminate(xg)\n",
    "        return z, xg, zi, xi, d_xi, d_x, d_xg\n",
    "\n",
    "    @tf.function\n",
    "    def compute_loss(self, x):\n",
    "        # run through network\n",
    "        z, xg, zi, xi, d_xi, d_x, d_xg = self.network_pass(x)\n",
    "\n",
    "        # compute losses\n",
    "        xg_loss = self.regularization(x, xg)\n",
    "        d_xg_loss = self.regularization(x, d_xg)\n",
    "        d_xi_loss = self.regularization(xi, d_xi)\n",
    "        d_x_loss = self.regularization(x, d_x)\n",
    "        return d_xg_loss, d_xi_loss, d_x_loss, xg_loss\n",
    "\n",
    "    @tf.function\n",
    "    def compute_gradients(self, x):\n",
    "        with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
    "            d_xg_loss, d_xi_loss, d_x_loss, xg_loss = self.compute_loss(x)\n",
    "\n",
    "            gen_loss = d_xg_loss + d_xi_loss\n",
    "            disc_loss = d_xg_loss + d_x_loss - tf.clip_by_value(d_xi_loss, 0, d_x_loss)\n",
    "\n",
    "        gen_gradients = gen_tape.gradient(\n",
    "            gen_loss, self.enc.trainable_variables + self.dec.trainable_variables\n",
    "        ) \n",
    "        disc_gradients = disc_tape.gradient(disc_loss, self.disc.trainable_variables)\n",
    "        return gen_gradients, disc_gradients\n",
    "\n",
    "    @tf.function\n",
    "    def apply_gradients(self, gen_gradients, disc_gradients):\n",
    "        self.gen_optimizer.apply_gradients(\n",
    "            zip(\n",
    "                gen_gradients,\n",
    "                self.enc.trainable_variables + self.dec.trainable_variables,\n",
    "            )\n",
    "        )\n",
    "        self.disc_optimizer.apply_gradients(\n",
    "            zip(disc_gradients, self.disc.trainable_variables)\n",
    "        )\n",
    "    \n",
    "    @tf.function\n",
    "    def train(self, x):\n",
    "        gen_gradients, disc_gradients = self.compute_gradients(x)\n",
    "        self.apply_gradients(gen_gradients, disc_gradients)\n",
    "\n",
    "    def _interpolate_z(self, z):\n",
    "        \"\"\" takes the dot product of some random tensor of batch_size,\n",
    "         and the z representation of the batch as the interpolation\n",
    "        \"\"\"\n",
    "        if self.chsq.df != z.shape[0]:\n",
    "            self.chsq = Chi2(df=1 / z.shape[0])\n",
    "        ip = self.chsq.sample((z.shape[0], z.shape[0]))\n",
    "        ip = ip / tf.reduce_sum(ip, axis=0)\n",
    "        zi = tf.transpose(tf.tensordot(tf.transpose(z), ip, axes=1))\n",
    "        return zi\n",
    "\n",
    "\n",
    "def sigmoid(x, shift=0.0, mult=20):\n",
    "    \"\"\" squashes a value with a sigmoid\n",
    "    \"\"\"\n",
    "    return tf.constant(1.0) / (\n",
    "        tf.constant(1.0) + tf.exp(-tf.constant(1.0) * ((x + tf.constant(shift)) * mult))\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NfpitTlFTxBv"
   },
   "source": [
    "### Define the network architecture\n",
    "- GAIA has an autoencoder as its generator, and a UNET as its descriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:58.746308Z",
     "start_time": "2019-05-10T23:02:58.639967Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "S_4k4XoCTxBw"
   },
   "outputs": [],
   "source": [
    "N_Z = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:58.833907Z",
     "start_time": "2019-05-10T23:02:58.747971Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "rBpSToGHTxCC"
   },
   "outputs": [],
   "source": [
    "def unet_convblock_down(\n",
    "    _input,\n",
    "    channels=16,\n",
    "    kernel=(3, 3),\n",
    "    activation=\"relu\",\n",
    "    pool_size=(2, 2),\n",
    "    kernel_initializer=\"he_normal\",\n",
    "):\n",
    "    \"\"\" An upsampling convolutional block for a UNET\n",
    "    \"\"\"\n",
    "    conv = tf.keras.layers.Conv2D(\n",
    "        channels,\n",
    "        kernel,\n",
    "        activation=activation,\n",
    "        padding=\"same\",\n",
    "        kernel_initializer=kernel_initializer,\n",
    "    )(_input)\n",
    "    conv = tf.keras.layers.Conv2D(\n",
    "        channels,\n",
    "        kernel,\n",
    "        activation=activation,\n",
    "        padding=\"same\",\n",
    "        kernel_initializer=kernel_initializer,\n",
    "    )(conv)\n",
    "    pool = tf.keras.layers.MaxPooling2D(pool_size=pool_size)(conv)\n",
    "    return conv, pool\n",
    "\n",
    "\n",
    "def unet_convblock_up(\n",
    "    last_conv,\n",
    "    cross_conv,\n",
    "    channels=16,\n",
    "    kernel=(3, 3),\n",
    "    activation=\"relu\",\n",
    "    pool_size=(2, 2),\n",
    "    kernel_initializer=\"he_normal\",\n",
    "):\n",
    "    \"\"\" A downsampling convolutional block for a UNET\n",
    "    \"\"\"\n",
    "\n",
    "    up_conv = tf.keras.layers.UpSampling2D(size=(2, 2))(last_conv)\n",
    "    merge = tf.keras.layers.concatenate([up_conv, cross_conv], axis=3)\n",
    "    conv = tf.keras.layers.Conv2D(\n",
    "        channels,\n",
    "        kernel,\n",
    "        activation=activation,\n",
    "        padding=\"same\",\n",
    "        kernel_initializer=kernel_initializer,\n",
    "    )(merge)\n",
    "    conv = tf.keras.layers.Conv2D(\n",
    "        channels,\n",
    "        kernel,\n",
    "        activation=activation,\n",
    "        padding=\"same\",\n",
    "        kernel_initializer=kernel_initializer,\n",
    "    )(conv)\n",
    "    return conv\n",
    "\n",
    "\n",
    "def unet_mnist():\n",
    "    \"\"\" the architecture for a UNET specific to MNIST\n",
    "    \"\"\"\n",
    "    inputs = tf.keras.layers.Input(shape=(28, 28, 1))\n",
    "    up_1, pool_1 = unet_convblock_down(inputs, channels=32)\n",
    "    up_2, pool_2 = unet_convblock_down(pool_1, channels=64)\n",
    "    conv_middle = tf.keras.layers.Conv2D(\n",
    "        128, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\"\n",
    "    )(pool_2)\n",
    "    conv_middle = tf.keras.layers.Conv2D(\n",
    "        128, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\"\n",
    "    )(conv_middle)\n",
    "    down_2 = unet_convblock_up(conv_middle, up_2, channels=64)\n",
    "    down_1 = unet_convblock_up(down_2, up_1, channels=32)\n",
    "    outputs = tf.keras.layers.Conv2D(1, (1, 1), activation=\"sigmoid\")(down_1)\n",
    "    return inputs, outputs\n",
    "\n",
    "\n",
    "encoder = [\n",
    "    tf.keras.layers.InputLayer(input_shape=DIMS),\n",
    "    tf.keras.layers.Conv2D(\n",
    "        filters=32, kernel_size=3, strides=(2, 2), activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2D(\n",
    "        filters=64, kernel_size=3, strides=(2, 2), activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(units=N_Z*2),\n",
    "]\n",
    "\n",
    "decoder = [\n",
    "    tf.keras.layers.Dense(units=7 * 7 * 64, activation=\"relu\"),\n",
    "    tf.keras.layers.Reshape(target_shape=(7, 7, 64)),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=64, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=32, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=1, kernel_size=3, strides=(1, 1), padding=\"SAME\", activation=\"sigmoid\"\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T18:40:40.306731Z",
     "start_time": "2019-05-10T18:40:40.292930Z"
    },
    "colab_type": "text",
    "id": "NPYtYgxSTxCH"
   },
   "source": [
    "### Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:02:59.710355Z",
     "start_time": "2019-05-10T23:02:58.835576Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "IDg5by1OTxCK"
   },
   "outputs": [],
   "source": [
    "# the unet function \n",
    "gen_optimizer = tf.keras.optimizers.Adam(1e-3, beta_1=0.5)\n",
    "disc_optimizer = tf.keras.optimizers.RMSprop(1e-3)\n",
    "    \n",
    "# model\n",
    "model = GAIA(\n",
    "    enc = encoder,\n",
    "    dec = decoder,\n",
    "    unet_function = unet_mnist,\n",
    "    gen_optimizer=gen_optimizer,\n",
    "    disc_optimizer = disc_optimizer,\n",
    "    chsq = Chi2(df=1 / BATCH_SIZE)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-HJ6qrw5TxCS"
   },
   "source": [
    "### Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:03:00.338845Z",
     "start_time": "2019-05-10T23:02:59.712093Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "42tCXUHMTxCU"
   },
   "outputs": [],
   "source": [
    "# exampled data for plotting results\n",
    "example_data = next(iter(train_dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:03:07.331536Z",
     "start_time": "2019-05-10T23:03:00.340829Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "MCklCQJzTxCb"
   },
   "outputs": [],
   "source": [
    "model.train(example_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:03:07.346895Z",
     "start_time": "2019-05-10T23:03:07.333797Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "4xwG1HCqTxCk"
   },
   "outputs": [],
   "source": [
    "def plot_reconstruction(model, example_data, nex=5, zm=3):\n",
    "    z, xg, zi, xi, d_xi, d_x, d_xg = model.network_pass(example_data)\n",
    "    fig, axs = plt.subplots(ncols=6, nrows = nex, figsize=(zm*6, zm*nex))\n",
    "    for axi, (dat, lab) in enumerate(\n",
    "        zip(\n",
    "            [example_data, d_x, xg, d_xg, xi, d_xi],\n",
    "            [\"data\", \"disc data\",\"gen\", \"disc gen\", \"interp\", \"disc interp\"],\n",
    "        )\n",
    "    ):\n",
    "        for ex in range(nex):\n",
    "            axs[ex, axi].matshow(dat.numpy()[ex].squeeze(), cmap = plt.cm.Greys, vmin=0, vmax=1)\n",
    "            axs[ex, axi].axis('off')\n",
    "        axs[0, axi].set_title(lab)\n",
    "        \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T23:03:07.465158Z",
     "start_time": "2019-05-10T23:03:07.350193Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "7xco2ckaTxCn"
   },
   "outputs": [],
   "source": [
    "# a pandas dataframe to save the loss information to\n",
    "losses = pd.DataFrame(columns = ['d_xg_loss', 'd_xi_loss', 'd_x_loss', 'xg_loss'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-11T00:56:46.240031Z",
     "start_time": "2019-05-10T23:07:32.155916Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "0Trrpp4kTxCu",
    "outputId": "7cbd8af2-3559-48a8-b1bf-1c953a4256c8",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 49\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x1080 with 30 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_epochs = 50\n",
    "for epoch in range(n_epochs):\n",
    "    # train\n",
    "    for batch, train_x in tqdm(\n",
    "        zip(range(N_TRAIN_BATCHES), train_dataset), total=N_TRAIN_BATCHES\n",
    "    ):\n",
    "        model.train(train_x)\n",
    "    # test on holdout\n",
    "    loss = []\n",
    "    for batch, test_x in tqdm(\n",
    "        zip(range(N_TEST_BATCHES), train_dataset), total=N_TEST_BATCHES\n",
    "    ):\n",
    "        loss.append(model.compute_loss(train_x))\n",
    "    losses.loc[len(losses)] = np.mean(loss, axis=0)\n",
    "    # plot results\n",
    "    display.clear_output()\n",
    "    print(\n",
    "        \"Epoch: {}\".format(epoch)\n",
    "    )\n",
    "    plot_reconstruction(model, example_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vyFWbSlgTxCy"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "5.0-GAIA-fashion-mnist.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}