Multi-label Neural Network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "from sklearn.datasets import fetch_mldata\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "yeast = fetch_mldata(\"yeast\")\n",
    "X = yeast.data\n",
    "Y = yeast.target.toarray().astype(np.int).T\n",
    "\n",
    "train_test_split = np.random.rand(len(X)) < 0.70\n",
    "train_x = X[train_test_split]\n",
    "train_y = Y[train_test_split]\n",
    "test_x = X[~train_test_split]\n",
    "test_y = Y[~train_test_split]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "training_epochs = 15\n",
    "n_dimensions = train_x.shape[1]\n",
    "nhu_lone = 100\n",
    "nhu_ltwo = 50\n",
    "n_classes = 14\n",
    "learning_rate = 0.001\n",
    "batch_size = 10\n",
    "total_batches = train_x.shape[0] // batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def weight_variable(shape):\n",
    "    initial = tf.truncated_normal(shape, stddev = 1/np.sqrt(n_dimensions))\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "def bias_variable(shape):\n",
    "    initial = tf.constant(0.0, shape = shape)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "def fully_connected_sigmoid(x,weight,bias,return_logits = False):\n",
    "    return tf.nn.sigmoid(tf.add(tf.matmul(x,weight),bias))\n",
    "\n",
    "def fully_connected_relu(x,weight,bias):\n",
    "    return tf.nn.relu(tf.add(tf.matmul(x,weight),bias))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "X = tf.placeholder(tf.float32,[None,n_dimensions])\n",
    "Y = tf.placeholder(tf.float32,[None,n_classes])\n",
    "\n",
    "weight_lone = weight_variable([n_dimensions,nhu_lone])\n",
    "bias_lone = bias_variable([nhu_lone])\n",
    "\n",
    "weight_ltwo = weight_variable([nhu_lone,nhu_ltwo])\n",
    "bias_ltwo = bias_variable([nhu_ltwo])\n",
    "\n",
    "weight_lout = weight_variable([nhu_ltwo,n_classes])\n",
    "bias_lout = bias_variable([n_classes])\n",
    "\n",
    "l1 = fully_connected_relu(X,weight_lone,bias_lone)\n",
    "l2 = fully_connected_relu(l1,weight_ltwo,bias_ltwo)\n",
    "y_ = fully_connected_sigmoid(l2,weight_lout,bias_lout,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "loss_function = -tf.reduce_mean(((Y * tf.log(y_)) + ((1 - Y) * tf.log(1 - y_))))\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(loss_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------- Epoch -----------\n",
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 \n",
      "\n",
      "ROC AUC Score:  0.712481999143\n",
      "F1 Score:  0.659800776633\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as session:\n",
    "    tf.initialize_all_variables().run()\n",
    "    print\"--------- Epoch -----------\"\n",
    "    for epoch in range(training_epochs):\n",
    "        cost_history = np.empty((0),dtype=float)\n",
    "        for b in range(total_batches):    \n",
    "            offset = (b * batch_size) % (train_y.shape[0] - batch_size)\n",
    "            batch_x = train_x[offset:(offset + batch_size), :]\n",
    "            batch_y = train_y[offset:(offset + batch_size), :]\n",
    "            _, c = session.run([optimizer,loss_function],feed_dict = {X: batch_x, Y: batch_y})\n",
    "            cost_history = np.append(cost_history,c)\n",
    "        print epoch, \n",
    "        \n",
    "    y_pred = session.run(y_,feed_dict = { X: test_x })\n",
    "    print \"\\n\\nROC AUC Score: \",roc_auc_score(test_y,y_pred)\n",
    "    \n",
    "    y_pred[y_pred > 0.5] = 1 # considering probability above 0.5 as true label\n",
    "    y_pred[y_pred < 0.5] = 0 # considering any probability below 0.5 as false label\n",
    "    print \"F1 Score: \", f1_score(test_y, y_pred, average='micro')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}