10-1- Perceptron-Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "84abe646-3135-4daf-959f-746454fe42cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15779c05-6d57-4c21-b97c-5d5b07ac2905",
   "metadata": {},
   "source": [
    "### load and preprocess data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "790cbde2-1541-42be-b2cb-84df1b4c4584",
   "metadata": {},
   "outputs": [],
   "source": [
    "Train_data = pd.read_csv('linear_data_train.csv')\n",
    "Test_data = pd.read_csv('linear_data_test.csv')\n",
    "print(Train_data.head(2), Train_data.shape)\n",
    "print(Test_data.head(2), Test_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bf9b6e4-ac22-4a5d-a36e-51397c726512",
   "metadata": {},
   "outputs": [],
   "source": [
    "Train_data = Train_data.to_numpy()\n",
    "Test_data = Test_data.to_numpy()\n",
    "\n",
    "X_train = Train_data[:, [0,1]]\n",
    "Y_train = Train_data[:, 2]\n",
    "X_test = Test_data[:, [0,1]]\n",
    "Y_test = Test_data[:, 2]\n",
    "\n",
    "print(X_train.shape, Y_train.shape, X_test.shape, Y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3f2051f-4b72-4641-8cb8-b2651f62f01a",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_train = Y_train.reshape(-1, 1)\n",
    "Y_test = Y_test.reshape(-1, 1)\n",
    "print(X_train.shape, Y_train.shape, X_test.shape, Y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01af31ed-4320-4a2f-b55a-c4c2d94fff3b",
   "metadata": {},
   "source": [
    "### Perceptron class, predict and evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2cb61f35-14e4-43b5-a826-214e6a9f3cba",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Perceptron:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def fit(self, itr, X_train, Y_train):\n",
    "        \"\"\"\n",
    "        Train the perceptron model.\n",
    "\n",
    "        Args:\n",
    "        itr (int): Number of iterations for training.\n",
    "        X_train (numpy.ndarray): Input features for training.\n",
    "        Y_train (numpy.ndarray): Output labels for training.\n",
    "\n",
    "        Returns:\n",
    "        list: Mean absolute error (MAE) for each iteration.\n",
    "        list: Mean squared error (MSE) for each iteration.\n",
    "        \"\"\"\n",
    "        self.W = np.random.rand(2)\n",
    "        lr = 0.0001\n",
    "        MAE = []\n",
    "        MSE = []\n",
    "\n",
    "        for i in range(itr):\n",
    "            num_false = 0\n",
    "            mae = []\n",
    "            mse = []\n",
    "\n",
    "            for i in range(X_train.shape[0]):\n",
    "                x_train = X_train[i].reshape(1,-1)\n",
    "                y_pred = np.matmul(x_train, self.W )\n",
    "\n",
    "                e = Y_train[i] - y_pred\n",
    "                self.W = self.W  + e * lr * X_train[i]\n",
    "          \n",
    "                mae.append(np.abs(e))\n",
    "                mse.append(np.square(e))\n",
    "\n",
    "            MAE.append(np.mean(mae))\n",
    "            MSE.append(np.mean(mse))\n",
    "\n",
    "        return MAE, MSE\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        \"\"\"\n",
    "        Predict output labels for test data using the trained model.\n",
    "\n",
    "        Args:\n",
    "        X_test (numpy.ndarray): Input features for testing.\n",
    "\n",
    "        Returns:\n",
    "        numpy.ndarray: Predicted output labels.\n",
    "        \"\"\"\n",
    "        Y_pred = np.matmul(X_test, self.W )\n",
    "        Y_pred[Y_pred > 0] = 1\n",
    "        Y_pred[Y_pred<0] = -1\n",
    "\n",
    "        return Y_pred\n",
    "\n",
    "    def evaluate(self, X_test, Y_test, metric):\n",
    "        \"\"\"\n",
    "        Evaluate the performance of the model on the test data.\n",
    "\n",
    "        Args:\n",
    "        X_test (numpy.ndarray): Input features for testing.\n",
    "        Y_test (numpy.ndarray): True output labels for testing.\n",
    "        metric (str): Metric to use for evaluation (e.g., 'MAE', 'MSE', 'accuracy').\n",
    "\n",
    "        Returns:\n",
    "        float: Evaluation result based on the specified metric.\n",
    "        \"\"\"\n",
    "        Y_pred = np.matmul(X_test, self.W)\n",
    "        Y_pred = Y_pred.reshape(-1,1)\n",
    "        \n",
    "        if metric == 'MAE':\n",
    "            absolute_error = np.abs(Y_pred - Y_test)\n",
    "            evaluation = np.mean(absolute_error)\n",
    "            \n",
    "        if metric == 'MSE':\n",
    "            squared_error = (Y_pred - Y_test) ** 2\n",
    "            evaluation = np.mean(squared_error)\n",
    "            \n",
    "        if metric == 'accuracy':\n",
    "            Y_pred[Y_pred > 0] = 1\n",
    "            Y_pred[Y_pred<0] = -1\n",
    "            evaluation = np.count_nonzero(Y_pred == Y_test) / len(Y_test)\n",
    "                                 \n",
    "        return evaluation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7464de8c-9ac7-4b49-92d5-6eceae5f0f95",
   "metadata": {},
   "outputs": [],
   "source": [
    "#train\n",
    "\n",
    "itration = 1000\n",
    "model = Perceptron()\n",
    "MAE, MSE = model.fit(itration, X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e2d6f75-83de-4881-b373-c571a1f1eb6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#predict\n",
    "\n",
    "Y_pred = model.predict(X_test)\n",
    "print(Y_pred)\n",
    "# print(Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24640b39-e4af-4425-a190-64306c1f487e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#evaluate\n",
    "\n",
    "accuracy = model.evaluate(X_test, Y_test, 'accuracy')\n",
    "MSE_test = model.evaluate(X_test, Y_test, 'MSE')\n",
    "MAE_test = model.evaluate(X_test, Y_test, 'MAE')\n",
    "print(\"accuracy_test\", accuracy)\n",
    "print(\"MSE_test\", MSE_test)\n",
    "print(\"MAE_test\", MAE_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a51de56-ca5d-48c6-80c3-142e6ef245e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot((np.arange(len(MAE))), MAE, c='b')\n",
    "plt.grid(True)\n",
    "plt.xticks(np.arange(0,len(MAE)+1,100))\n",
    "plt.xlabel('iteration')\n",
    "plt.ylabel('MAE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "136b4a46-0588-448f-abcf-d02a337d4ccf",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot((np.arange(len(MSE))), MSE, c='b')\n",
    "plt.grid(True)\n",
    "plt.xticks(np.arange(0,len(MSE)+1,100))\n",
    "\n",
    "plt.xlabel('iteration')\n",
    "plt.ylabel('MSE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f305314-6d22-4d94-9628-fb7a5c4cef72",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(10,10))\n",
    "ax = fig.add_subplot(projection='3d')\n",
    "ax.view_init(10, 70)\n",
    "\n",
    "x_range = np.arange(X_train[:,0].min(), X_train[:,0].max(), 0.1)\n",
    "y_range = np.arange(X_train[:,1].min(), X_train[:,1].max(), 0.1)\n",
    "x, y = np.meshgrid(x_range, y_range)\n",
    "z = x * model.W[0] + y * model.W[1]\n",
    "\n",
    "surf = ax.plot_surface(x, y, z, alpha = 0.8, rstride=1, cstride=1)\n",
    "ax.scatter(X_train[:,0], X_train[:,1], Y_train, c='m', marker='o')\n",
    "\n",
    "ax.set_xlabel('X0')\n",
    "ax.set_ylabel('X1')\n",
    "ax.set_zlabel('Y')\n",
    "\n",
    "plt.pause(0.001)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}