Lab04-1_107062558.ipynb

{
 "cells": [
  {
   "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>Sepal length</th>\n",
       "      <th>Sepal width</th>\n",
       "      <th>Petal length</th>\n",
       "      <th>Petal width</th>\n",
       "      <th>Class label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Sepal length  Sepal width  Petal length  Petal width  Class label\n",
       "0           5.1          3.5           1.4          0.2  Iris-setosa\n",
       "1           4.9          3.0           1.4          0.2  Iris-setosa\n",
       "2           4.7          3.2           1.3          0.2  Iris-setosa\n",
       "3           4.6          3.1           1.5          0.2  Iris-setosa\n",
       "4           5.0          3.6           1.4          0.2  Iris-setosa"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from IPython.display import display\n",
    "from sklearn.metrics import accuracy_score\n",
    "import matplotlib.pyplot as plt\n",
    "df = pd.read_csv('https://archive.ics.uci.edu/ml/'\n",
    "        'machine-learning-databases/iris/iris.data', header=None)\n",
    "df.columns = ['Sepal length', 'Sepal width', 'Petal length', 'Petal width', 'Class label']\n",
    "display(df.head())\n",
    "\n",
    "X = df[['Petal length', 'Petal width']].values\n",
    "y = pd.factorize(df['Class label'])[0]\n",
    "\n",
    "# discard exmaples in the first class\n",
    "X = X[50:150]\n",
    "y = np.where(y[50:150] == 2, -1, y[50:150])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc = StandardScaler()\n",
    "sc.fit(X_train)\n",
    "X_train_std = sc.transform(X_train)\n",
    "X_test_std = sc.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "\n",
    "class AdalineSGD(object):\n",
    "    \"\"\"ADAptive LInear NEuron classifier.\n",
    "\n",
    "    Parameters\n",
    "    ------------\n",
    "    eta : float\n",
    "        Learning rate (between 0.0 and 1.0)\n",
    "    n_iter : int\n",
    "        Passes over the training dataset.\n",
    "\n",
    "    Attributes\n",
    "    -----------\n",
    "    w_ : 1d-array\n",
    "        Weights after fitting.\n",
    "    errors_ : list\n",
    "        Number of misclassifications in every epoch.\n",
    "    shuffle : bool (default: True)\n",
    "        Shuffles training data every epoch if True to prevent cycles.\n",
    "    random_state : int\n",
    "        Set random state for shuffling and initializing the weights.\n",
    "        \n",
    "    \"\"\"\n",
    "    def __init__(self, eta=0.01, n_iter=50, shuffle=True, random_state=1,m=1):\n",
    "        self.eta = eta\n",
    "        self.n_iter = n_iter\n",
    "        self.w_initialized = False\n",
    "        self.shuffle = shuffle\n",
    "        self.m = m\n",
    "        if random_state:\n",
    "            seed(random_state)\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        \"\"\" Fit training data.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : {array-like}, shape = [n_samples, n_features]\n",
    "            Training vectors, where n_samples is the number of samples and\n",
    "            n_features is the number of features.\n",
    "        y : array-like, shape = [n_samples]\n",
    "            Target values.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        self : object\n",
    "\n",
    "        \"\"\"\n",
    "        self._initialize_weights(X.shape[1])\n",
    "        self.cost_ = []\n",
    "        for i in range(self.n_iter):\n",
    "            if self.shuffle:\n",
    "                X, y = self._shuffle(X, y)\n",
    "            cost = []\n",
    "            m_X = np.split(X,X.shape[0]/self.m)\n",
    "            m_y = np.split(y,y.shape[0]/self.m)\n",
    "            for xi, target in zip(m_X, m_y):\n",
    "                cost.append(self._update_weights(xi, target))\n",
    "            avg_cost = sum(cost) / len(cost)\n",
    "            self.cost_.append(avg_cost)\n",
    "#         print(self.w_)\n",
    "        return self\n",
    "\n",
    "    def _shuffle(self, X, y):\n",
    "        \"\"\"Shuffle training data\"\"\"\n",
    "        r = np.random.permutation(len(y))\n",
    "        return X[r], y[r]\n",
    "    \n",
    "    def _initialize_weights(self, m):\n",
    "        \"\"\"Randomly initialize weights\"\"\"\n",
    "        self.w_ = np.random.normal(loc=0.0, scale=0.01, size=1 + m)\n",
    "        self.w_initialized = True\n",
    "        \n",
    "    def _update_weights(self, x, targets):\n",
    "        \"\"\"Apply Adaline learning rule to update the weights\"\"\"\n",
    "        cost = 0\n",
    "        errors = []\n",
    "        tmp = np.copy(self.w_)\n",
    "        for xi,target in zip(x,targets):\n",
    "            output = self.activation(xi)\n",
    "            error = (target - output)\n",
    "            tmp[1:] += self.eta * xi.dot(error)\n",
    "            tmp[0] += self.eta * error  \n",
    "            cost += 0.5 * error**2\n",
    "#         self.w_[1:] += self.eta * xi.dot(error)\n",
    "#         self.w_[0] += self.eta * error\n",
    "        self.w_ = np.copy(tmp)\n",
    "        return cost\n",
    "    \n",
    "    def net_input(self, X):\n",
    "        \"\"\"Calculate net input\"\"\"\n",
    "        return np.dot(X, self.w_[1:]) + self.w_[0]\n",
    "\n",
    "    def activation(self, X):\n",
    "        \"\"\"Compute linear activation\"\"\"\n",
    "        return self.net_input(X)\n",
    "\n",
    "    def predict(self, X):\n",
    "        \"\"\"Return class label after unit step\"\"\"\n",
    "        return np.where(self.activation(X) >= 0.0, 1, -1)\n",
    "\n",
    "    def partial_fit(self, X, y):\n",
    "        \"\"\"Fit training data without reinitializing the weights\"\"\"\n",
    "        if not self.w_initialized:\n",
    "            self._initialize_weights(X.shape[1])\n",
    "        if y.ravel().shape[0] > 1:\n",
    "            for xi, target in zip(X, y):\n",
    "                self._update_weights(xi, target)\n",
    "        else:\n",
    "            self._update_weights(X, y)\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m=1\n",
      "Misclassified samples: 1\n",
      "Accuracy: 0.95\n",
      "m=2\n",
      "Misclassified samples: 1\n",
      "Accuracy: 0.95\n",
      "m=4\n",
      "Misclassified samples: 1\n",
      "Accuracy: 0.95\n"
     ]
    }
   ],
   "source": [
    "adas = AdalineSGD(n_iter=20, eta=0.01, random_state=1,m=1)\n",
    "adas.fit(X_train_std, y_train)\n",
    "adas2 = AdalineSGD(n_iter=20, eta=0.01, random_state=1,m=2)\n",
    "adas2.fit(X_train_std, y_train)\n",
    "adas4 = AdalineSGD(n_iter=20, eta=0.01, random_state=1,m=4)\n",
    "adas4.fit(X_train_std, y_train)\n",
    "# cost values\n",
    "\n",
    "plt.plot(range(1, len(adas.cost_) + 1), adas.cost_, \n",
    "         marker='o', label='SGD')\n",
    "plt.plot(range(1, len(adas.cost_) + 1), adas2.cost_, \n",
    "         marker='*', label='SGD2')\n",
    "plt.plot(range(1, len(adas.cost_) + 1), adas4.cost_, \n",
    "         marker='^', label='SGD4')\n",
    "# plt.plot(range(1, len(ada.cost_) + 1), np.array(ada.cost_) / len(y_train), \n",
    "#          marker='x', linestyle='--', label='GD (normalized)')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Sum-squared-error')\n",
    "plt.legend(loc='upper right')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('./output/fig-adaline-sgd-cost.png', dpi=300)\n",
    "plt.show()\n",
    "\n",
    "# testing accuracy\n",
    "\n",
    "y_pred = adas.predict(X_test_std)\n",
    "print('m=1')\n",
    "print('Misclassified samples: %d' % (y_test != y_pred).sum())\n",
    "print('Accuracy: %.2f' % accuracy_score(y_test, y_pred))\n",
    "y_pred2 = adas2.predict(X_test_std)\n",
    "print('m=2')\n",
    "print('Misclassified samples: %d' % (y_test != y_pred2).sum())\n",
    "print('Accuracy: %.2f' % accuracy_score(y_test, y_pred2))\n",
    "y_pred4 = adas4.predict(X_test_std)\n",
    "print('m=4')\n",
    "print('Misclassified samples: %d' % (y_test != y_pred4).sum())\n",
    "print('Accuracy: %.2f' % accuracy_score(y_test, y_pred4))\n",
    "# plot decision boundary \n",
    "\n",
    "# plot_decision_regions(X_combined_std, y_combined, \n",
    "#                       classifier=adas, test_idx=range(len(y_train),\n",
    "#                                                       len(y_train) + len(y_test)))\n",
    "# plt.title('Adaline - Stochastic Gradient Descent')\n",
    "# plt.xlabel('Petal length [Standardized]')\n",
    "# plt.ylabel('Petal width [Standardized]')\n",
    "# plt.legend(loc='upper left')\n",
    "# plt.tight_layout()\n",
    "# plt.savefig('./output/fig-adaline-sgd-boundary.png', dpi=300)\n",
    "# plt.show()"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}