Logistic-Regression-Keras.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import io\n",
    "import numpy as np\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "from sklearn.linear_model import LogisticRegression \n",
    "\n",
    "###########################################################################\n",
    "#generate training/test data\n",
    "########################################################################### \n",
    "bragging_file = io.open(\"Happy_clean.txt\",'r',encoding=\"utf-8\") \n",
    "bitching_file = io.open(\"FML_clean.txt\",'r',encoding=\"utf-8\") \n",
    "\n",
    "\n",
    "bragging_tweets = []\n",
    "bitching_tweets = []\n",
    "\n",
    "for _ in range(249000):\n",
    "    bragging_tweets.append([bragging_file.readline().strip(\"\\n\"),0])\n",
    "    bitching_tweets.append([bitching_file.readline().strip(\"\\n\"),1])\n",
    "    \n",
    "tweets = bragging_tweets+bitching_tweets\n",
    "np.random.seed(42)\n",
    "np.random.shuffle(tweets)\n",
    "\n",
    "\n",
    "tweets_train = np.array(tweets[:348600])\n",
    "tweets_test = np.array(tweets[348600:498000])\n",
    "\n",
    "X_train = tweets_train[:,0]\n",
    "Y_train = tweets_train[:,1]\n",
    "X_test = tweets_test[:,0]\n",
    "Y_test = tweets_test[:,1]\n",
    "\n",
    "#########################################################################\n",
    "#bag of words\n",
    "#########################################################################\n",
    "\n",
    "vectorizer = CountVectorizer()\n",
    "X_train_counts = vectorizer.fit_transform(X_train)\n",
    "X_test_counts = vectorizer.transform(X_test)\n",
    "\n",
    "\n",
    "tfidf_transformer = TfidfTransformer()\n",
    "X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)\n",
    "X_test_tfidf = tfidf_transformer.transform(X_test_counts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Children 's #Day to u all.....may #GOD #bless and #protect our #children in the name of #JESUS #AMEN from... http:// fb.me/4ifqcgWnA\n"
     ]
    }
   ],
   "source": [
    "print (X_test[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import keras.optimizers\n",
    "from keras.models import Sequential \n",
    "from keras.layers import Dense, Activation \n",
    "\n",
    "model = Sequential() \n",
    "model.add( Dense(units=1, activation=\"sigmoid\", input_dim= X_train_counts.shape[1], use_bias=False) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sgd = keras.optimizers.SGD(lr=0.0001*400)\n",
    "model.compile(optimizer=sgd, loss='binary_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "348600/348600 [==============================] - 720s 2ms/step - loss: 0.3713 - acc: 0.8535\n",
      "Epoch 2/10\n",
      "348600/348600 [==============================] - 734s 2ms/step - loss: 0.3060 - acc: 0.8814\n",
      "Epoch 3/10\n",
      "348600/348600 [==============================] - 747s 2ms/step - loss: 0.2868 - acc: 0.8891\n",
      "Epoch 4/10\n",
      "348600/348600 [==============================] - 681s 2ms/step - loss: 0.2755 - acc: 0.8937\n",
      "Epoch 5/10\n",
      "348600/348600 [==============================] - 679s 2ms/step - loss: 0.2677 - acc: 0.8968\n",
      "Epoch 6/10\n",
      "348600/348600 [==============================] - 661s 2ms/step - loss: 0.2618 - acc: 0.8992\n",
      "Epoch 7/10\n",
      "348600/348600 [==============================] - 662s 2ms/step - loss: 0.2570 - acc: 0.9012\n",
      "Epoch 8/10\n",
      "348600/348600 [==============================] - 663s 2ms/step - loss: 0.2530 - acc: 0.9027\n",
      "Epoch 9/10\n",
      "348600/348600 [==============================] - 664s 2ms/step - loss: 0.2497 - acc: 0.9038\n",
      "Epoch 10/10\n",
      "348600/348600 [==============================] - 663s 2ms/step - loss: 0.2467 - acc: 0.9049\n"
     ]
    }
   ],
   "source": [
    "from keras.utils import to_categorical\n",
    "train_labels = to_categorical(Y_train)\n",
    "test_labels = to_categorical(Y_test)\n",
    "train_log = model.fit(X_train_counts, Y_train, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calc_classification_error(predictions, class_labels):\n",
    "    n = predictions.size\n",
    "    num_of_errors = 0.\n",
    "    for idx in range(n):\n",
    "        if (predictions[idx] >= 0.5 and class_labels[idx]==0) or (predictions[idx] < 0.5 and class_labels[idx]==1):\n",
    "            num_of_errors += 1\n",
    "    return num_of_errors/n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test_counts)\n",
    "# print(\"Classification Error on Training Set: %.2f%%\" %(calc_classification_error(predictions, class_labels) * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  9.43452537e-01   2.50476114e-02   5.69929421e-01 ...,   9.28300899e-04\n",
      "   3.80459398e-01   8.10950249e-03]\n",
      "(149400,)\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print (predictions.flatten())\n",
    "print (Y_test.shape)\n",
    "print (np.round(0.55))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "149400/149400 [==============================] - 277s 2ms/step\n",
      "[0.2461475504242592, 0.90384872824951024]\n"
     ]
    }
   ],
   "source": [
    "# for i in range(len(predictions)):\n",
    "print (model.evaluate(X_test_counts, Y_test))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy with logistic regression:.... 0.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/hamzakhan/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "# print('Accuracy with logistic regression:....', np.mean(predictions==Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.57011467]\n",
      " [ 0.65407145]]\n"
     ]
    }
   ],
   "source": [
    "myTweet = ['I got cock blocked', 'I have a big car']\n",
    "# X_test = tweets_test[:,0]\n",
    "my_test_counts = vectorizer.transform(myTweet)\n",
    "predictions = model.predict(my_test_counts)\n",
    "\n",
    "print (predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}