train.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import warnings\n",
    "from functools import partial\n",
    "import multiprocessing.pool\n",
    "from six.moves import xrange \n",
    "import tensorflow as tf\n",
    "import math\n",
    "import sys\n",
    "sys.path.insert(0, '../')\n",
    "\n",
    "from utils import *\n",
    "from synthetic_experiments.create_synthetic_dataset import *\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'2.1.0'"
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def placeholder_inputs():\n",
    "    \"\"\"Generate placeholder variables to represent the input tensors.\n",
    "    Returns:\n",
    "    images_placeholder: Images placeholder.\n",
    "    labels_placeholder: Labels placeholder.\n",
    "    \"\"\"\n",
    "    images_placeholder = tf.placeholder(tf.float32, shape=(None,\n",
    "                                                         model.IM_SIZE,\n",
    "                                                         model.IM_SIZE,\n",
    "                                                         model.IM_SIZE,\n",
    "                                                         model.CHANNELS))\n",
    "    labels_placeholder = tf.placeholder(tf.int64, shape=(None))\n",
    "    return images_placeholder, labels_placeholder\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X,y = create_synthetic_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Import the model definition:\n",
    "\n",
    "#import synthetic_experiments.sse_lri_model as model\n",
    "import synthetic_experiments.bispectrum_lri_model as model\n",
    "\n",
    "## All parameters for training\n",
    "is_shconv = True # To compare with a normal CNN (shconv=False) \n",
    "is_trainable = True # To test freezing the conv weights\n",
    "is_hn=True # If false: polar-separable\n",
    "is_augment=False # Right angle rotation augmentation at training\n",
    "M = 0 # number of orientations (only needed for S-LRI). 1, 4, 24 or 72\n",
    "nf1 = 2 # number of filters in first layer\n",
    "batch_size = 16\n",
    "stride = 1 \n",
    "lr = 1e-3\n",
    "max_steps = 50000\n",
    "degreeMax = 1 # maxmum degree of the SHs\n",
    "ksize = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list_test_acc = []\n",
    "for _ in xrange(10):\n",
    "    n_class = 2\n",
    "    tf.reset_default_graph()\n",
    "    # Placeholders    \n",
    "    xph, yph = placeholder_inputs()\n",
    "    learning_rate = tf.placeholder(tf.float32, name='learning_rate')\n",
    "\n",
    "    # Construct model and optimizer\n",
    "    pred = model.build_model(X = xph,\n",
    "                            batch_size = batch_size,\n",
    "                            n_class = n_class,\n",
    "                            nf1 = nf1,\n",
    "                            ksize = ksize,\n",
    "                            stride = stride,\n",
    "                            is_trainable = is_trainable,\n",
    "                            degreeMax = degreeMax,\n",
    "                            is_shconv = is_shconv,\n",
    "                            is_hn = is_hn,\n",
    "                            M = M\n",
    "                            )\n",
    "    loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=pred, labels=yph))\n",
    "\n",
    "    # Evaluation criteria\n",
    "    correct_pred = tf.equal(tf.argmax(pred, 1), yph)\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n",
    "    # Optimizer\n",
    "    optim = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=0.99, beta2=0.9999)\n",
    "    grads_and_vars = optim.compute_gradients(loss)\n",
    "    train_op = optim.apply_gradients(grads_and_vars)\n",
    "\n",
    "\n",
    "    # Configure tensorflow session\n",
    "    init_global = tf.global_variables_initializer()\n",
    "    init_local = tf.local_variables_initializer()\n",
    "    config = tf.ConfigProto()\n",
    "    config.gpu_options.allow_growth = True\n",
    "    config.log_device_placement = False\n",
    "\n",
    "    sess = tf.Session(config=config)\n",
    "    sess.run([init_global, init_local])\n",
    "\n",
    "    # shuffle           \n",
    "    np.random.seed(0)\n",
    "    idx = np.arange(0,len(X))\n",
    "    np.random.shuffle(idx)\n",
    "    X_shuf = X[idx]\n",
    "    y_shuf = y[idx]\n",
    "    \n",
    "    # Split 4/5 train 1/5 test\n",
    "    ntest = int(X_shuf.shape[0]/5)\n",
    "    ntrain = int(X_shuf.shape[0]*4/5)\n",
    "    X_train, X_test = X_shuf[:ntrain], X_shuf[:ntest]\n",
    "    y_train, y_test = y_shuf[:ntrain], y_shuf[:ntest]\n",
    "    \n",
    "    print('X_train shape:',X_train.shape, 'X_test shape:',X_test.shape, 'y_train shape:',y_train.shape, 'y_test shape:',y_test.shape)\n",
    "\n",
    "    print('Starting training loop...')\n",
    "    for step in xrange(max_steps):\n",
    "        Xb, Yb = next_batch(batch_size, X_train, y_train, is_augment)\n",
    "        feed_dict = {xph: Xb, yph: Yb, learning_rate: lr}\n",
    "        __, loss_train, acc_train = sess.run([train_op, loss, accuracy], feed_dict=feed_dict)\n",
    "\n",
    "        if (step) % 5000 == 0 and step!=0 or (step + 1) == max_steps:                \n",
    "            print('Step %d'%(step))\n",
    "            print('Training Data Eval:')\n",
    "            print (\"accuracy training: \" + \"{:.5f}\".format(acc_train))\n",
    "            print (\"loss training: \" + \"{:.5f}\".format(loss_train))\n",
    "\n",
    "            # Training Data Eval:\n",
    "            ############\n",
    "            nb_train_steps = int(math.ceil(float(y_train.shape[0])/(batch_size)))\n",
    "            acc_train_all=0.\n",
    "            for step_t in xrange(nb_train_steps):\n",
    "                Xt=X_train[step_t*batch_size:(step_t+1)*batch_size]\n",
    "                Yt=y_train[step_t*batch_size:(step_t+1)*batch_size]\n",
    "                feed_dict = {xph: Xt, yph: Yt}\n",
    "                accuracy_,pred_ = sess.run([accuracy,pred], feed_dict=feed_dict)\n",
    "                acc_train_all += accuracy_*Xt.shape[0]\n",
    "            acc_train_all=acc_train_all/X_train.shape[0]\n",
    "            print (\"accuracy training: \" + \"{:.5f}\".format(acc_train_all))\n",
    "\n",
    "            print('Test Data Eval:')\n",
    "            ############\n",
    "            nb_test_steps = int(math.ceil(float(y_test.shape[0])/(batch_size)))\n",
    "            acc_test=0.\n",
    "            for step_t in xrange(nb_test_steps):\n",
    "                Xt=X_test[step_t*batch_size:(step_t+1)*batch_size]\n",
    "                Yt=y_test[step_t*batch_size:(step_t+1)*batch_size]\n",
    "                feed_dict = {xph: Xt, yph: Yt}\n",
    "                accuracy_,pred_ = sess.run([accuracy,pred], feed_dict=feed_dict)\n",
    "                acc_test += accuracy_*Xt.shape[0]\n",
    "            acc_test=acc_test/X_test.shape[0]\n",
    "            print (\"accuracy test: \" + \"{:.5f}\".format(acc_test))    \n",
    "    list_test_acc.append(acc_test)\n",
    "    print('list_test_acc: ',list_test_acc, np.mean(list_test_acc))\n",
    "    sess.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}