2. Autoencoders-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Succesfull loaded: path_list, labels, split, image_type, file_npy\n",
      "Succesfull loaded: df_metadata_images\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import sys; sys.path.insert(0, '../Scripts')\n",
    "# import load_images\n",
    "from load_images import load_images, get_df_paths\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "from matplotlib import pyplot as plt\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def gen_data(n_train, n_gen, data_gen_args, n_load = 10):\n",
    "#     import random\n",
    "    seed = random.randint(100,10000)\n",
    "    ims = load_images(get_df_paths(n=n_load, random=False)) # Cargamos las imagenes reales\n",
    "    '''Revisar este punto. Tarda mucho en cargar dataset. Valorar crear pickle.'''\n",
    "#     print(\"ims cargadas\")\n",
    "    \n",
    "    n_ims = ims.shape[0]\n",
    "    if n_train<=1 & isinstance(n_train, float): #asumimos n_float como fracción\n",
    "        n_train = int(np.round(n_ims*n_train))\n",
    "    \n",
    "    ims_train = ims[:n_train, :, :].astype(\"float16\")\n",
    "    ims_val = ims[n_train:, :, :].astype(\"float16\")\n",
    "    \n",
    "    # Generamos el DS de train. newaxis por posterior requerimiento de DataAugmentation\n",
    "    ds_train = tf.data.Dataset.from_tensor_slices((ims_train[:,:,:,np.newaxis],ims_train[:,:,:,np.newaxis]))\n",
    "    ds_val = tf.data.Dataset.from_tensor_slices((ims_val[:,:,:,np.newaxis], ims_val[:,:,:,np.newaxis]))\n",
    "#     print(\"ds_train y ds_val generados\")\n",
    "    \n",
    "    # Generamos DS de DataAugmentation\n",
    "    image_datagen = tf.keras.preprocessing.image.ImageDataGenerator(**data_gen_args)\n",
    "    im_iter = image_datagen.flow(ims_train[:,:,:,np.newaxis], batch_size=1, seed=seed) # Iterador/Generador\n",
    "    # TODO: Revisar batch_size y ims/ims_train\n",
    "    def generador():\n",
    "        aux_iter = im_iter.next()[0,:,:,:]\n",
    "        yield aux_iter, aux_iter\n",
    "        \n",
    "    ds_gen = tf.data.Dataset.from_generator(generador, output_types=(tf.float16, tf.float16),\n",
    "                                             output_shapes=([180,180,1], [180,180,1]))\n",
    "    \n",
    "    # SOME ARGUMENTS ARE DEPRECATED: (output_shapes, output_types). They will be removed in a future version. \n",
    "                                        #Instructions for updating: Use output_signature instead (no esta en esta version)\n",
    "#     ds_gen = tf.data.Dataset.from_generator(lambda: im_iter, \n",
    "#                                         output_signature=tf.TensorSpec(shape=(1,180,180,1), dtype=tf.float64))\n",
    "#     print(\"ds_gen generado\")\n",
    "    # Concatenamos ds_train y ds_gen, indicando cuantas imágenes se generan\n",
    "    print(\"ds_train shape: {}\\nds_gen shape: {}\".format(ds_train.element_spec,ds_gen.element_spec))\n",
    "    ds = ds_train.concatenate(ds_gen.take(n_gen)).filter(lambda x, y: tf.reduce_max(x)>0)\n",
    "#     print(\"ds concatenado\")\n",
    "#     ds = ds.shuffle(n_train+n_gen, reshuffle_each_iteration=True) \n",
    "    '''Revisar 1er argumento si problemas con la memoria'''\n",
    "    return(ds, ds_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data\n",
      "A total of 0 images has been omited due to its max value was 0\n",
      "ds_train shape: (TensorSpec(shape=(180, 180, 1), dtype=tf.float16, name=None), TensorSpec(shape=(180, 180, 1), dtype=tf.float16, name=None))\n",
      "ds_gen shape: (TensorSpec(shape=(180, 180, 1), dtype=tf.float16, name=None), TensorSpec(shape=(180, 180, 1), dtype=tf.float16, name=None))\n",
      "\n",
      "\n",
      "Num images: 3486\n",
      "Length: 2\n",
      "Shape: (180, 180, 1)\n",
      "Min & Max: 0.0 - 0.73876953125\n",
      "Dataset info: <FilterDataset shapes: ((180, 180, 1), (180, 180, 1)), types: (tf.float16, tf.float16)>\n"
     ]
    }
   ],
   "source": [
    "data_gen_args = dict(\n",
    "                     rotation_range=10, zoom_range=0.1)\n",
    "                     # shear_range=1)\n",
    "                     # width_shift_range=0.1,\n",
    "                     # height_shift_range=0.1,\n",
    "                     # zoom_range=0.2)\n",
    "            \n",
    "ds,ds_val = gen_data(0.8, 2000, data_gen_args, 0)\n",
    "a=ds.as_numpy_iterator().next()\n",
    "print(\"\\n\\nNum images: {}\\nLength: {}\\nShape: {}\\nMin & Max: {} - {}\\nDataset info: {}\".format(\n",
    "    len(list(ds.as_numpy_iterator())), len(a), a[0].shape, a[0].min(), a[0].max(), ds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2769"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a = ds.as_numpy_iterator().next()\n",
    "lista = []\n",
    "for a in ds.as_numpy_iterator():\n",
    "    lista.append(a[0].max())\n",
    "    if np.isnan(a[0].max()):\n",
    "        print(\"1 NaN\")\n",
    "np.min(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'lista' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-63-76d566a4b717>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlista\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mas_numpy_iterator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m# ds.element_spec\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'lista' is not defined"
     ]
    }
   ],
   "source": [
    "lista\n",
    "len(list(ds.as_numpy_iterator()))\n",
    "ds.element_spec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data\n",
      "ims cargadas\n",
      "ds_train y ds_val generados\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "seed = random.randint(100,10000)\n",
    "n_train=0.8\n",
    "n_gen=3000\n",
    "n_load = 0\n",
    "\n",
    "data_gen_args = dict(rotation_range=10, zoom_range=0.1)\n",
    "    \n",
    "ims = load_images(get_df_paths(n=n_load, random=False)) # Cargamos las imagenes reales\n",
    "'''Revisar este punto. Tarda mucho en cargar dataset. Valorar crear pickle.'''\n",
    "print(\"ims cargadas\")\n",
    "\n",
    "n_ims = ims.shape[0]\n",
    "if n_train<=1 & isinstance(n_train, float): #asumimos n_float como fracción\n",
    "    n_train = int(np.round(n_ims*n_train))\n",
    "\n",
    "ims_train = ims[:n_train, :, :].astype(\"float16\")\n",
    "ims_val = ims[n_train:, :, :].astype(\"float16\")\n",
    "\n",
    "# Generamos el DS de train. newaxis por posterior requerimiento de DataAugmentation\n",
    "ds_train = tf.data.Dataset.from_tensor_slices((ims_train[:,:,:,np.newaxis],ims_train[:,:,:,np.newaxis]))\n",
    "ds_val = tf.data.Dataset.from_tensor_slices((ims_val[:,:,:,np.newaxis], ims_val[:,:,:,np.newaxis]))\n",
    "print(\"ds_train y ds_val generados\")\n",
    "\n",
    "# Generamos DS de DataAugmentation\n",
    "image_datagen = tf.keras.preprocessing.image.ImageDataGenerator(**data_gen_args)\n",
    "im_iter = image_datagen.flow(ims_train[:,:,:,np.newaxis], batch_size=1, seed=seed) # Iterador/Generador\n",
    "# TODO: Revisar batch_size y ims/ims_train\n",
    "def generador():\n",
    "    aux_iter = im_iter.next()[0,:,:,:]\n",
    "    yield aux_iter, aux_iter\n",
    "\n",
    "ds_gen = tf.data.Dataset.from_generator(generador, output_types=(tf.float16, tf.float16), \n",
    "                                         output_shapes=([180,180,1], [180,180,1]))\n",
    "\n",
    "\n",
    "ds = ds_train.concatenate(ds_gen.take(n_gen))\n",
    "# a=ds_gen.as_numpy_iterator().next()\n",
    "# print(\"Num images: {}\\nLength: {}\\nShape: {}\\nMin & Max: {} - {}\\nDataset info: {}\".format(\n",
    "#     len(list(ds.as_numpy_iterator())), len(a), a[0].shape, a[0].min(), a[0].max(), ds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(180, 180, 1)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds_train.as_numpy_iterator().next()[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x27385d18188>"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(121)\n",
    "plt.imshow(a1[0,:,:,0], vmax=a1[0,:,:,0].max(),vmin=a1[0,:,:,0].min())\n",
    "plt.subplot(122)\n",
    "plt.imshow(a2[0,:,:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "58"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(1,1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext tensorboard\n",
    "import datetime\n",
    "\n",
    "\n",
    "#### Custom layer to sample the codings, given μ and γ \n",
    "# μ = mean\n",
    "# γ = log_var = log(sigma^2), where sigma is standard deviation\n",
    "class Sampling(keras.layers.Layer):\n",
    "    def call(self, inputs):\n",
    "        mean, log_var = inputs\n",
    "        return K.random_normal(tf.shape(log_var)) * K.exp(log_var / 2) + mean\n",
    "    \n",
    "    \n",
    "def encoder_block(inputs, n_filters, block_name):\n",
    "    \"\"\"\n",
    "    Custom block of layers to build the encoder\n",
    "    \"\"\"\n",
    "    with K.name_scope(block_name):\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, strides=(2, 2), kernel_size=3, padding='same')(inputs)\n",
    "#         bn = tf.keras.layers.BatchNormalization()(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, kernel_size=3, padding='same')(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, kernel_size=3, padding='same')(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "    return x    \n",
    "\n",
    "\n",
    "def decoder_block(inputs, n_filters, block_name, padding='same'):\n",
    "    \"\"\"\n",
    "    Custom block of layers to build the decoder\n",
    "    \"\"\"\n",
    "    with K.name_scope(block_name):\n",
    "#         x = tf.keras.layers.Dropout(rate=0.2, seed=666)(inputs)\n",
    "        x = tf.keras.layers.UpSampling2D((2,2), interpolation=\"bilinear\")(inputs)\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, strides=1, kernel_size=3, padding=padding)(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, strides=1, kernel_size=3, padding=\"same\", use_bias=False)(x)\n",
    "#         x = tf.keras.layers.BatchNormalization()(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "    return x \n",
    "\n",
    "\n",
    "def conv_block(inputs, n_filters, block_name, padding='same'):\n",
    "    \"\"\"\n",
    "    Custom block of layers to build the decoder\n",
    "    \"\"\"\n",
    "    with K.name_scope(block_name):\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, strides=1, kernel_size=3, padding=padding)(inputs)\n",
    "#         x = tf.keras.layers.LeakyReLU()(x)\n",
    "#         x = tf.keras.layers.Conv2D(filters=n_filters, strides=1, kernel_size=3, padding=\"same\", use_bias=False)(x)\n",
    "        x = tf.keras.layers.BatchNormalization()(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "#         x = tf.keras.layers.Conv2D(filters=n_filters, strides=1, kernel_size=3, padding=\"same\", use_bias=True)(x)\n",
    "#         x = tf.keras.layers.LeakyReLU()(x)\n",
    "        x = tf.keras.layers.Conv2D(filters=n_filters, strides=1, kernel_size=3, padding=\"same\", use_bias=False)(x)\n",
    "        x = tf.keras.layers.BatchNormalization()(x)\n",
    "        x = tf.keras.layers.LeakyReLU()(x)\n",
    "        output = x\n",
    "    return output \n",
    "\n",
    "\n",
    "class CVAE(tf.keras.Model):\n",
    "    def __init__(self, codings_size, learning_rate=1e-3):\n",
    "        super().__init__() #Ejecutamos init de tf.keras.Model\n",
    "        self.codings_size = codings_size\n",
    "        self.learning_rate = learning_rate\n",
    "        self.initial_epoch = 0\n",
    "        print(\"Inicializando...\")\n",
    "        ### Encoder\n",
    "        inputs = keras.Input(shape=[180, 180, 1]) # Revisar si es necesario esto\n",
    "        z = encoder_block(inputs, 4, \"Encoder_1\")\n",
    "        z = encoder_block(z, 8, \"Encoder_2\")\n",
    "        z = encoder_block(z, 16, \"Encoder_3\")\n",
    "        z = encoder_block(z, 32, \"Encoder_4\")\n",
    "        z = encoder_block(z, 64, \"Encoder_5\")\n",
    "        z = encoder_block(z, 128, \"Encoder_7\")\n",
    "        z = tf.keras.layers.Flatten()(z)\n",
    "        # No activation\n",
    "#         tf.keras.layers.Dense(latent_dim + latent_dim)(z)\n",
    "        codings_mean = keras.layers.Dense(codings_size)(z) # μ\n",
    "        codings_log_var = keras.layers.Dense(codings_size)(z) # γ\n",
    "        codings = Sampling()([codings_mean, codings_log_var])\n",
    "        self.encoder = keras.Model(\n",
    "            inputs=[inputs], outputs=[codings_mean, codings_log_var, codings], name=\"encoder\")\n",
    "        print(\"Encoder creado\")\n",
    "        ### Decoder\n",
    "        decoder_inputs = keras.layers.Input(shape=[codings_size])\n",
    "#         final_shape = int(180/(2**5)) # shape[0] at the encoding before flatten\n",
    "        print(\"Decoder Inputs creados\")\n",
    "        x = tf.keras.layers.Dense(units=6*6*64, activation=tf.nn.relu)(decoder_inputs)\n",
    "        print(\"Decoder primera densa creada\")\n",
    "        x = tf.keras.layers.Reshape(target_shape=(6, 6, 64))(x)\n",
    "        print(\"Decoder reshape hecho\")\n",
    "        x = decoder_block(x, 128, \"Decoder_1\")\n",
    "        x = decoder_block(x, 64, \"Decoder_2\")\n",
    "        x = decoder_block(x, 64, \"Decoder_3\", padding=\"valid\")\n",
    "        x = decoder_block(x, 32, \"Decoder_4\", padding=\"valid\")\n",
    "        x = decoder_block(x, 32, \"Decoder_5\")\n",
    "        decoder_output = tf.keras.layers.Conv2D(filters=1, kernel_size=3, strides=1, padding='same')(x)\n",
    "        x = conv_block(x, 32, \"Decoder_6\")\n",
    "#         x = tf.keras.layers.Concatenate()([decoder_output, x])\n",
    "        x = conv_block(x, 64, \"Decoder_7\")\n",
    "#         x = tf.keras.layers.Concatenate()([decoder_output, x])\n",
    "        x = conv_block(x, 128, \"Decoder_8\")\n",
    "        x = tf.keras.layers.Conv2D(filters=1, kernel_size=3, strides=1, padding='same')(x)\n",
    "        outputs = tf.keras.layers.Add()([decoder_output, x])\n",
    "            # No activation\n",
    "        print(\"Decoder Layers creados\")\n",
    "#         outputs = tf.keras.layers.Conv2D(\n",
    "#                 filters=1, kernel_size=3, strides=1, padding='same')(x)\n",
    "        self.decoder = keras.Model(inputs=[decoder_inputs], outputs=[outputs], name = \"decoder\")\n",
    "        print(\"Decoder creado\")\n",
    "        ### Final Model\n",
    "        _, _, codings = self.encoder(inputs) # two first arguments not needed\n",
    "        reconstructions = self.decoder(codings)\n",
    "        self.CVAE_model = keras.Model(inputs=[inputs], outputs=[reconstructions], name=\"CVAE\")\n",
    "        #### Latent loss and reconstruction loss\n",
    "        latent_loss = -0.5 * K.sum(\n",
    "            1 + codings_log_var - K.exp(codings_log_var) - K.square(codings_mean),\n",
    "            axis=-1)\n",
    "        self.CVAE_model.add_loss(K.mean(latent_loss) / 32400.) # 180*180 = 32400 -> Dividimos entre el número de píxeles.\n",
    "        self.CVAE_model.compile(loss=\"binary_crossentropy\", optimizer=tf.keras.optimizers.SGD(learning_rate=self.learning_rate))\n",
    "\n",
    "    def fit_model(self, X_train, X_val, epochs = 200, batch_size = 128):\n",
    "        self.epochs = epochs\n",
    "        self.batch_size = batch_size\n",
    "        self.CVAE_model.fit(X_train, X_train, epochs=epochs, batch_size=batch_size,\n",
    "                            validation_data=[X_val, X_val])\n",
    "        self.model_fitted = True\n",
    "        \n",
    "    def fit_model_2(self, X_train, X_val, lr_scheduler, epochs = 400, batch_size = 128):\n",
    "        '''To use with Dataset object as input'''\n",
    "        log_dir = \"logs/fit/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "        assert epochs > self.initial_epoch\n",
    "#         tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)\n",
    "        self.epochs = epochs\n",
    "        self.batch_size = batch_size\n",
    "        self.hist = self.CVAE_model.fit(X_train.batch(batch_size), \n",
    "                                        epochs=epochs, \n",
    "                                        validation_data=X_val.batch(batch_size),\n",
    "                                        callbacks=[keras.callbacks.LearningRateScheduler(lr_scheduler, verbose=0)],\n",
    "                                        initial_epoch=self.initial_epoch)\n",
    "        self.model_fitted = True\n",
    "        self.initial_epoch += epochs\n",
    "        return self.hist\n",
    "    \n",
    "    def generate_image(self, n_images = 6):\n",
    "        if not self.model_fitted:\n",
    "            print(\"Modelo no entrenado\")\n",
    "            \n",
    "        codings = tf.random.normal(shape=[n_images, self.codings_size])\n",
    "        return self.decoder(codings).numpy()\n",
    "    \n",
    "    def generate_and_show_images(self):\n",
    "        images = self.generate_image(n_images = 6)\n",
    "        plt.figure(figsize = (20,15))\n",
    "        plt.suptitle(f\"Conv_VAe \\ncoding_size = 10; epochs = {self.epochs}; batch_size = {self.batch_size}\\nn_train = 340; n_valid = 50\\nSystole - slice 4\")\n",
    "\n",
    "        for i in range(6):\n",
    "            plt.subplot(2,3,i+1)\n",
    "            plt.imshow(images[i,:,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inicializando...\n",
      "Encoder creado\n",
      "Decoder Inputs creados\n",
      "Decoder primera densa creada\n",
      "Decoder reshape hecho\n",
      "Decoder Layers creados\n",
      "Decoder creado\n",
      "Model: \"CVAE\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_1 (InputLayer)            [(None, 180, 180, 1) 0                                            \n",
      "__________________________________________________________________________________________________\n",
      "encoder (Model)                 [(None, 512), (None, 1672792     input_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "decoder (Model)                 (None, 180, 180, 1)  1932226     encoder[1][2]                    \n",
      "__________________________________________________________________________________________________\n",
      "conv2d (Conv2D)                 (None, 90, 90, 4)    40          input_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu (LeakyReLU)         (None, 90, 90, 4)    0           conv2d[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_1 (Conv2D)               (None, 90, 90, 4)    148         leaky_re_lu[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_1 (LeakyReLU)       (None, 90, 90, 4)    0           conv2d_1[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_2 (Conv2D)               (None, 90, 90, 4)    148         leaky_re_lu_1[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_2 (LeakyReLU)       (None, 90, 90, 4)    0           conv2d_2[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_3 (Conv2D)               (None, 45, 45, 8)    296         leaky_re_lu_2[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_3 (LeakyReLU)       (None, 45, 45, 8)    0           conv2d_3[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_4 (Conv2D)               (None, 45, 45, 8)    584         leaky_re_lu_3[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_4 (LeakyReLU)       (None, 45, 45, 8)    0           conv2d_4[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_5 (Conv2D)               (None, 45, 45, 8)    584         leaky_re_lu_4[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_5 (LeakyReLU)       (None, 45, 45, 8)    0           conv2d_5[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_6 (Conv2D)               (None, 23, 23, 16)   1168        leaky_re_lu_5[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_6 (LeakyReLU)       (None, 23, 23, 16)   0           conv2d_6[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_7 (Conv2D)               (None, 23, 23, 16)   2320        leaky_re_lu_6[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_7 (LeakyReLU)       (None, 23, 23, 16)   0           conv2d_7[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_8 (Conv2D)               (None, 23, 23, 16)   2320        leaky_re_lu_7[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_8 (LeakyReLU)       (None, 23, 23, 16)   0           conv2d_8[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_9 (Conv2D)               (None, 12, 12, 32)   4640        leaky_re_lu_8[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_9 (LeakyReLU)       (None, 12, 12, 32)   0           conv2d_9[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_10 (Conv2D)              (None, 12, 12, 32)   9248        leaky_re_lu_9[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_10 (LeakyReLU)      (None, 12, 12, 32)   0           conv2d_10[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_11 (Conv2D)              (None, 12, 12, 32)   9248        leaky_re_lu_10[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_11 (LeakyReLU)      (None, 12, 12, 32)   0           conv2d_11[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_12 (Conv2D)              (None, 6, 6, 64)     18496       leaky_re_lu_11[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_12 (LeakyReLU)      (None, 6, 6, 64)     0           conv2d_12[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_13 (Conv2D)              (None, 6, 6, 64)     36928       leaky_re_lu_12[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_13 (LeakyReLU)      (None, 6, 6, 64)     0           conv2d_13[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_14 (Conv2D)              (None, 6, 6, 64)     36928       leaky_re_lu_13[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_14 (LeakyReLU)      (None, 6, 6, 64)     0           conv2d_14[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_15 (Conv2D)              (None, 3, 3, 128)    73856       leaky_re_lu_14[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_15 (LeakyReLU)      (None, 3, 3, 128)    0           conv2d_15[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_16 (Conv2D)              (None, 3, 3, 128)    147584      leaky_re_lu_15[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_16 (LeakyReLU)      (None, 3, 3, 128)    0           conv2d_16[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_17 (Conv2D)              (None, 3, 3, 128)    147584      leaky_re_lu_16[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "leaky_re_lu_17 (LeakyReLU)      (None, 3, 3, 128)    0           conv2d_17[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "flatten (Flatten)               (None, 1152)         0           leaky_re_lu_17[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "dense_1 (Dense)                 (None, 512)          590336      flatten[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_AddV2 (TensorFlowOp [(None, 512)]        0           dense_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Exp (TensorFlowOpLa [(None, 512)]        0           dense_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "dense (Dense)                   (None, 512)          590336      flatten[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Sub (TensorFlowOpLa [(None, 512)]        0           tf_op_layer_AddV2[0][0]          \n",
      "                                                                 tf_op_layer_Exp[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Square (TensorFlowO [(None, 512)]        0           dense[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Sub_1 (TensorFlowOp [(None, 512)]        0           tf_op_layer_Sub[0][0]            \n",
      "                                                                 tf_op_layer_Square[0][0]         \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Sum (TensorFlowOpLa [(None,)]            0           tf_op_layer_Sub_1[0][0]          \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Mul (TensorFlowOpLa [(None,)]            0           tf_op_layer_Sum[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_Mean (TensorFlowOpL [()]                 0           tf_op_layer_Mul[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "tf_op_layer_RealDiv (TensorFlow [()]                 0           tf_op_layer_Mean[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "add_loss (AddLoss)              ()                   0           tf_op_layer_RealDiv[0][0]        \n",
      "==================================================================================================\n",
      "Total params: 3,605,018\n",
      "Trainable params: 3,604,122\n",
      "Non-trainable params: 896\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# len(list(ds.as_numpy_iterator()))\n",
    "cvae_model = CVAE(512)\n",
    "cvae_model.CVAE_model.summary()\n",
    "# cvae_model.decoder.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Found duplicated `Variable`s in Model's `weights`. This is usually caused by `Variable`s being shared by Layers in the Model. These `Variable`s will be treated as separate `Variable`s when the Model is restored. To avoid this, please save with `save_format=\"tf\"`.\n"
     ]
    }
   ],
   "source": [
    "# cvae_model.CVAE_model.save(\"cvae_model_20211025_loss_0.4222_val_loss_0.4203.h5\", save_format=\"tf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tensorboard extension is already loaded. To reload it, use:\n",
      "  %reload_ext tensorboard\n",
      "Inicializando...\n",
      "Encoder creado\n",
      "Decoder Inputs creados\n",
      "Decoder primera densa creada\n",
      "Decoder reshape hecho\n",
      "Decoder Layers creados\n",
      "Decoder creado\n",
      "Epoch 1/2100\n",
      "109/109 [==============================] - 36s 329ms/step - loss: 2.4317 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 2/2100\n",
      "109/109 [==============================] - 35s 324ms/step - loss: 2.4129 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 3/2100\n",
      "109/109 [==============================] - 35s 324ms/step - loss: 2.4131 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 4/2100\n",
      "109/109 [==============================] - 35s 325ms/step - loss: 2.4128 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 5/2100\n",
      "109/109 [==============================] - 35s 325ms/step - loss: 2.4129 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 6/2100\n",
      "109/109 [==============================] - 35s 325ms/step - loss: 2.4128 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 7/2100\n",
      "109/109 [==============================] - 35s 324ms/step - loss: 2.4131 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 8/2100\n",
      "109/109 [==============================] - 35s 324ms/step - loss: 2.4131 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 9/2100\n",
      "109/109 [==============================] - 35s 325ms/step - loss: 2.4132 - val_loss: 2.3895 - lr: 0.0050\n",
      "Epoch 10/2100\n",
      "109/109 [==============================] - 36s 329ms/step - loss: 2.4131 - val_loss: 2.3895 - lr: 0.0049\n",
      "Epoch 11/2100\n",
      "109/109 [==============================] - 36s 326ms/step - loss: 2.4129 - val_loss: 2.3895 - lr: 0.0049\n",
      "Epoch 12/2100\n",
      " 72/109 [==================>...........] - ETA: 10s - loss: 2.3722"
     ]
    }
   ],
   "source": [
    "%load_ext tensorboard\n",
    "import datetime\n",
    "\n",
    "def lr_scheduler(epoch, lr):\n",
    "    initial_learning_rate = 0.005\n",
    "    decay_steps = 300\n",
    "    alpha = 0.0000005\n",
    "    cosine_decay = 0.5 * (1 + np.cos(np.pi * epoch / decay_steps)) / (1+epoch/1000)\n",
    "    decayed = (1 - alpha) * cosine_decay + alpha\n",
    "    return initial_learning_rate * decayed\n",
    "\n",
    "# tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)\n",
    "\n",
    "\n",
    "cvae_model = CVAE(512, learning_rate=0.00005)\n",
    "# cvae_model.fit_model(X[:,:,:,np.newaxis], Y[:,:,:,np.newaxis])\n",
    "hist = cvae_model.fit_model_2(ds, ds_val, batch_size=32, epochs=cvae_model.initial_epoch + 2100,  lr_scheduler=lr_scheduler)\n",
    "# cvae_model.generate_and_show_images()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# if \"iterador\" not in globals():\n",
    "    iterador = ds.as_numpy_iterator()\n",
    "encoded_ims = []\n",
    "plt.figure(figsize=(20,10))\n",
    "for i in range(4):\n",
    "    im = iterador.next()[0][None, :, :, :]\n",
    "    encoded_ims.append(cvae_model.encoder(im))\n",
    "    imgen = cvae_model.CVAE_model.predict(im)\n",
    "#     print(imgen.shape)\n",
    "    plt.subplot(2,4,1+i)\n",
    "    print((2,5,1+i))\n",
    "    plt.imshow(im[0,:,:,0].astype(\"float32\"))\n",
    "    plt.subplot(2,4,5+i)\n",
    "    print((2,5,4+i))\n",
    "    plt.imshow(imgen[0,:,:,0].astype(\"float32\"))initial_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a168558e48>"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(121)\n",
    "plt.imshow(im[0,:,:,:].astype(\"float32\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20925e4be48>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 0\n",
    "plt.figure(figsize=(20,5))\n",
    "plt.plot(hist.history[\"loss\"][n:], label=\"loss\")\n",
    "plt.plot(hist.history[\"val_loss\"][n:], label=\"val_loss\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.81309824 0.21838272 0.40400171 0.62300598 0.7059388  0.94662184\n",
      " 0.25463538 0.43189022 0.99182365 0.86305555]\n",
      "[0.91957168 0.3465188  0.45116316 0.13884377 0.97735042 0.75179823\n",
      " 0.10077926 0.80364806 0.15312118 0.6631572 ]\n",
      "[0.11293162 0.44865339 0.12683959 0.53631563 0.35518164 0.38937002\n",
      " 0.55806623 0.17579241 0.82005789 0.6993984 ]\n",
      "[0.35838122 0.59846615 0.86766606 0.61315767 0.14494019 0.91610491\n",
      " 0.0867704  0.90630638 0.59305847 0.75038869]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "vector = np.random.rand(4,64)\n",
    "for i in range(4):\n",
    "    im = vector[i,:]\n",
    "    imgen = cvae_model.decoder.predict(im[None,:])\n",
    "#     print(imgen.shape)\n",
    "    plt.subplot(1,4,1+i)\n",
    "    print(im[:10])\n",
    "    plt.imshow(imgen[0,:,:,0].astype(\"float32\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Found duplicated `Variable`s in Model's `weights`. This is usually caused by `Variable`s being shared by Layers in the Model. These `Variable`s will be treated as separate `Variable`s when the Model is restored. To avoid this, please save with `save_format=\"tf\"`.\n"
     ]
    }
   ],
   "source": [
    "# cvae_model.CVAE_model.save(\"cvae_model_20210918_keras.h5\", save_format=\"tf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = next(ds.as_numpy_iterator())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.000e+00, 9.239e-06, 3.099e-05, ..., 6.333e-01, 6.338e-01,\n",
       "       6.377e-01], dtype=float16)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Error in loading the saved optimizer state. As a result, your model is starting with a freshly initialized optimizer.\n"
     ]
    }
   ],
   "source": [
    "class Sampling(tf.keras.layers.Layer):\n",
    "    def call(self, inputs):\n",
    "        mean, log_var = inputs\n",
    "        return K.random_normal(tf.shape(log_var)) * K.exp(log_var / 2) + mean\n",
    "\n",
    "model = tf.keras.models.load_model(\"./cvae_model_20210918_keras.h5\", custom_objects={'Sampling': Sampling})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder = model.get_layer(\"encoder\")\n",
    "decoder = model.get_layer(\"decoder\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.739"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if \"iterador\" not in globals():\n",
    "    iterador = ds_val.as_numpy_iterator()\n",
    "# a = next(iterador)\n",
    "plt.imshow(a[0].astype(\"float32\"))\n",
    "np.save(\"im.npy\", a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnknownError",
     "evalue": " Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.\n\t [[node encoder/conv2d_597/Conv2D (defined at <ipython-input-11-c47db85ffa29>:1) ]] [Op:__inference_predict_function_11788]\n\nFunction call stack:\npredict_function\n",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnknownError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-c47db85ffa29>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mencoder\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\keras\\engine\\training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m     86\u001b[0m       raise ValueError('{} is not supported in multi-worker mode.'.format(\n\u001b[0;32m     87\u001b[0m           method.__name__))\n\u001b[1;32m---> 88\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     89\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     90\u001b[0m   return tf_decorator.make_decorator(\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mpredict\u001b[1;34m(self, x, batch_size, verbose, steps, callbacks, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m   1266\u001b[0m           \u001b[1;32mfor\u001b[0m \u001b[0mstep\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msteps\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1267\u001b[0m             \u001b[0mcallbacks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mon_predict_batch_begin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1268\u001b[1;33m             \u001b[0mtmp_batch_outputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpredict_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1269\u001b[0m             \u001b[1;31m# Catch OutOfRangeError for Datasets of unknown size.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1270\u001b[0m             \u001b[1;31m# This blocks until the batch has finished executing.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    578\u001b[0m         \u001b[0mxla_context\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    579\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 580\u001b[1;33m       \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    581\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    582\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mtracing_count\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_tracing_count\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m_call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    648\u001b[0m               *args, **kwds)\n\u001b[0;32m    649\u001b[0m       \u001b[1;31m# If we did not create any variables the trace we have is good enough.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 650\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_concrete_stateful_fn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcanon_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcanon_kwds\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    651\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    652\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mfn_with_cond\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0minner_kwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[1;34m(self, args, kwargs)\u001b[0m\n\u001b[0;32m   1663\u001b[0m          if isinstance(t, (ops.Tensor,\n\u001b[0;32m   1664\u001b[0m                            resource_variable_ops.BaseResourceVariable))),\n\u001b[1;32m-> 1665\u001b[1;33m         self.captured_inputs)\n\u001b[0m\u001b[0;32m   1666\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1667\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m_call_flat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcancellation_manager\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[1;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[0;32m   1744\u001b[0m       \u001b[1;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1745\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[1;32m-> 1746\u001b[1;33m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[0;32m   1747\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[0;32m   1748\u001b[0m         \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[0;32m    596\u001b[0m               \u001b[0minputs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    597\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 598\u001b[1;33m               ctx=ctx)\n\u001b[0m\u001b[0;32m    599\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    600\u001b[0m           outputs = execute.execute_with_cancellation(\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     59\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[1;32m---> 60\u001b[1;33m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[0;32m     61\u001b[0m   \u001b[1;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     62\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnknownError\u001b[0m:  Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.\n\t [[node encoder/conv2d_597/Conv2D (defined at <ipython-input-11-c47db85ffa29>:1) ]] [Op:__inference_predict_function_11788]\n\nFunction call stack:\npredict_function\n"
     ]
    }
   ],
   "source": [
    "x = encoder.predict(a[0][None, :, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "InternalError",
     "evalue": " Blas GEMM launch failed : a.shape=(1, 64), b.shape=(64, 2304), m=1, n=2304, k=64\n\t [[node decoder/dense_80/MatMul (defined at <ipython-input-12-8c920a96cd53>:1) ]] [Op:__inference_predict_function_12187]\n\nFunction call stack:\npredict_function\n",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mInternalError\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-8c920a96cd53>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdecoder\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0.7\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m64\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\keras\\engine\\training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m     86\u001b[0m       raise ValueError('{} is not supported in multi-worker mode.'.format(\n\u001b[0;32m     87\u001b[0m           method.__name__))\n\u001b[1;32m---> 88\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     89\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     90\u001b[0m   return tf_decorator.make_decorator(\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mpredict\u001b[1;34m(self, x, batch_size, verbose, steps, callbacks, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m   1266\u001b[0m           \u001b[1;32mfor\u001b[0m \u001b[0mstep\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msteps\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1267\u001b[0m             \u001b[0mcallbacks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mon_predict_batch_begin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1268\u001b[1;33m             \u001b[0mtmp_batch_outputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpredict_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1269\u001b[0m             \u001b[1;31m# Catch OutOfRangeError for Datasets of unknown size.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1270\u001b[0m             \u001b[1;31m# This blocks until the batch has finished executing.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    578\u001b[0m         \u001b[0mxla_context\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    579\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 580\u001b[1;33m       \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    581\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    582\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mtracing_count\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_tracing_count\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m_call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    648\u001b[0m               *args, **kwds)\n\u001b[0;32m    649\u001b[0m       \u001b[1;31m# If we did not create any variables the trace we have is good enough.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 650\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_concrete_stateful_fn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcanon_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcanon_kwds\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    651\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    652\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mfn_with_cond\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0minner_kwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[1;34m(self, args, kwargs)\u001b[0m\n\u001b[0;32m   1663\u001b[0m          if isinstance(t, (ops.Tensor,\n\u001b[0;32m   1664\u001b[0m                            resource_variable_ops.BaseResourceVariable))),\n\u001b[1;32m-> 1665\u001b[1;33m         self.captured_inputs)\n\u001b[0m\u001b[0;32m   1666\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1667\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m_call_flat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcancellation_manager\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[1;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[0;32m   1744\u001b[0m       \u001b[1;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1745\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[1;32m-> 1746\u001b[1;33m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[0;32m   1747\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[0;32m   1748\u001b[0m         \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[0;32m    596\u001b[0m               \u001b[0minputs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    597\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 598\u001b[1;33m               ctx=ctx)\n\u001b[0m\u001b[0;32m    599\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    600\u001b[0m           outputs = execute.execute_with_cancellation(\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\eager\\execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     59\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[1;32m---> 60\u001b[1;33m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[0;32m     61\u001b[0m   \u001b[1;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     62\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mInternalError\u001b[0m:  Blas GEMM launch failed : a.shape=(1, 64), b.shape=(64, 2304), m=1, n=2304, k=64\n\t [[node decoder/dense_80/MatMul (defined at <ipython-input-12-8c920a96cd53>:1) ]] [Op:__inference_predict_function_12187]\n\nFunction call stack:\npredict_function\n"
     ]
    }
   ],
   "source": [
    " decoder.predict([[0.7 for x in range(64)]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}