Perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sentiment</th>\n",
       "      <th>productId</th>\n",
       "      <th>userId</th>\n",
       "      <th>summary</th>\n",
       "      <th>text</th>\n",
       "      <th>helpfulY</th>\n",
       "      <th>helpfulN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>B000EQYQBO</td>\n",
       "      <td>A2JZVE0Y19VLL0</td>\n",
       "      <td>blue chips</td>\n",
       "      <td>The chips are okay Not near as flavorful as th...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>B000LKVHYC</td>\n",
       "      <td>A3NAKOMAS0I5L9</td>\n",
       "      <td>Bad even for 'healthy'</td>\n",
       "      <td>I had high hopes for this, but it was bad.  Re...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>-1</td>\n",
       "      <td>B003QRQRY2</td>\n",
       "      <td>ARBO3XW14MNGA</td>\n",
       "      <td>Alot of money for one can</td>\n",
       "      <td>I guess it's only one can since there is nothi...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>-1</td>\n",
       "      <td>B008EG58V8</td>\n",
       "      <td>A1IQXGT4MJUYJ8</td>\n",
       "      <td>The Box says \"OATMEAL SQUARES\" which I believe...</td>\n",
       "      <td>\"Oatmeal Squares\" is in about the largest prin...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>B004WZZY8M</td>\n",
       "      <td>A2TBL6WAZGXB9P</td>\n",
       "      <td>Delicious!</td>\n",
       "      <td>I really enjoyed this flavor, this has a very ...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sentiment   productId          userId  \\\n",
       "0         -1  B000EQYQBO  A2JZVE0Y19VLL0   \n",
       "1         -1  B000LKVHYC  A3NAKOMAS0I5L9   \n",
       "2         -1  B003QRQRY2   ARBO3XW14MNGA   \n",
       "3         -1  B008EG58V8  A1IQXGT4MJUYJ8   \n",
       "4          1  B004WZZY8M  A2TBL6WAZGXB9P   \n",
       "\n",
       "                                             summary  \\\n",
       "0                                         blue chips   \n",
       "1                             Bad even for 'healthy'   \n",
       "2                          Alot of money for one can   \n",
       "3  The Box says \"OATMEAL SQUARES\" which I believe...   \n",
       "4                                         Delicious!   \n",
       "\n",
       "                                                text  helpfulY  helpfulN  \n",
       "0  The chips are okay Not near as flavorful as th...         0         0  \n",
       "1  I had high hopes for this, but it was bad.  Re...         0         0  \n",
       "2  I guess it's only one can since there is nothi...         1         1  \n",
       "3  \"Oatmeal Squares\" is in about the largest prin...         0         0  \n",
       "4  I really enjoyed this flavor, this has a very ...         1         0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_excel('dataset.xlsx')\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sentiment</th>\n",
       "      <th>productId</th>\n",
       "      <th>userId</th>\n",
       "      <th>summary</th>\n",
       "      <th>text</th>\n",
       "      <th>helpfulY</th>\n",
       "      <th>helpfulN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>B000SDKDM4</td>\n",
       "      <td>A1NE47S8ZJPLR3</td>\n",
       "      <td>Smooth coffee</td>\n",
       "      <td>My built-in Bosch coffee machine has trouble g...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>B000MS6CK2</td>\n",
       "      <td>A1GV419L0C3AJY</td>\n",
       "      <td>awesome</td>\n",
       "      <td>An absolute \"must have\" item for your Bloody M...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>B0030F70LO</td>\n",
       "      <td>A8EJ2H1P3ELL3</td>\n",
       "      <td>Great treat for bigger dogs</td>\n",
       "      <td>I have a Great Dane &amp; most treats are gone in ...</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>-1</td>\n",
       "      <td>B001EO6GJK</td>\n",
       "      <td>A34R5COY8PP3LE</td>\n",
       "      <td>Disappointing - more like candy than fruit</td>\n",
       "      <td>I got turned on to dried mangoes from the ones...</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>B004SRH2B6</td>\n",
       "      <td>A23H9F74EMOXEF</td>\n",
       "      <td>Good Product !</td>\n",
       "      <td>I enjoyed the product, good taste, good qualit...</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sentiment   productId          userId  \\\n",
       "0          1  B000SDKDM4  A1NE47S8ZJPLR3   \n",
       "1          1  B000MS6CK2  A1GV419L0C3AJY   \n",
       "2          1  B0030F70LO   A8EJ2H1P3ELL3   \n",
       "3         -1  B001EO6GJK  A34R5COY8PP3LE   \n",
       "4          1  B004SRH2B6  A23H9F74EMOXEF   \n",
       "\n",
       "                                      summary  \\\n",
       "0                               Smooth coffee   \n",
       "1                                     awesome   \n",
       "2                 Great treat for bigger dogs   \n",
       "3  Disappointing - more like candy than fruit   \n",
       "4                              Good Product !   \n",
       "\n",
       "                                                text  helpfulY  helpfulN  \n",
       "0  My built-in Bosch coffee machine has trouble g...         0         0  \n",
       "1  An absolute \"must have\" item for your Bloody M...         0         0  \n",
       "2  I have a Great Dane & most treats are gone in ...         2         1  \n",
       "3  I got turned on to dried mangoes from the ones...         0         1  \n",
       "4  I enjoyed the product, good taste, good qualit...         0         1  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = pd.read_excel('test_set.xlsx')\n",
    "\n",
    "df_test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1, -1, -1, -1,  1, -1, -1,  1,  1,  1], dtype=int64)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m, n = df.shape\n",
    "\n",
    "y_train = df.iloc[:, :1].values\n",
    "\n",
    "X_train = df.iloc[:, n-2:n].values\n",
    "\n",
    "y_list = []\n",
    "\n",
    "for i in y_train:\n",
    "    for j in i:\n",
    "        y_list.append(j)\n",
    "        \n",
    "y_train = np.array(y_list)\n",
    "\n",
    "y_train[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  1,  1, -1,  1, -1,  1, -1, -1,  1], dtype=int64)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m, n = df_test.shape\n",
    "\n",
    "y_test = df_test.iloc[:, :1].values\n",
    "\n",
    "X_test = df_test.iloc[:, n-2:n].values\n",
    "\n",
    "y_list = []\n",
    "\n",
    "for i in y_test:\n",
    "    for j in i:\n",
    "        y_list.append(j)\n",
    "        \n",
    "y_test = np.array(y_list)\n",
    "\n",
    "y_test[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [0, 0],\n",
       "       [1, 1],\n",
       "       [0, 0],\n",
       "       [1, 0],\n",
       "       [0, 0],\n",
       "       [0, 0],\n",
       "       [0, 0],\n",
       "       [5, 0],\n",
       "       [0, 0]], dtype=int64)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [0, 0],\n",
       "       [2, 1],\n",
       "       [0, 1],\n",
       "       [0, 1],\n",
       "       [0, 5],\n",
       "       [1, 0],\n",
       "       [0, 0],\n",
       "       [0, 0],\n",
       "       [0, 0]], dtype=int64)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc = StandardScaler()\n",
    "\n",
    "X_train = sc.fit_transform(X_train)\n",
    "\n",
    "X_test  = sc.fit_transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4000, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4000,)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 2)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500,)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# myPerceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class myPerceptron(object):\n",
    "    \n",
    "    def __init__(self, epochs = 10, learning_rate = 0.01):\n",
    "        self.epochs = epochs\n",
    "        self.learning_rate = learning_rate\n",
    "    \n",
    "    def classify(self, X, y):\n",
    "        (n_samples, n_features) = X.shape\n",
    "        self.w = np.zeros(n_features)\n",
    "        self.b = 0\n",
    "        for t in range(0, self.epochs):\n",
    "            for i in range(0, n_samples):\n",
    "                pred = np.dot(self.w, X[i]) + self.b\n",
    "                if(y[i] * pred <= 0):\n",
    "                    self.w += -(1 / n_samples) * self.learning_rate * ((pred - y[i]) * X[i])\n",
    "                    self.b += -(1 / n_samples) * self.learning_rate * (pred - y[i])\n",
    "        return (self.w, self.b)\n",
    "    \n",
    "    def predict(self, X):\n",
    "        (n_samples, n_features) = X.shape\n",
    "        self.predictions = np.zeros(n_samples)\n",
    "        for i in range(0, n_samples):\n",
    "            x = X[i]\n",
    "            self.prediction = np.dot(self.w, x) + self.b\n",
    "            if(self.prediction > 0):\n",
    "                self.predictions[i] = 1\n",
    "            else:\n",
    "                self.predictions[i] = -1\n",
    "        return self.predictions\n",
    "    \n",
    "    def accuracy(self, predictions, y):\n",
    "        return (predictions == y).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_perceptron = myPerceptron()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 1.86028466e-06, -4.66516849e-06]), 1.1046364924566984e-08)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_perceptron.classify(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  1., -1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred_train = my_perceptron.predict(X_train)\n",
    "\n",
    "y_pred_train[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.64175"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_perceptron.accuracy(y_pred_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_test = my_perceptron.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.642"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_perceptron.accuracy(y_pred_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Perceptron(alpha=0.0001, class_weight=None, early_stopping=False, eta0=1.0,\n",
       "           fit_intercept=True, max_iter=1000, n_iter_no_change=5, n_jobs=None,\n",
       "           penalty=None, random_state=0, shuffle=True, tol=0.001,\n",
       "           validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron = Perceptron()\n",
    "\n",
    "perceptron.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  1, -1,  1,  1,  1,  1,  1,  1,  1], dtype=int64)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred_train = perceptron.predict(X_train)\n",
    "\n",
    "y_pred_train[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.639"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_train, y_pred_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  1, -1, -1, -1, -1,  1,  1,  1,  1], dtype=int64)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred_test = perceptron.predict(X_test)\n",
    "\n",
    "y_pred_test[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.638"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_pred_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}