2-logistic-regression-6831-PIPELINE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd,numpy as np,matplotlib.pyplot as plt, time  \n",
    "from numpy import *  \n",
    "from random import seed\n",
    "from random import randrange\n",
    "from csv import reader\n",
    "from math import sqrt\n",
    "from sklearn import preprocessing\n",
    "%matplotlib inline\n",
    "\n",
    "def sigmoid(x):  \n",
    "    return 1.0 / (1 + np.exp(-x))  \n",
    "\n",
    "def prepareData(train_pd, stance):  \n",
    "    train_x = train_pd[selected_features].values\n",
    "    train_y = train_pd['Stance'].values == stance\n",
    "    return mat(train_x), mat(train_y).transpose()\n",
    "\n",
    "def predict(weights, test_x):\n",
    "    predict = sigmoid(test_x * weights)\n",
    "    return predict\n",
    "\n",
    "def gradient_descent(train_x, train_y, weights, alpha, iteration):  \n",
    "    for k in range(iteration):  \n",
    "        output = sigmoid(np.dot(train_x, weights))  \n",
    "        loss = train_y - output\n",
    "        weights = weights + alpha * train_x.transpose() * loss \n",
    "    \n",
    "    mse = (sum(loss))**2/len(train_x)\n",
    "    print('mse:',mse)\n",
    "\n",
    "    return weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(train_feat_path,alpha,iteration, W0):\n",
    "    load_feature_df = pd.read_csv(train_feat_path)\n",
    "\n",
    "    train_x_unrelated, train_y_unrelated = prepareData(load_feature_df, 'unrelated')\n",
    "    train_x_agree, train_y_agree = prepareData(load_feature_df, 'agree')\n",
    "    train_x_disagree, train_y_disagree = prepareData(load_feature_df, 'disagree')\n",
    "    train_x_discuss, train_y_discuss = prepareData(load_feature_df, 'discuss')\n",
    "\n",
    "    # train logistic regression\n",
    "    W = W0*np.ones((len(selected_features),1))\n",
    "    print('start train using logistic regression:')\n",
    "    W_agree = gradient_descent(train_x_agree, train_y_agree, W, alpha, iteration)\n",
    "    W_disagree = gradient_descent(train_x_disagree, train_y_disagree, W, alpha, iteration)\n",
    "    W_discuss = gradient_descent(train_x_discuss, train_y_discuss, W, alpha, iteration)\n",
    "    W_unrelated = gradient_descent(train_x_unrelated, train_y_unrelated, W, alpha, iteration)\n",
    "    \n",
    "    return W_agree, W_disagree, W_discuss, W_unrelated\n",
    "\n",
    "def validate(W_agree, W_disagree, W_discuss, W_unrelated, validate_feat_path, printResult = False):\n",
    "    # predict on validation \n",
    "    validation_data = pd.read_csv(validate_feat_path)\n",
    "    validation_x = validation_data[selected_features].values\n",
    "\n",
    "    validation_predict_agree = predict(W_agree, validation_x)*0.072\n",
    "    validation_predict_disagree = predict(W_disagree, validation_x)*0.017\n",
    "    validation_predict_discuss = predict(W_discuss, validation_x)*0.176\n",
    "    validation_predict_unrelated = predict(W_unrelated, validation_x)*0.735\n",
    "\n",
    "    prediction = np.column_stack([validation_predict_agree,\\\n",
    "                                  validation_predict_disagree,\\\n",
    "                                  validation_predict_discuss,\\\n",
    "                                  validation_predict_unrelated])\n",
    "    label_dict = {0:'agree', 1:'disagree', 2:'discuss',3:'unrelated'}\n",
    "    prediction = np.array([label_dict[result.argmax()] for result in prediction])\n",
    "\n",
    "    # evaluate accuracy and score\n",
    "    unrelated_correct = 0\n",
    "    other_correct = 0\n",
    "    N_unrelated = len(validation_data[validation_data.Stance == 'unrelated'])\n",
    "    N_other = len(validation_data) - N_unrelated\n",
    "\n",
    "    for p,true_laWel in zip(prediction, validation_data.Stance):\n",
    "        if p == true_laWel:\n",
    "            if p == 'unrelated':\n",
    "                unrelated_correct +=1\n",
    "            else:\n",
    "                other_correct +=1\n",
    "\n",
    "    unrelated_acc = unrelated_correct/N_unrelated\n",
    "    other_acc = other_correct/N_other\n",
    "    \n",
    "    if printResult:\n",
    "        print('find unrelated:',unrelated_correct,'/' ,N_unrelated, 'accuracy:', unrelated_acc)\n",
    "        print('find other:',other_correct,'/',N_other, 'accuracy:', other_acc)\n",
    "        \n",
    "    score = 0\n",
    "    total_score = 0\n",
    "\n",
    "    for p,true_laWel in zip(prediction, validation_data.Stance):\n",
    "        if p == true_laWel:\n",
    "            if true_laWel == 'unrelated':\n",
    "                score += 0.25\n",
    "                total_score += 0.25\n",
    "            else:\n",
    "                score += 1\n",
    "                total_score += 1\n",
    "        else:\n",
    "            if true_laWel == 'unrelated':\n",
    "                score += 0\n",
    "                total_score += 0.25\n",
    "            elif true_laWel != 'unrelated' and p != 'unrelated':\n",
    "                score += 0.25\n",
    "                total_score += 1\n",
    "            else:\n",
    "                score += 0\n",
    "                total_score += 1\n",
    "\n",
    "    get_score = score * 100 / total_score \n",
    "    print('score:', get_score)\n",
    "    \n",
    "    return get_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# select features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start train using logistic regression:\n",
      "mse: 5524.79939994\n",
      "mse: 5170.75571854\n",
      "mse: 7131.29494415\n",
      "mse: 5132.17000378\n",
      "find unrelated: 29550 / 29647 accuracy: 0.9967281681114447\n",
      "find other: 4939 / 10703 accuracy: 0.4614594039054471\n",
      "score: 71.54942795235927\n"
     ]
    }
   ],
   "source": [
    "# selected_features = ['cos']\n",
    "# iteration  = 5000\n",
    "# w0 = 0\n",
    "# alpha = 0.01\n",
    "\n",
    "# W_agree, W_disagree, W_discuss, W_unrelated = train('train_processed_feat.csv', alpha, iteration, w0)\n",
    "\n",
    "# score = validate(W_agree, W_disagree, W_discuss, W_unrelated, 'hold_out_processed_feat.csv', printResult = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w:    unrelated     agree   disagree  discuss\n",
      "0  -11.01687 -3.175632 -11.893544   -1.627\n",
      "total contribute: [ 27.71304625]\n",
      "best contributor: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# w = pd.DataFrame(np.column_stack([W_unrelated, W_agree, W_disagree,W_discuss]), \\\n",
    "#                  columns=['unrelated', 'agree', 'disagree', 'discuss'])\n",
    "# print('w:',w)\n",
    "# a = w.values\n",
    "# a = [abs(v) for v in a]\n",
    "# print('total contribute:',np.sum(a, axis = 1))\n",
    "# print('best contributor:', np.sum(a, axis = 1).argmin())\n",
    "\n",
    "# import os\n",
    "# os.system('say \"you are very beautiful\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# tune hypterparameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start train using logistic regression:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:11: RuntimeWarning: overflow encountered in exp\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mse: 797.313110285\n",
      "mse: 1549.45846344\n",
      "mse: 6218.81191721\n",
      "mse: 9603.45043371\n",
      "find unrelated: 18196 / 18349 accuracy: 0.9916616709357459\n",
      "find other: 3320 / 7064 accuracy: 0.46998867497168745\n",
      "score: 72.38493723849372\n"
     ]
    }
   ],
   "source": [
    "# selected_features = ['kl','overlap_ratio','cos','dis', 'overlap_count', 'uncertain']\n",
    "# iteration  = 5000\n",
    "# w0 = 0\n",
    "# alpha = 0.01\n",
    "\n",
    "# W_agree, W_disagree, W_discuss, W_unrelated = train('train_processed_feat.csv', alpha, iteration, w0)\n",
    "\n",
    "# score = validate(W_agree, W_disagree, W_discuss, W_unrelated, 'test_processed_feat.csv', printResult = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# # ALPHA = list(np.arange(0,1,0.1))\n",
    "# Iter = list(np.arange(1000,8000,1000))\n",
    "# score_s = []\n",
    "# iteration = 5000\n",
    "# alpha = 0.a1\n",
    "# w0 = -0.04\n",
    "\n",
    "# for i,iteration in enumerate(Iter):\n",
    "#     W_agree, W_disagree, W_discuss, W_unrelated = train('train_processed_feat.csv', alpha, iteration, w0)\n",
    "#     score = validate(W_agree, W_disagree, W_discuss, W_unrelated, 'hold_out_processed_feat.csv', printInfo=False)\n",
    "#     score_s.append(score)\n",
    "\n",
    "# plt.figure()\n",
    "# plt.plot(range(len(score_s)), score_s, 'g*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iter[score_s.index(max(score_s))]\n",
    "# import os\n",
    "# os.system('say \"you are very beautiful\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# evaluate on test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start train using logistic regression:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:11: RuntimeWarning: overflow encountered in exp\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mse: 1634.36242892\n",
      "mse: 1831.04387237\n",
      "mse: 378.579519692\n",
      "mse: 1437.78693188\n",
      "find unrelated: 14014 / 18349 accuracy: 0.7637473431794648\n",
      "find other: 4406 / 7064 accuracy: 0.6237259343148358\n",
      "score: 73.37195579873404\n"
     ]
    }
   ],
   "source": [
    "W0 = 0\n",
    "iteration = 5000\n",
    "alpha = 0.01\n",
    "selected_features = ['overlap_count','cos','kl']\n",
    "\n",
    "W_agree, W_disagree, W_discuss, W_unrelated = train('train_processed_feat.csv', alpha, iteration, W0)\n",
    "\n",
    "score = validate(W_agree, W_disagree, W_discuss, W_unrelated, 'test_processed_feat.csv', printResult=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.system('say \"you are very beautiful\"')"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}