Perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import time\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyPerceptron:\n",
    "    \n",
    "    def __init__(self,nepoch =10, alpha=0.01,verbose=False):\n",
    "        self.nepoch = nepoch\n",
    "        self.alpha = alpha\n",
    "        self.verbose = verbose\n",
    "    \n",
    "\n",
    "    def train(self,X_train,y_train):\n",
    "        self.weights = [0]*len(X_train[0])\n",
    "        self.bias = random.uniform(-1,1)\n",
    "        self.errors = []\n",
    "        \n",
    "        for i in range(self.nepoch):\n",
    "            sum_error = 0\n",
    "            \n",
    "            for row,label in zip(X_train,y_train):\n",
    "                predicted = self.predict(row)\n",
    "                error = label - predicted\n",
    "                delta = error * self.alpha\n",
    "                sum_error += error*error\n",
    "                # BackPropagate\n",
    "                for j in range(len(row)):\n",
    "                    self.weights[j] = self.weights[j] + row[j]*delta\n",
    "                self.bias = self.bias + delta\n",
    "            if self.verbose:\n",
    "                print(\"Epoch {}, error {}\".format(i+1,sum_error))\n",
    "            self.errors.append(sum_error)\n",
    "    \n",
    "    def predict(self,row):\n",
    "        _sum = self.bias\n",
    "        for i in range(len(row)):\n",
    "            _sum += row[i]*self.weights[i]\n",
    "        return self.activate(_sum)\n",
    "        \n",
    "        \n",
    "    def activate(self,value):\n",
    "        if value > 0:\n",
    "            return 1\n",
    "        else:\n",
    "            return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "% matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mnist import MNIST\n",
    "mndata = MNIST('./mnist/', gz=True)\n",
    "images, labels = mndata.load_training()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learn to classify between 0 and 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "lab=[]\n",
    "dat=[]\n",
    "\n",
    "for i in range(len(labels)):\n",
    "    if labels[i] == 0:\n",
    "        lab.append(-1)\n",
    "        dat.append(images[i])\n",
    "    if labels[i] == 8:\n",
    "        lab.append(+1)\n",
    "        dat.append(images[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(dat, lab, test_size=0.33, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "perceptron = MyPerceptron(verbose=True)\n",
    "perceptron.train(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(perceptron.errors,'-g')\n",
    "#plt.xticks(range(1,max_iter+1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = [1]*len(y_test)\n",
    "for i in range(len(X_test)):\n",
    "    predicted[i] = perceptron.predict(X_test[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(y_test,predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using sklearn Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = Perceptron(alpha=0.01,max_iter=10)\n",
    "clf.fit(X_train,y_train)\n",
    "accuracy_score(y_test,clf.predict(X_test))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:kaggle]",
   "language": "python",
   "name": "conda-env-kaggle-py"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}