initializations.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os, pickle\n",
    "\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '1'\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
    "np.set_printoptions(linewidth=120, precision=5, suppress=True)\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.config.optimizer.set_experimental_options({\n",
    "    'layout_optimizer': False,\n",
    "})\n",
    "\n",
    "from keras import backend as K\n",
    "from keras.layers import Input, Conv2D, GlobalAveragePooling2D, Dense, Lambda, BatchNormalization, Activation\n",
    "from keras.layers import multiply\n",
    "from keras.models import Model\n",
    "from keras import initializers\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "from layers import conv_init_linear, conv_init_relu, conv_init_relu2\n",
    "from layers import depthwiseconv_init_linear, depthwiseconv_init_relu\n",
    "from layers import normal_init, uniform_init\n",
    "\n",
    "all_results = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "he:             stddev = sqrt(2 / fan_in)\n",
    "glorot/xavier:  stddev = sqrt(2 / (fan_in + fan_out))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Activation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_statistics(conv_block, initializers, activations, plot=False):\n",
    "    input_shape = (128,64,64,40)\n",
    "    x = np.random.randn(*input_shape)\n",
    "\n",
    "    print('%-33s %7s %7s %7s %7s' % ('', 'mean', 'std', 'var', 'meanabs'))\n",
    "    print('%-33s %7.3f %7.3f %7.3f %7.2f' % ('input', np.mean(x), np.std(x), np.var(x), np.mean(np.abs(x))))\n",
    "\n",
    "    for acti in activations:\n",
    "        print(acti)\n",
    "        for init in initializers:\n",
    "            \n",
    "            x1 = x_in = Input(input_shape[1:]) \n",
    "            x1 = conv_block(x1, init, acti)\n",
    "            if type(x1) is list:\n",
    "                x1 = multiply(x1)\n",
    "            model = Model(x_in, x1)\n",
    "\n",
    "            y = model.predict(x, verbose=0)\n",
    "            \n",
    "            init_name = init if type(init) == str else init.__name__\n",
    "            print(' %-32s %7.3f %7.3f %7.3f %7.2f' % (init_name, np.mean(y), np.std(y), np.var(y), np.mean(np.abs(y))))\n",
    "\n",
    "            if plot:\n",
    "                plt.figure(figsize=(8,2))\n",
    "                plt.axvline(np.mean(x), alpha=0.5, linestyle='--', color='tab:blue')\n",
    "                plt.axvline(np.mean(y), alpha=0.5, linestyle='--', color='tab:orange')\n",
    "                sns.histplot(x[0,:,:,0:4].flatten(), bins=24, kde=True, linewidth=0)\n",
    "                sns.histplot(y[0,:,:,0:4].flatten(), bins=24, kde=True, linewidth=0)\n",
    "                plt.title('%s, %s' % (acti, init_name)); plt.grid()\n",
    "                plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                     mean     std     var meanabs\n",
      "input                              -0.000   1.000   1.000    0.80\n",
      "linear\n",
      " he_uniform                        -0.001   1.416   2.006    1.13\n",
      " he_normal                         -0.001   1.398   1.954    1.11\n",
      " glorot_uniform                     0.001   1.191   1.418    0.95\n",
      " glorot_normal                      0.000   1.194   1.426    0.95\n",
      " conv_init_linear                   0.000   1.003   1.006    0.80\n",
      " conv_init_relu                    -0.000   1.407   1.980    1.12\n",
      " normal_init                       -0.006  18.996 360.854   15.15\n",
      " uniform_init                      -0.012  18.983 360.349   15.14\n",
      "relu\n",
      " he_uniform                         0.564   0.826   0.682    0.56\n",
      " he_normal                          0.556   0.815   0.664    0.56\n",
      " glorot_uniform                     0.479   0.702   0.492    0.48\n",
      " glorot_normal                      0.477   0.699   0.488    0.48\n",
      " conv_init_linear                   0.404   0.591   0.350    0.40\n",
      " conv_init_relu                     0.557   0.816   0.666    0.56\n",
      " normal_init                        7.482  10.963 120.192    7.48\n",
      " uniform_init                       7.596  11.117 123.592    7.60\n"
     ]
    }
   ],
   "source": [
    "# Conv2D\n",
    "\n",
    "initializers = [\n",
    "    'he_uniform',\n",
    "    'he_normal',\n",
    "    'glorot_uniform',\n",
    "    'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "    normal_init,\n",
    "    uniform_init,\n",
    "]\n",
    "\n",
    "activations = ['linear', 'relu']\n",
    "\n",
    "def conv_block(x, initializer, activation):\n",
    "    x = Conv2D(16,3, use_bias=False, kernel_initializer=initializer, activation=activation)(x)\n",
    "    return x\n",
    "\n",
    "calc_statistics(conv_block, initializers, activations, plot=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                     mean     std     var meanabs\n",
      "input                              -0.000   1.000   1.000    0.80\n",
      "linear\n",
      " conv_init_linear                   0.001   0.989   0.979    0.79\n",
      " conv_init_relu                     0.000   1.402   1.967    1.12\n",
      " normal_init                        0.020  19.269 371.282   15.36\n",
      " uniform_init                       0.011  18.942 358.795   15.11\n",
      "relu\n",
      " conv_init_linear                   0.398   0.582   0.339    0.40\n",
      " conv_init_relu                     0.558   0.817   0.667    0.56\n",
      " normal_init                        7.341  10.766 115.914    7.34\n",
      " uniform_init                       7.659  11.205 125.542    7.66\n"
     ]
    }
   ],
   "source": [
    "# SparseConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "    normal_init,\n",
    "    uniform_init,\n",
    "]\n",
    "\n",
    "activations = ['linear', 'relu']\n",
    "\n",
    "def conv_block(x, initializer, activation):\n",
    "    from layers import SparseConv2D\n",
    "    #xm = [x, Lambda(lambda x: tf.ones_like(x)[:,:,:,:1])(x)]\n",
    "    xm = x\n",
    "    xm = SparseConv2D(6, 3, kernel_initializer=initializer, activation=activation)(xm)\n",
    "    return xm\n",
    "\n",
    "calc_statistics(conv_block, initializers, activations, plot=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                     mean     std     var meanabs\n",
      "input                               0.000   1.000   1.001    0.80\n",
      "linear\n",
      " conv_init_linear                   0.000   0.998   0.997    0.80\n",
      " conv_init_relu                     0.001   1.442   2.079    1.15\n",
      " normal_init                       -0.009  19.104 364.975   15.24\n",
      " uniform_init                       0.002  18.790 353.050   14.99\n",
      "relu\n",
      " conv_init_linear                   0.399   0.584   0.342    0.40\n",
      " conv_init_relu                     0.559   0.818   0.669    0.56\n",
      " normal_init                        7.577  11.084 122.863    7.58\n",
      " uniform_init                       7.583  11.104 123.304    7.58\n"
     ]
    }
   ],
   "source": [
    "# PartialConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "    normal_init,\n",
    "    uniform_init,\n",
    "]\n",
    "\n",
    "activations = ['linear', 'relu']\n",
    "\n",
    "def conv_block(x, initializer, activation):\n",
    "    from layers import PartialConv2D\n",
    "    #xm = [x, Lambda(lambda x: tf.ones_like(x)[:,:,:,:1])(x)]\n",
    "    xm = x\n",
    "    xm = PartialConv2D(6, 3, kernel_initializer=initializer, activation=activation)(xm)\n",
    "    return xm\n",
    "\n",
    "calc_statistics(conv_block, initializers, activations, plot=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                     mean     std     var meanabs\n",
      "input                              -0.000   1.000   1.000    0.80\n",
      "linear\n",
      " conv_init_linear                   0.000   0.156   0.024    0.12\n",
      " conv_init_relu                     0.000   0.220   0.048    0.17\n",
      " depthwiseconv_init_linear         -0.000   1.002   1.004    0.78\n",
      " depthwiseconv_init_relu           -0.000   1.403   1.970    1.09\n",
      "relu\n",
      " conv_init_linear                   0.061   0.092   0.009    0.06\n",
      " conv_init_relu                     0.087   0.133   0.018    0.09\n",
      " depthwiseconv_init_linear          0.393   0.599   0.359    0.39\n",
      " depthwiseconv_init_relu            0.553   0.844   0.712    0.55\n"
     ]
    }
   ],
   "source": [
    "# DepthwiseConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "    depthwiseconv_init_linear,\n",
    "    depthwiseconv_init_relu,\n",
    "    #normal_init,\n",
    "    #uniform_init,\n",
    "]\n",
    "\n",
    "activations = ['linear', 'relu']\n",
    "\n",
    "def conv_block(x, initializer, activation):\n",
    "    from layers import DepthwiseConv2D\n",
    "    x = DepthwiseConv2D(4, 3, kernel_initializer=initializer, activation=activation, use_bias=False)(x)\n",
    "    return x\n",
    "\n",
    "calc_statistics(conv_block, initializers, activations, plot=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                     mean     std     var meanabs\n",
      "input                              -0.000   1.000   1.000    0.80\n",
      "linear\n",
      " conv_init_linear                  -0.000   0.215   0.046    0.17\n",
      " conv_init_relu                     0.000   0.212   0.045    0.17\n",
      " depthwiseconv_init_linear          0.000   0.211   0.044    0.17\n",
      " depthwiseconv_init_relu            0.000   0.215   0.046    0.17\n",
      "relu\n",
      " conv_init_linear                   0.084   0.124   0.015    0.08\n",
      " conv_init_relu                     0.083   0.123   0.015    0.08\n",
      " depthwiseconv_init_linear          0.084   0.125   0.016    0.08\n",
      " depthwiseconv_init_relu            0.083   0.123   0.015    0.08\n"
     ]
    }
   ],
   "source": [
    "# keras DepthwiseConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "    depthwiseconv_init_linear,\n",
    "    depthwiseconv_init_relu,\n",
    "    #normal_init,\n",
    "    #uniform_init,\n",
    "]\n",
    "\n",
    "activations = ['linear', 'relu']\n",
    "\n",
    "def conv_block(x, initializer, activation):\n",
    "    from tensorflow.keras.layers import DepthwiseConv2D\n",
    "    x = DepthwiseConv2D(3, depth_multiplier=4, kernel_initializer=initializer, activation=activation, use_bias=False)(x)\n",
    "    return x\n",
    "\n",
    "calc_statistics(conv_block, initializers, activations, plot=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from training import cross_entropy_loss\n",
    "\n",
    "values = np.array([[1,0,0],[0,1,0],[0,0,1],[1,1,0],[1,0,1],[0,1,1]])\n",
    "num_classes = len(values)\n",
    "\n",
    "num_samples = 100\n",
    "num_epochs = 20\n",
    "batch_size = 256\n",
    "\n",
    "n = 10\n",
    "\n",
    "def generator(batch_size):\n",
    "    while True:\n",
    "        x, y = [], []\n",
    "        for i in range(batch_size):\n",
    "            idx = np.random.randint(num_classes)\n",
    "            one_hot = np.zeros(num_classes)\n",
    "            one_hot[idx] = 1\n",
    "            value = (values[idx]*2-1) * np.abs(np.random.random(3))\n",
    "            x.append( np.tile(value, (32,32,1)) )\n",
    "            y.append( one_hot )\n",
    "        yield np.asarray(x, dtype='float32'), np.asarray(y, dtype='float32')\n",
    "\n",
    "\n",
    "def evaluate_initializer(model_name, conv_block, initializers, n=n, learning_rate=1e-3):\n",
    "    print('%i epochs, %i samples, %i runs ' % (num_epochs, num_samples))\n",
    "    results = {}\n",
    "\n",
    "    for initializer in initializers:\n",
    "        loss = []\n",
    "\n",
    "        initializer_name = initializer if type(initializer) == str else initializer.__name__\n",
    "        name = model_name + '_' + initializer_name\n",
    "        print(name)\n",
    "        \n",
    "        for j in range(n):\n",
    "            optimizer = Adam(learning_rate=learning_rate)\n",
    "            \n",
    "            x = x_in = Input((32,32,3))\n",
    "            for i in range(4):\n",
    "                x = conv_block(x, initializer)\n",
    "            if type(x) is list:\n",
    "                x = x[0]\n",
    "            x = GlobalAveragePooling2D()(x)\n",
    "            x = Dense(6, kernel_initializer='he_normal')(x)\n",
    "            x = Activation('sigmoid')(x)\n",
    "            model = Model(x_in, x, name=model_name)\n",
    "        \n",
    "            model.compile(optimizer=optimizer, loss=cross_entropy_loss)\n",
    "            model.fit(generator(batch_size), epochs=num_epochs, steps_per_epoch=num_samples, verbose=0)\n",
    "\n",
    "            loss.append(model.history.history['loss'])\n",
    "\n",
    "        results[name] = np.array(loss)\n",
    "        \n",
    "    return results\n",
    "\n",
    "\n",
    "def plot_with_std(x, y, label):\n",
    "    mean, std = np.mean(y, axis=0), np.std(y, axis=0)\n",
    "    plt.plot(x, mean, label=label)\n",
    "    plt.fill_between(x, mean-std, mean+std, alpha=0.25)\n",
    "\n",
    "def plot_training(results):\n",
    "    \n",
    "    plt.figure(figsize=(16,8))\n",
    "    epochs = np.arange(1,num_epochs+1)\n",
    "    for k, v in results.items():\n",
    "        plot_with_std(epochs, v, k)\n",
    "    plt.legend(); plt.grid(); plt.xlim(epochs[0],epochs[-1]); plt.ylim(0,None)\n",
    "    plt.show()\n",
    "    \n",
    "    x = list(reversed(results.keys()))\n",
    "    y = [np.mean(results[k][:,-3:]) for k in x]\n",
    "    plt.figure(figsize=(8, 0.2+0.2*len(x)))\n",
    "    plt.barh(x,y)\n",
    "    plt.title('final loss')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    conv_init_relu2,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import Conv2D\n",
    "    return Conv2D(6, 3, kernel_initializer=initializer, activation='relu')(x)\n",
    "\n",
    "results = evaluate_initializer('conv', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# SparseConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import SparseConv2D\n",
    "    if type(x) is list:\n",
    "        xm = x\n",
    "    else:\n",
    "        xm = [x, Lambda(lambda x: tf.ones_like(x)[:,:,:,:1])(x)]\n",
    "    xm = SparseConv2D(6, 3, kernel_initializer=initializer, activation='relu')(xm)\n",
    "    return xm\n",
    "\n",
    "results = evaluate_initializer('sconv', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PartialConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import PartialConv2D\n",
    "    if type(x) is list:\n",
    "        xm = x\n",
    "    else:\n",
    "        xm = [x, Lambda(lambda x: tf.ones_like(x)[:,:,:,:1])(x)]\n",
    "    xm = PartialConv2D(6, 3, kernel_initializer=initializer, activation='relu')(xm)\n",
    "    return xm\n",
    "\n",
    "results = evaluate_initializer('pconv', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DepthwiseConv2D\n",
    "\n",
    "initializers = [\n",
    "    #'he_uniform',\n",
    "    #'he_normal',\n",
    "    #'glorot_uniform',\n",
    "    #'glorot_normal',\n",
    "    conv_init_linear,\n",
    "    conv_init_relu,\n",
    "    #conv_init_relu2,\n",
    "    depthwiseconv_init_linear,\n",
    "    depthwiseconv_init_relu,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import DepthwiseConv2D\n",
    "    x = DepthwiseConv2D(2, 3, kernel_initializer=initializer, use_bias=False)(x)\n",
    "    x = Conv2D(6, 1, kernel_initializer=conv_init_relu)(x)\n",
    "    x = Activation('relu')(x)\n",
    "    return x\n",
    "\n",
    "results = evaluate_initializer('dconv', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv2D equalized\n",
    "\n",
    "initializers = [\n",
    "    #conv_init_relu,\n",
    "    #normal_init,\n",
    "    uniform_init,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import Conv2D\n",
    "    x = Conv2D(6, 3, kernel_initializer=initializer, activation='relu', equalize=True)(x)\n",
    "    return x\n",
    "\n",
    "results = evaluate_initializer('econv', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv2D equalized larger learning rate\n",
    "\n",
    "initializers = [\n",
    "    #conv_init_relu,\n",
    "    #normal_init,\n",
    "    uniform_init,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import Conv2D\n",
    "    x = Conv2D(6, 3, kernel_initializer=initializer, activation='relu', equalize=True)(x)\n",
    "    return x\n",
    "\n",
    "results = evaluate_initializer('econv_lr', conv_block, initializers, learning_rate=1e-2)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv2D larger learning rate\n",
    "\n",
    "initializers = [\n",
    "    #conv_init_relu,\n",
    "    #normal_init,\n",
    "    uniform_init,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import Conv2D\n",
    "    x = Conv2D(6, 3, kernel_initializer=initializer, activation='relu', equalize=False)(x)\n",
    "    return x\n",
    "\n",
    "results = evaluate_initializer('conv_lr', conv_block, initializers, learning_rate=1e-2)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv2D + BN\n",
    "\n",
    "initializers = [\n",
    "    conv_init_relu,\n",
    "    normal_init,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import Conv2D\n",
    "    x = Conv2D(6, 3, kernel_initializer=initializer)(x)\n",
    "    x = BatchNormalization()(x)\n",
    "    x = Activation('relu')(x)\n",
    "    return x\n",
    "\n",
    "results = evaluate_initializer('conv_bn', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv2D + WN\n",
    "\n",
    "initializers = [\n",
    "    conv_init_relu,\n",
    "    normal_init,\n",
    "]\n",
    "\n",
    "def conv_block(x, initializer):\n",
    "    from layers import Conv2D\n",
    "    x = Conv2D(6, 3, kernel_initializer=initializer, activation='relu', weightnorm=True)(x)\n",
    "    return x\n",
    "\n",
    "results = evaluate_initializer('conv_wn', conv_block, initializers)\n",
    "all_results.update(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in all_results.keys():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x129.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#keys = [k for k in all_results.keys() if k.startswith('conv_')]\n",
    "#keys = [k for k in all_results.keys() if k.find('_lr_') != -1]\n",
    "keys = ['conv_conv_init_relu', 'conv_lr_conv_init_relu', \n",
    "        'conv_bn_conv_init_relu', 'conv_wn_conv_init_relu', \n",
    "        'econv_gaussian_init', 'econv_lr_gaussian_init',\n",
    "        'econv_uniform_init', 'econv_lr_uniform_init']\n",
    "\n",
    "results = {k:all_results[k] for k in sorted(keys)}\n",
    "plot_training(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 0:\n",
    "    with open('initialization_results.pkl', 'wb') as f:\n",
    "        pickle.dump(all_results, f)\n",
    "else:\n",
    "    with open('initialization_results.pkl', 'rb') as f:\n",
    "        all_results = pickle.load(f)"
   ]
  },
  {
   "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": 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": 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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}