Run_Experiment_Supervised.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use this notebook to train supervised models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from utils import *\n",
    "from VDSH_S import *\n",
    "from VDSH_SP import *\n",
    "from __future__ import print_function\n",
    "\n",
    "filename = 'dataset/ng20.tfidf.mat'\n",
    "data = Load_Dataset(filename)\n",
    "\n",
    "latent_dim = 32\n",
    "sess = get_session(\"1\", 0.10)\n",
    "model = VDSH_S(sess, latent_dim, data.n_feas, data.n_tags, use_cross_entropy=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# create an optimizer\n",
    "learning_rate=0.001\n",
    "decay_rate = 0.96\n",
    "#decay_step = 10000\n",
    "step = tf.Variable(0, trainable=False)  \n",
    "lr = tf.train.exponential_decay(learning_rate, \n",
    "                                step, \n",
    "                                10000, \n",
    "                                decay_rate, \n",
    "                                staircase=True, name=\"lr\")\n",
    "\n",
    "my_optimizer = tf.train.AdamOptimizer(learning_rate=lr) \\\n",
    "                     .minimize(model.cost, global_step=step)\n",
    "    \n",
    "init = tf.global_variables_initializer()\n",
    "model.sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "total_epoch = 15\n",
    "kl_weight = 0.\n",
    "kl_inc = 1 / 5000. # set the annealing rate for KL loss\n",
    "\n",
    "pred_weight = 0.\n",
    "pred_inc = 0.1\n",
    "max_pred_weight = 150.\n",
    "\n",
    "for epoch in xrange(total_epoch):\n",
    "    epoch_loss = []\n",
    "    for i in range(len(data.train)):\n",
    "        # get doc\n",
    "        doc = data.train[i]\n",
    "        labels = data.gnd_train[i]\n",
    "        word_indice = np.where(doc > 0)[0]\n",
    "        \n",
    "        # indices\n",
    "        opt, loss = model.sess.run((my_optimizer, model.cost), \n",
    "                                    feed_dict={model.input_bow: doc.reshape((-1, data.n_feas)),\n",
    "                                               model.input_bow_idx: word_indice,\n",
    "                                               model.labels: labels.reshape((-1, data.n_tags)),\n",
    "                                               model.kl_weight: kl_weight,\n",
    "                                               model.tag_weight: pred_weight,\n",
    "                                               model.keep_prob: 0.9})\n",
    "        \n",
    "        kl_weight = min(kl_weight + kl_inc, 1.0)\n",
    "        pred_weight = min(pred_weight + pred_inc, max_pred_weight)\n",
    "\n",
    "        epoch_loss.append(loss[0])\n",
    "        \n",
    "        if i % 50 == 0:\n",
    "            print(\"\\rEpoch:{}/{} {}/{}: Loss:{:.3f} AvgLoss:{:.3f}\".format(epoch+1, total_epoch, i, \n",
    "                                                                           data.n_trains, loss[0], np.mean(epoch_loss)), end='')\n",
    "            \n",
    "    # run experiment on CV dataset\n",
    "    zTrain = model.transform(data.train)\n",
    "    zCV = model.transform(data.cv)\n",
    "    zTrain = np.array(zTrain)\n",
    "    zCV = np.array(zCV)\n",
    "    medHash = MedianHashing()\n",
    "    cbTrain = medHash.fit_transform(zTrain)\n",
    "    cbCV = medHash.transform(zCV)\n",
    "\n",
    "    TopK=100\n",
    "    print('Retrieve Top{} candidates using hamming distance'.format(TopK))\n",
    "    results = run_topK_retrieval_experiment(cbTrain, cbCV, data.gnd_train, data.gnd_cv, TopK)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# run experiment here\n",
    "zTrain = model.transform(data.train)\n",
    "zTest = model.transform(data.test)\n",
    "zTrain = np.array(zTrain)\n",
    "zTest = np.array(zTest)\n",
    "medHash = MedianHashing()\n",
    "cbTrain = medHash.fit_transform(zTrain)\n",
    "cbTest = medHash.transform(zTest)\n",
    "\n",
    "TopK=100\n",
    "print('Retrieve Top{} candidates using hamming distance'.format(TopK))\n",
    "results = run_topK_retrieval_experiment(cbTrain, cbTest, data.gnd_train, data.gnd_test, TopK)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}