ordinal_logistic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.special import expit\n",
    "from scipy import optimize, sparse\n",
    "from scipy.stats import logistic\n",
    "from sklearn import cross_validation, datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "boston = datasets.load_boston()\n",
    "X, y = boston.data, np.round(boston.target)\n",
    "idx = np.argsort(y)\n",
    "X = X[idx]\n",
    "y = y[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import mord"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = mord.LogisticIT() #Default parameters: alpha=1.0, verbose=0, maxiter=10000\n",
    "c.fit(np.array([[0,0,0,1],[0,1,0,0],[1,0,0,0]]), np.array([1,2,3]))\n",
    "c.predict(np.array([0,0,0,1]))\n",
    "c.predict(np.array([0,1,0,0]))\n",
    "c.predict(np.array([1,0,0,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word_vector_path = 'wordvectors.txt'\n",
    "train_reviews_path = 'training_reviews.txt'\n",
    "train_labels_path = 'training_labels.txt'\n",
    "test_reviews_path = 'test_reviews.txt'\n",
    "test_labels_path = 'test_labels.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def get_vectors(path):\n",
    "    word_vectors = {}\n",
    "    with open(path, 'r') as f:\n",
    "        for line in f:\n",
    "            line = line.strip().split()\n",
    "            word, vector = line[0], np.array([float(x) for x in line[1:]])\n",
    "            word_vectors[word] = vector\n",
    "    return word_vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sum_word_vectors(words, word_vectors):\n",
    "    vectors = []\n",
    "    for word in words:\n",
    "        try:\n",
    "            vectors.append(word_vectors[word])\n",
    "        except KeyError:\n",
    "            pass\n",
    "    vectors = np.array(vectors)\n",
    "    return vectors.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def prod_word_vectors(words, word_vectors):\n",
    "    vector = np.ones(word_vectors.values()[0].size)\n",
    "    for word in words:\n",
    "        try:\n",
    "            np.multiply(vector, word_vectors[word])\n",
    "        except KeyError:\n",
    "            pass\n",
    "    return vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "vectors = get_vectors(word_vector_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5000, 128)\n",
      "5000\n",
      "(5000,)\n"
     ]
    }
   ],
   "source": [
    "X = []\n",
    "y = []\n",
    "samples = 0\n",
    "with open(train_reviews_path, 'r') as f, open(train_labels_path, 'r') as g:\n",
    "    for line, label in zip(f, g):\n",
    "        line = line.split()\n",
    "        X.append(prod_word_vectors(line, vectors))\n",
    "        y.append(int(label.strip()))\n",
    "        samples += 1\n",
    "        \n",
    "    X = np.array(X)\n",
    "    y = np.array(y)\n",
    "    print X.shape\n",
    "    print samples\n",
    "    print y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(500, 128)\n",
      "500\n",
      "(500,)\n"
     ]
    }
   ],
   "source": [
    "X_test = []\n",
    "y_test = []\n",
    "samples = 0\n",
    "with open(test_reviews_path, 'r') as f, open(test_labels_path, 'r') as g:\n",
    "    for line, label in zip(f, g):\n",
    "        line = line.split()\n",
    "\n",
    "        X_test.append(sum_word_vectors(line, vectors))\n",
    "        y_test.append(int(label.strip()))\n",
    "        samples += 1\n",
    "\n",
    "    X_test = np.array(X_test)\n",
    "    y_test = np.array(y_test)\n",
    "    print X_test.shape\n",
    "    print samples\n",
    "    print y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticIT(alpha=1.0, max_iter=1000, verbose=0)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = mord.LogisticIT() #Default parameters: alpha=1.0, verbose=0, maxiter=10000\n",
    "c.fit(X, y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2\n"
     ]
    }
   ],
   "source": [
    "data = []\n",
    "for label, truth in zip(c.predict(X), y):\n",
    "    data.append(label == truth)\n",
    "print sum(data) / float(len(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import ologr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d = ologr.OrdinalLogisticRegressionAT()\n",
    "w, theta = d.train(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "0.2\n"
     ]
    }
   ],
   "source": [
    "atdata = []\n",
    "#print w\n",
    "#print theta\n",
    "labels = np.unique(y)\n",
    "print labels\n",
    "for row, truth in zip(X, y):\n",
    "    label = labels[d.predict(w, theta, row)]\n",
    "    atdata.append(label == truth)\n",
    "print sum(atdata) / float(len(atdata))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "e = ologr.OrdinalLogisticRegressionIT()\n",
    "wit, thetait = e.train(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "0.2\n"
     ]
    }
   ],
   "source": [
    "itdata = []\n",
    "#print w\n",
    "#print theta\n",
    "labels = np.unique(y)\n",
    "print labels\n",
    "for row, truth in zip(X, y):\n",
    "    label = labels[e.predict(wit, thetait, row)]\n",
    "    #print label, truth\n",
    "    itdata.append(label == truth)\n",
    "print sum(itdata) / float(len(itdata))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}