vert Torch VAE DEEP KERAS-CVGrid-CleanedUpload.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import math\n",
    "import os\n",
    "import os\n",
    "import pickle\n",
    "import random\n",
    "import shutil\n",
    "import time\n",
    "\n",
    "import keras\n",
    "import moviepy.video.io.ImageSequenceClip\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pptk\n",
    "import tensorflow as tf\n",
    "from keras import backend as K\n",
    "from keras.backend import clear_session\n",
    "from keras.callbacks import TensorBoard\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import Normalizer\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from tensorflow.keras import regularizers\n",
    "from tqdm.notebook import tqdm\n",
    "print('Tensorflow: ', tf.__version__)\n",
    "from keras import layers\n",
    "import datetime\n",
    "from PIL import Image\n",
    "import glob\n",
    "from keras.optimizers import Adam\n",
    "import tensorflow_addons as tfa\n",
    "from keras.wrappers.scikit_learn import KerasRegressor\n",
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.model_selection import (\n",
    "    GridSearchCV,\n",
    "    KFold,\n",
    "    RandomizedSearchCV,\n",
    "    RepeatedKFold,\n",
    "    StratifiedKFold,\n",
    "    cross_val_score,\n",
    "    cross_validate,\n",
    "    train_test_split,\n",
    ")\n",
    "from keras.optimizers import Adam\n",
    "from sklearn.model_selection import ParameterGrid\n",
    "\n",
    "\n",
    "\n",
    "# Before instantiating a tf.data.Dataset obj & before model creation, call:\n",
    "clear_session()\n",
    "\n",
    "# Hyperparameter and architecture search for a deep variational autoencoder on 3d point cloud/mesh/vertex data\n",
    "# Published July 2022. S.H.\n",
    "# Network capable of learning and generating 3d mesh structures\n",
    "# Pass examples as 1d vectors.\n",
    "# Multiple related meshes may be passed as concatenated vectors of point coordinates [xyzxyzxyz] + [xyzxyz]. Network learns relation.\n",
    "# network dimensions collapse to a latent vector, decending width.\n",
    "# to tweak/grid search:\n",
    "# optimal latent vector size may vary\n",
    "# optimal layer depth and compression dimension varies depending on input complexity\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def image_grid(imgs, rows, cols):\n",
    "    assert len(imgs) == rows*cols\n",
    "\n",
    "    w, h = imgs[0].size\n",
    "    grid = Image.new('RGB', size=(cols*w, rows*h))\n",
    "    grid_w, grid_h = grid.size\n",
    "    \n",
    "    for i, img in enumerate(imgs):\n",
    "        grid.paste(img, box=(i%cols*w, i//cols*h))\n",
    "    return grid"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def calc_closest_factors(c: int):\n",
    "    \"\"\"Calculate the closest two factors of c.\n",
    "    \n",
    "    Returns:\n",
    "      [int, int]: The two factors of c that are closest; in other words, the\n",
    "        closest two integers for which a*b=c. If c is a perfect square, the\n",
    "        result will be [sqrt(c), sqrt(c)]; if c is a prime number, the result\n",
    "        will be [1, c]. The first number will always be the smallest, if they\n",
    "        are not equal.\n",
    "    \"\"\"    \n",
    "    if c//1 != c:\n",
    "        raise TypeError(\"c must be an integer.\")\n",
    "\n",
    "    a, b, i = 1, c, 0\n",
    "    while a < b:\n",
    "        i += 1\n",
    "        if c % i == 0:\n",
    "            a = i\n",
    "            b = c//a\n",
    "    \n",
    "    return [b, a]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Clear previous tensorboard data\n",
    "try:\n",
    "    shutil.rmtree(\"M:\\\\keras_env\\\\train\")\n",
    "except:\n",
    "    pass"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "try:\n",
    "    shutil.rmtree(\"M:\\\\keras_env\\\\validation\")\n",
    "except:\n",
    "    pass"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Read RAW data\n",
    "#Read in 1d data arrays for each mesh/point cloud in the form[x1,y1,z1, x2,y2,z2.... xn, yn, zn]\n",
    "#Each row of the data frame/matrix should be one example.\n",
    "df = pd.read_csv('1d_xyz_vertex_point_cloud_data.csv')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "\n",
    "df.drop('Unnamed: 0', inplace = True, axis=1)\n",
    "#df.drop('index', inplace = True, axis=1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Add additional data, for more samples, boot strap.\n",
    "merges = pd.read_csv(\"merges.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "merges.drop('Unnamed: 0', inplace = True, axis=1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "df = df.append(merges)#.copy()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# open a file, where you stored the pickled data\n",
    "file = open('mask_array', 'rb')\n",
    "\n",
    "# dump information to that file\n",
    "data = pickle.load(file)\n",
    "\n",
    "# close the file\n",
    "file.close()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "mask_array = data"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "mask_array = [str(x) for x in mask_array]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "apply_mask = False"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "if(apply_mask):\n",
    "    df = df[mask_array].copy()\n",
    "    \n",
    "else:\n",
    "    mask_array = np.ones(len(df.iloc[0]))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Scale for NN, inverse scale later\n",
    "scaler = StandardScaler()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#scaler = MinMaxScaler()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#scaler = Normalizer()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "scaler.fit(df)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "scale = True"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "if(scale):\n",
    "    df = scaler.transform(df)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "x_train, x_test, = train_test_split(\n",
    "     df, test_size=0.2, random_state=0)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#1d array of xyzxyzxyz...\n",
    "\n",
    "original_dim = 11496\n",
    "intermediate_dim = 64\n",
    "latent_dim = 2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#These layers can be changed\n",
    "original_dim = df.shape[1]\n",
    "\n",
    "scale_factor = 12\n",
    "\n",
    "intermediate_dim = int(original_dim/scale_factor)\n",
    "\n",
    "deep_dim_one = int(intermediate_dim/2)\n",
    "\n",
    "latent_dim = 2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(intermediate_dim,deep_dim_one,int(deep_dim_one/2), int(deep_dim_one/4), latent_dim)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "kernel_regularizer_val = 0.000001\n",
    "activity_regularizer = 0.0"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "inputs = keras.Input(shape=(original_dim,))\n",
    "\n",
    "h = layers.Dense(intermediate_dim, activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                activity_regularizer=regularizers.L2(activity_regularizer))(inputs)\n",
    "\n",
    "h1 = layers.Dense(deep_dim_one, activation='relu')(h)\n",
    "\n",
    "z_mean = layers.Dense(latent_dim)(h1)\n",
    "\n",
    "z_log_sigma = layers.Dense(latent_dim)(h1)\n",
    "\n",
    "def sampling(args):\n",
    "    z_mean, z_log_sigma = args\n",
    "    epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim),\n",
    "                              mean=0., stddev=0.1)\n",
    "    return z_mean + K.exp(z_log_sigma) * epsilon\n",
    "\n",
    "z = layers.Lambda(sampling)([z_mean, z_log_sigma])\n",
    "\n",
    "# Create encoder\n",
    "encoder = keras.Model(inputs, [z_mean, z_log_sigma, z], name='encoder')\n",
    "\n",
    "# Create decoder\n",
    "latent_inputs = keras.Input(shape=(latent_dim,), name='z_sampling')\n",
    "x = layers.Dense(int(deep_dim_one/10),\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(latent_inputs)\n",
    "\n",
    "outputs = layers.Dense(original_dim, activation='sigmoid')(x)\n",
    "decoder = keras.Model(latent_inputs, outputs, name='decoder')\n",
    "\n",
    "# instantiate VAE model\n",
    "outputs = decoder(encoder(inputs)[2])\n",
    "\n",
    "vae = keras.Model(inputs, outputs, name='vae_mlp')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Create encoder\n",
    "encoder = keras.Model(inputs, [z_mean, z_log_sigma, z], name='encoder')\n",
    "\n",
    "# Create decoder\n",
    "latent_inputs = keras.Input(shape=(latent_dim,), name='z_sampling')\n",
    "x = layers.Dense(int(deep_dim_one/10),\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(latent_inputs)\n",
    "\n",
    "x1 = layers.Dense(int(deep_dim_one/8),\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(x)\n",
    "\n",
    "x2 = layers.Dense(int(deep_dim_one/6),\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(x1)\n",
    "\n",
    "x3 = layers.Dense(int(deep_dim_one/4),\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(x2)\n",
    "\n",
    "x4 = layers.Dense(int(deep_dim_one/2),\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(x3)\n",
    "\n",
    "x5 = layers.Dense(deep_dim_one,\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(x4)\n",
    "\n",
    "x6 = layers.Dense(intermediate_dim,\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(x5)\n",
    "\n",
    "#x =  layers.Dropout(0.02)(x) #exp\n",
    "\n",
    "outputs = layers.Dense(original_dim, activation='sigmoid')(x6)\n",
    "decoder = keras.Model(latent_inputs, outputs, name='decoder')\n",
    "\n",
    "# instantiate VAE model\n",
    "outputs = decoder(encoder(inputs)[2])\n",
    "\n",
    "vae = keras.Model(inputs, outputs, name='vae_mlp')\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#encoder"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "print(intermediate_dim,\n",
    "      deep_dim_one,\n",
    "      deep_dim_one/2,\n",
    "      int(deep_dim_one/4),\n",
    "      int(deep_dim_one/6),\n",
    "      int(deep_dim_one/8),\n",
    "      int(deep_dim_one/10))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#decoder"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "print( int(deep_dim_one/10),\n",
    "      int(deep_dim_one/8),\n",
    "      int(deep_dim_one/6),\n",
    "      int(deep_dim_one/4),\n",
    "      int(deep_dim_one/2),\n",
    "      int(deep_dim_one),\n",
    "      int(intermediate_dim))\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#sgd = optimizers.SGD(lr=0.01, clipnorm=1.)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "initial_learning_rate = 0.0007\n",
    "\n",
    "lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
    "    initial_learning_rate,\n",
    "    decay_steps=100000,\n",
    "    decay_rate=0.96, #96\n",
    "    staircase=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "momentum = 0.8"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "opt_adam = Adam(clipnorm=0.01,\n",
    "                learning_rate = 0.002) #lr_schedule) #0.000005)\n",
    "#opt_adam = Adam(clipvalue=0.5)\n",
    "\n",
    "#opt_adam = Adam(clipvalue=0.5,clipnorm=0.01)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "opt_adam.get_config()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#reconstruction_loss = keras.losses.binary_crossentropy(inputs, outputs)\n",
    "loss_fn = tf.keras.losses.MeanSquaredError(reduction='sum_over_batch_size')\n",
    "reconstruction_loss = loss_fn(inputs, outputs)\n",
    "\n",
    "reconstruction_loss *= original_dim\n",
    "kl_loss = 1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma)\n",
    "kl_loss = K.sum(kl_loss, axis=-1)\n",
    "kl_loss *= -0.5\n",
    "vae_loss = K.mean(reconstruction_loss + kl_loss)\n",
    "vae.add_loss(vae_loss)\n",
    "vae.compile(optimizer=opt_adam)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from keras.utils.vis_utils import plot_model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#print(vae.summary())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#plot_model(vae, to_file='model_plot.png', show_shapes=True, show_layer_names=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "x_train.shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from keras.callbacks import Callback\n",
    "\n",
    "class stopAtLossValue(Callback):\n",
    "\n",
    "        def on_batch_end(self, batch, logs={}):\n",
    "            THR = 1000.03 #Assign THR with the value at which you want to stop training.\n",
    "            THR_L = -THR\n",
    "            if logs.get('loss') <= THR and logs.get('loss') >= THR_L:\n",
    "                 self.model.stop_training = True"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "original_dim = df.shape[1]\n",
    "\n",
    "scale_factor = 12\n",
    "\n",
    "intermediate_dim = int(original_dim/scale_factor)\n",
    "\n",
    "deep_dim_one = int(intermediate_dim/2)\n",
    "\n",
    "latent_dim = 2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "int(deep_dim_one/(0+1))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def create_model(\n",
    "    layers_param=1,\n",
    "    kernel_reg=tf.keras.regularizers.l1_l2(l1=0, l2=0),\n",
    "    width=15,\n",
    "    learning_rate=0.01,\n",
    "    dropout_val=0.2,\n",
    "    input_dim_val=df.shape[1],\n",
    "    scale_factor = 12\n",
    "):\n",
    "    \n",
    "    original_dim = df.shape[1]\n",
    "\n",
    "    #scale_factor = 12\n",
    "\n",
    "    intermediate_dim = int(original_dim/scale_factor)\n",
    "\n",
    "    deep_dim_one = int(intermediate_dim/2)\n",
    "\n",
    "    latent_dim = 2\n",
    "    \n",
    "    \n",
    "    inputs = keras.Input(shape=(original_dim,))\n",
    "\n",
    "    h = layers.Dense(intermediate_dim, activation='relu',\n",
    "                     kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                    activity_regularizer=regularizers.L2(activity_regularizer))(inputs)\n",
    "\n",
    "    h1 = layers.Dense(deep_dim_one, activation='relu')(h)\n",
    "    \n",
    "    live_h = h1\n",
    "    for i in range(0, layers_param):\n",
    "        print(int(deep_dim_one/(i+1)))\n",
    "        h2 = layers.Dense(int(deep_dim_one/(i+1)), activation='relu')(live_h)\n",
    "        live_h = h2\n",
    "\n",
    "    z_mean = layers.Dense(latent_dim)(h2)\n",
    "\n",
    "    z_log_sigma = layers.Dense(latent_dim)(h2)\n",
    "\n",
    "    def sampling(args):\n",
    "        z_mean, z_log_sigma = args\n",
    "        epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim),\n",
    "                                  mean=0., stddev=0.1)\n",
    "        return z_mean + K.exp(z_log_sigma) * epsilon\n",
    "\n",
    "    z = layers.Lambda(sampling)([z_mean, z_log_sigma])\n",
    "\n",
    "    # Create encoder\n",
    "    encoder = keras.Model(inputs, [z_mean, z_log_sigma, z], name='encoder')\n",
    "\n",
    "    # Create decoder\n",
    "    latent_inputs = keras.Input(shape=(latent_dim,), name='z_sampling')\n",
    "    x = layers.Dense(int(deep_dim_one/10),\n",
    "                     #kernel_initializer='ones',\n",
    "                     activation='relu',\n",
    "                     kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                     activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "\n",
    "                    )(latent_inputs)\n",
    "    \n",
    "    live_h = x\n",
    "    for j in range(layers_param+1,0, -1):\n",
    "        print(int(deep_dim_one/(j+1)))\n",
    "        x1 = layers.Dense(int(deep_dim_one/(j+1)), #flip? reverse..?\n",
    "                 #kernel_initializer='ones',\n",
    "                 activation='relu',\n",
    "                 kernel_regularizer=regularizers.L1(kernel_regularizer_val),\n",
    "                 activity_regularizer=regularizers.L2(activity_regularizer)\n",
    "                 \n",
    "                )(live_h)\n",
    "        live_h = x1\n",
    "    \n",
    "\n",
    "    outputs = layers.Dense(original_dim, activation='sigmoid')(x1)\n",
    "    decoder = keras.Model(latent_inputs, outputs, name='decoder')\n",
    "\n",
    "    # instantiate VAE model\n",
    "    outputs = decoder(encoder(inputs)[2])\n",
    "\n",
    "    vae = keras.Model(inputs, outputs, name='vae_mlp')\n",
    "    #return inputs, outputs\n",
    "    loss_fn = tf.keras.losses.MeanSquaredError(reduction='sum_over_batch_size')\n",
    "    reconstruction_loss = loss_fn(inputs, outputs)\n",
    "\n",
    "    reconstruction_loss *= original_dim\n",
    "    kl_loss = 1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma)\n",
    "    kl_loss = K.sum(kl_loss, axis=-1)\n",
    "    kl_loss *= -0.5\n",
    "    vae_loss = K.mean(reconstruction_loss + kl_loss)\n",
    "    vae.add_loss(vae_loss)\n",
    "    vae.compile(optimizer=opt_adam)\n",
    "    return vae"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "metric = tfa.metrics.r_square.RSquare()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "opt_adam = Adam(clipnorm=0.01,\n",
    "                learning_rate = 0.002)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "parameters = {'learning_rate': [0.0001, 0.001, 0.00001, 0.00005],\n",
    "             'layers_param': [2, 3, 4],\n",
    "             'scale_factor':[12, 24, 36, 48, 60]}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "kmodel = KerasRegressor(\n",
    "        build_fn=create_model, verbose=0, learning_rate=0.0001, layers_param=1, width=1\n",
    "    )\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    kmodel, parameters, verbose=3, cv=[(slice(None), slice(None))]\n",
    ")  # Negate CV in param search for speed\n",
    "\n",
    "pg = ParameterGrid(parameters)\n",
    "pg = len(pg)\n",
    "print(pg)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "int(df.shape[1]/40)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "grid.fit(x_train,\n",
    "        x_train,\n",
    "         batch_size = int(df.shape[1]/10),\n",
    "         epochs=300,\n",
    "        callbacks=[TensorBoard(log_dir='M:\\\\keras_env'),\n",
    "                  tf.keras.callbacks.TerminateOnNaN(),\n",
    "                  tf.keras.callbacks.EarlyStopping(monitor='loss', mode='auto', verbose=1, patience=400, restore_best_weights=True),\n",
    "                  stopAtLossValue(),\n",
    "                  tf.keras.callbacks.ModelCheckpoint(\"M:\\\\kerascheckpoints\", monitor='loss', save_best_only=False,\n",
    "                 mode='auto', save_freq=5000)])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "grid.best_params_"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "estimator = KerasRegressor(\n",
    "        build_fn=create_model, verbose=0, learning_rate=0.0001, layers_param=3, width=1, scale_factor = 60\n",
    "    )"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "estimator.fit(x_train,\n",
    "        x_train,\n",
    "        batch_size = int(df.shape[1]/20),\n",
    "         epochs=300,\n",
    "        callbacks=[TensorBoard(log_dir='M:\\\\keras_env'),\n",
    "                  tf.keras.callbacks.TerminateOnNaN(),\n",
    "                  tf.keras.callbacks.EarlyStopping(monitor='loss', mode='auto', verbose=1, patience=400, restore_best_weights=True),\n",
    "                  stopAtLossValue(),\n",
    "                  tf.keras.callbacks.ModelCheckpoint(\"M:\\\\kerascheckpoints\", monitor='loss', save_best_only=False,\n",
    "                 mode='auto', save_freq=5000)])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "estimator.model.summary()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "len(estimator.model.layers)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "estimator.model.layers"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "estimator.model.layers"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "break\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from keras.utils.vis_utils import plot_model \n",
    "plot_model(estimator, to_file='layers_plot.png', show_shapes=True, show_layer_names=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "ayers = estimator.weights\n",
    "[ layers[i].name for i in range( len(layers) ) ]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "b"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "KerasRegressor(\n",
    "        build_fn=create_model, verbose=0, learning_rate=0.0001, layers=1, width=1\n",
    "    ).fit(x_train, x_train,\n",
    "        epochs=100000,\n",
    "        batch_size=int(x_train.shape[0]/1),\n",
    "        #validation_data=(x_test, x_test),\n",
    "        #validation_data=(x_train, x_train),\n",
    "       callbacks=[TensorBoard(log_dir='M:\\\\keras_env'),\n",
    "                  tf.keras.callbacks.TerminateOnNaN(),\n",
    "                  tf.keras.callbacks.EarlyStopping(monitor='loss', mode='auto', verbose=1, patience=400, restore_best_weights=True),\n",
    "                  stopAtLossValue(),\n",
    "                  tf.keras.callbacks.ModelCheckpoint(\"M:\\\\kerascheckpoints\", monitor='loss', save_best_only=False,\n",
    "                 mode='auto', save_freq=5000)])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def create_model(\n",
    "    layers=1,\n",
    "    kernel_reg=tf.keras.regularizers.l1_l2(l1=0, l2=0),\n",
    "    width=15,\n",
    "    learning_rate=0.01,\n",
    "    dropout_val=0.2,\n",
    "    input_dim_val=len(X.columns),\n",
    "):\n",
    "\n",
    "    # create model\n",
    "    model = Sequential()\n",
    "    for i in range(0, layers):\n",
    "        model.add(\n",
    "            Dense(\n",
    "                math.floor(width),\n",
    "                input_dim=len(X.columns),\n",
    "                kernel_initializer=\"normal\",\n",
    "                activation=\"relu\",\n",
    "                kernel_constraint=maxnorm(4),\n",
    "                kernel_regularizer=kernel_reg,\n",
    "            )\n",
    "        )\n",
    "\n",
    "    model.add(Dropout(dropout_val))\n",
    "    model.add(Dense(1, kernel_initializer=\"normal\", activation=\"relu\"))\n",
    "    # Compile model\n",
    "    optimizer = Adam(learning_rate=learning_rate)\n",
    "\n",
    "    metric = tfa.metrics.r_square.RSquare()\n",
    "\n",
    "    model.compile(\n",
    "        loss=\"mean_squared_error\",\n",
    "        optimizer=optimizer,\n",
    "        metrics=[metric, \"mean_squared_error\", rmse],\n",
    "    )\n",
    "\n",
    "    # print(kernel_reg.get_config())\n",
    "    return model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "metric_list = [\"neg_mean_absolute_error\", \"r2\"]\n",
    "\n",
    "scores = cross_validate(\n",
    "        vae,\n",
    "        X_train,\n",
    "        X_train,\n",
    "        scoring=metric_list,\n",
    "        cv=cv,  # Full CV on final best model\n",
    "        n_jobs=1,\n",
    "        verbose=0,\n",
    "    )"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#pd.DataFrame(df).describe()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#vae.summary()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import visualkeras\n",
    "#visualkeras.layered_view(vae)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from ann_visualizer.visualize import ann_viz;\n",
    "#Build your model here\n",
    "#ann_viz(vae)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "x_train.shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "vae.history.history['loss'][0]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "vae.history.history['loss'][-1]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "vae.history.history['loss'][-1] / len(x_train)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "decoded_imgs = encoder.predict(x_test, batch_size=x_train.shape[0])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "n = 15\n",
    "grid_x = np.linspace(-15, 15, n)\n",
    "grid_y = np.linspace(-15, 15, n)\n",
    "\n",
    "grid_dims = []\n",
    "\n",
    "for i, yi in enumerate(grid_x):\n",
    "    for j, xi in enumerate(grid_y):\n",
    "        \n",
    "        to_append = np.linspace(xi, yi, latent_dim)\n",
    "        grid_dims.append(to_append)\n",
    "        #print((xi,yi))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "z_sample = np.linspace(0, 1, latent_dim).reshape(1,-1)\n",
    "x_decoded = decoder.predict(z_sample)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "if(scale):\n",
    "    x_decoded = scaler.inverse_transform(x_decoded)\n",
    "   \n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(len(grid_dims))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "counter = 0\n",
    "for i in range(0, len(grid_dims), 6):\n",
    "    \n",
    "    try:\n",
    "        z_sample = np.array(grid_dims[i])\n",
    "        z_sample = z_sample.reshape(1,-1)\n",
    "\n",
    "        x_decoded = decoder.predict(z_sample)\n",
    "        x_decoded = scaler.inverse_transform(x_decoded)\n",
    "        print(grid_dims[i])\n",
    "        print(x_decoded)\n",
    "        print(\" \")\n",
    "        div = int(len(mask_array)/3)\n",
    "        #print(div)\n",
    "        if(x_decoded[0][0] > 0.1):\n",
    "\n",
    "            x = x_decoded[0].reshape(div,3)[:,0]\n",
    "            y = x_decoded[0].reshape(div,3)[:,1]\n",
    "            z = x_decoded[0].reshape(div,3)[:,2]\n",
    "            points = np.vstack((x, y, z)).transpose()\n",
    "\n",
    "            v = pptk.viewer(points)\n",
    "            #v.set(lookat = (0.15379477,   1.502563  , 115.0956955), phi = 1.57079637, theta=0.09817477, r = 52.53429031)\n",
    "            v.set(lookat = (6.88162446e-02, 8.74810934e-01, 1.21469368e+02), phi = 1.57079637, theta=-0.11467963, r = 30.0)\n",
    "\n",
    "            v.capture(\"M:\\\\pptk_capture\\\\\" + str(i) +\".png\")\n",
    "            time.sleep(2)\n",
    "            v.close()\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "        pass"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "filenames = os.listdir(\"M:\\\\pptk_capture\\\\\")\n",
    "temp = []\n",
    "for file in filenames:\n",
    "    if(\"png\" in file):\n",
    "        temp.append(int(file.split(\".\")[0]))\n",
    "temp.sort()\n",
    "\n",
    "temp2 = []\n",
    "for file in temp:\n",
    "    temp2.append(str(file) + \".png\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "folder_time = datetime.datetime.now().strftime(\"%Y-%m-%d_%I-%M-%S_%p\")\n",
    "folder_time"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "pre = 'M:\\\\pptk_capture\\\\'\n",
    "image_folder='folder_with_images'\n",
    "fps=2\n",
    "\n",
    "image_files = temp2.copy()\n",
    "\n",
    "for i in range(0, len(image_files)):\n",
    "    image_files[i] = pre + image_files[i]\n",
    "\n",
    "\n",
    "clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(image_files, fps=fps)\n",
    "\n",
    "#clip.write_videofile('M:\\\\pptk_capture\\\\vid.webm')\n",
    "clip.write_videofile(\"M:\\\\pptk_archive\\\\\" + folder_time +str(scale_factor) +\"_\" + str(intermediate_dim)+\"_\"+ str(deep_dim_one)+\"_\"+ str(latent_dim)+\"_\"+str(vae.history.history['loss'][-1]) +\".webm\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "image_list = []\n",
    "#for filename in glob.glob('M:\\pptk_capture\\*.png'):\n",
    "for filename in glob.glob('miscimg\\*.png'):\n",
    "    im=Image.open(filename)\n",
    "    image_list.append(im)\n",
    "\n",
    "grid_dims = calc_closest_factors(75)\n",
    "grid = image_grid(image_list, rows=grid_dims[0], cols=grid_dims[1])\n",
    "folder_time = datetime.datetime.now().strftime(\"%Y-%m-%d_%I-%M-%S_%p\")\n",
    "\n",
    "im1 = grid.save(\"M:\\\\pptk_archive\\\\\" + folder_time +str(scale_factor) +\"_\" + str(intermediate_dim)+\"_\"+ str(deep_dim_one)+\"_\"+ str(latent_dim)+\"_\"+str(vae.history.history['loss'][-1]) +\".png\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "break"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "keras environment",
   "language": "python",
   "name": "keras_env"
  },
  "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.9"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}