train_new.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/anaconda3/lib/python3.9/site-packages/tensorflow/python/compat/v2_compat.py:107: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    }
   ],
   "source": [
    "# import the necessary packages\n",
    "import numpy as np\n",
    "import canton as ct\n",
    "from canton import *\n",
    "import matplotlib.pyplot as plt\n",
    "# import tensorflow as tf v1\n",
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior() \n",
    "# reduce the log level error\n",
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the data from cifar\n",
    "def cifar():\n",
    "    from keras.datasets import cifar10\n",
    "    (X_train, y_train), (X_test, y_test) = cifar10.load_data()\n",
    "\n",
    "    print('X_train shape:', X_train.shape)\n",
    "    print(X_train.shape[0], 'train samples')\n",
    "    print(X_test.shape[0], 'test samples')\n",
    "\n",
    "    X_train = X_train.astype('float32')\n",
    "    X_test = X_test.astype('float32')\n",
    "\n",
    "    X_train /= 255\n",
    "    X_test /= 255\n",
    "    return X_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ceraate an encoder layer\n",
    "def encoder():\n",
    "    c=Can()\n",
    "    def conv(nip,nop,tail=True):\n",
    "        c.add(Conv2D(nip,nop,k=3,usebias=True))\n",
    "        if tail:\n",
    "            # c.add(BatchNorm(nop))\n",
    "            c.add(Act('elu'))\n",
    "    c.add(Lambda(lambda x:x-0.5))\n",
    "    conv(3,16)\n",
    "    conv(16,32)\n",
    "    conv(32,64)\n",
    "    conv(64,128,tail=False)\n",
    "    c.chain()\n",
    "    return c\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decoder():\n",
    "    c= Can()\n",
    "    def conv(nip,nop,tail=True):\n",
    "        c.add(Conv2D(nip,nop,k=3,usebias=True))\n",
    "        if tail:\n",
    "            # c.add(BatchNorm(nop))\n",
    "            c.add(Act('elu'))\n",
    "\n",
    "    conv(128,64)\n",
    "    conv(64,32)\n",
    "    conv(32,16)\n",
    "    conv(16,3,tail=False)\n",
    "    c.add(Act('sigmoid'))\n",
    "    c.chain()\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_trainer():\n",
    "    x = ph([None,None,3])\n",
    "\n",
    "    # augment the training set by adding random gain and bias pertubation\n",
    "    sx = tf.shape(x)\n",
    "    input_gain = tf.random_uniform(\n",
    "        minval=0.6,\n",
    "        maxval=1.4,\n",
    "        shape=[sx[0],1,1,1])\n",
    "    input_bias = tf.random_uniform(\n",
    "        minval=-.2,\n",
    "        maxval=.2,\n",
    "        shape=[sx[0],1,1,1])\n",
    "    noisy_x = x * input_gain + input_bias\n",
    "    noisy_x = tf.clip_by_value(noisy_x,clip_value_max=1.,clip_value_min=0.)\n",
    "\n",
    "    code_noise = tf.Variable(0.1)\n",
    "    linear_code = enc(noisy_x)\n",
    "\n",
    "    # add gaussian before sigmoid to encourage binary code\n",
    "    noisy_code = linear_code + \\\n",
    "        tf.random_normal(stddev=code_noise,shape=tf.shape(linear_code))\n",
    "    binary_code = Act('sigmoid')(noisy_code)\n",
    "\n",
    "    y = dec(binary_code)\n",
    "    loss = tf.reduce_mean((y-noisy_x)**2) + tf.reduce_mean(binary_code**2) * 0.01\n",
    "\n",
    "    opt = tf.train.AdamOptimizer()\n",
    "    train_step = opt.minimize(loss,\n",
    "        var_list=enc.get_weights()+dec.get_weights())\n",
    "\n",
    "    def feed(batch,cnoise):\n",
    "        sess = ct.get_session()\n",
    "        res = sess.run([train_step,loss],feed_dict={\n",
    "            x:batch,\n",
    "            code_noise:cnoise,\n",
    "        })\n",
    "        return res[1]\n",
    "\n",
    "    set_training_state(False)\n",
    "    quantization_threshold = tf.Variable(0.5)\n",
    "    binary_code_test = tf.cast(binary_code>quantization_threshold,tf.float32)\n",
    "    y_test = dec(binary_code_test)\n",
    "\n",
    "    def test(batch,quanth):\n",
    "        sess = ct.get_session()\n",
    "        res = sess.run([binary_code_test,y_test,binary_code,y,noisy_x],feed_dict={\n",
    "            x:batch,\n",
    "            quantization_threshold:quanth,\n",
    "        })\n",
    "        return res\n",
    "    return feed,test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def r(ep=1,cnoise=0.1):\n",
    "    np.random.shuffle(xt)\n",
    "    length = len(xt)\n",
    "    bs = 20 #interval second\n",
    "    for i in range(ep):\n",
    "        print('ep',i)\n",
    "        for j in range(0,length,bs):\n",
    "            minibatch = xt[j:j+bs]\n",
    "            loss = feed(minibatch,cnoise)\n",
    "            print(j,'loss:',loss)\n",
    "\n",
    "            if j%1000==0:\n",
    "                show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show(threshold=.5):\n",
    "    from cv2tools import vis,filt\n",
    "    bs = 16\n",
    "    j = np.random.choice(len(xt)-16)\n",
    "    minibatch = xt[j:j+bs]\n",
    "    code, rec, code2, rec2, noisy_x = test(minibatch,threshold)\n",
    "\n",
    "    code = np.transpose(code[0:1],axes=(3,1,2,0))\n",
    "    code2 = np.transpose(code2[0:1],axes=(3,1,2,0))\n",
    "\n",
    "    vis.show_batch_autoscaled(code, name='code(quant)', limit=600.)\n",
    "    vis.show_batch_autoscaled(code2, name='code2(no quant)', limit=600.)\n",
    "\n",
    "    vis.show_batch_autoscaled(noisy_x,name='input')\n",
    "    vis.show_batch_autoscaled(rec,name='recon(quant)')\n",
    "    vis.show_batch_autoscaled(rec2,name='recon(no quant)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save():\n",
    "    print(enc, \"enc\")\n",
    "    enc.save_weights('enc.npy')\n",
    "    dec.save_weights('dec.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load():\n",
    "    enc.load_weights('enc.npy')\n",
    "    dec.load_weights('dec.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------\n",
      "Directly Trainable:\n",
      "counting variables...\n",
      "         3    3    3   16  ->  432    W:0\n",
      "                       16  ->  16     b:0\n",
      "         3    3   16   32  ->  4608   W_1:0\n",
      "                       32  ->  32     b_1:0\n",
      "         3    3   32   64  ->  18432  W_2:0\n",
      "                       64  ->  64     b_2:0\n",
      "         3    3   64  128  ->  73728  W_3:0\n",
      "                      128  ->  128    b_3:0\n",
      "               tensors: 8  ->  97440  variables\n",
      "-------------------\n",
      "Not Directly Trainable:\n",
      "counting variables...\n",
      "               tensors: 0  ->  0      variables\n",
      "-------------------\n",
      "-------------------\n",
      "Directly Trainable:\n",
      "counting variables...\n",
      "         3    3  128   64  ->  73728  W_4:0\n",
      "                       64  ->  64     b_4:0\n",
      "         3    3   64   32  ->  18432  W_5:0\n",
      "                       32  ->  32     b_5:0\n",
      "         3    3   32   16  ->  4608   W_6:0\n",
      "                       16  ->  16     b_6:0\n",
      "         3    3   16    3  ->  432    W_7:0\n",
      "                        3  ->  3      b_7:0\n",
      "               tensors: 8  ->  97315  variables\n",
      "-------------------\n",
      "Not Directly Trainable:\n",
      "counting variables...\n",
      "               tensors: 0  ->  0      variables\n",
      "-------------------\n",
      "X_train shape: (50000, 32, 32, 3)\n",
      "50000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "enc,dec = encoder(),decoder()\n",
    "enc.summary()\n",
    "dec.summary()\n",
    "xt = cifar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "feed,test = get_trainer()\n",
    "get_session().run(ct.gvi())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# randomly select input image\n",
    "index = np.random.randint(len(xt))\n",
    "# plot the image\n",
    "plt.imshow(xt[index])\n",
    "plt.gray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def showImage(j, threshold=0.8):\n",
    "    from cv2tools import vis,filt\n",
    "    bs = 16\n",
    "    minibatch = xt[j:j+bs]\n",
    "    code, rec, code2, rec2, noisy_x = test(minibatch,threshold)\n",
    "    vis.clear()\n",
    "    vis.show_batch_autoscaled(rec2,name='recon(no quant)')\n",
    "    image = rec2[15]\n",
    "    plt.imshow(np.squeeze(image))\n",
    "    plt.gray()\n",
    "    # vis.show_batch_autoscaled(rec2,name='recon(no quant)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize compressed image\n",
    "# load()\n",
    "showImage(index)\n",
    "# plt.gray()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}