Logistic_Regression_From_Scratch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "7d176f41",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the Library\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import pickle \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3024da50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating Class for Logistic Regression \n",
    "class LogitRegression:\n",
    "    \n",
    "    def __init__(self, learning_rate, iterations):\n",
    "        self.learning_rate = learning_rate\n",
    "        self.iterations = iterations\n",
    "        self.loss = list()\n",
    "        \n",
    "    def sigmoid(self, z):\n",
    "        return 1 / (1 + np.exp(-z))\n",
    "    \n",
    "    def cost(self, X, y, weights):\n",
    "        z = np.dot(X, weights)\n",
    "        h = self.sigmoid(z)\n",
    "        cost = (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()\n",
    "        return cost\n",
    "    \n",
    "    def gradient_descent(self, X, y, weights):\n",
    "        z = np.dot(X, weights)\n",
    "        h = self.sigmoid(z)\n",
    "        gradient = np.dot(X.T, (h - y)) / y.size\n",
    "        weights = weights - (self.learning_rate * gradient)\n",
    "        return weights\n",
    "    \n",
    "    def fit(self, X, y):\n",
    "        self.weights = np.random.uniform(0, 1, X.shape[1])\n",
    "#         print(type(self.weights))\n",
    "        self.loss = []\n",
    "        for i in range(self.iterations):\n",
    "            self.weights = self.gradient_descent(X, y, self.weights)\n",
    "            self.loss.append(self.cost(X, y, self.weights))\n",
    "#         print('Final loss:', self.loss)\n",
    "        \n",
    "        \n",
    "    def predict(self, X):\n",
    "        z = np.dot(X, self.weights)\n",
    "        sig = self.sigmoid(z)\n",
    "        pred = np.where(sig >= 0.5, 1, 0)\n",
    "#         print(type(pred))\n",
    "        return pred\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "20443689",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2408\n",
      "2338\n"
     ]
    }
   ],
   "source": [
    "# Read the data from CSV file \n",
    "df_penguins = pd.read_csv(\"penguins_size.csv\")\n",
    "print(df_penguins.size)\n",
    "# drop missing data\n",
    "df_penguins = df_penguins.dropna()\n",
    "print(df_penguins.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "72fd93e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     species  island  culmen_length_mm  culmen_depth_mm  flipper_length_mm  \\\n",
      "0          0       2              39.1             18.7              181.0   \n",
      "1          0       2              39.5             17.4              186.0   \n",
      "2          0       2              40.3             18.0              195.0   \n",
      "4          0       2              36.7             19.3              193.0   \n",
      "5          0       2              39.3             20.6              190.0   \n",
      "..       ...     ...               ...              ...                ...   \n",
      "338        2       0              47.2             13.7              214.0   \n",
      "340        2       0              46.8             14.3              215.0   \n",
      "341        2       0              50.4             15.7              222.0   \n",
      "342        2       0              45.2             14.8              212.0   \n",
      "343        2       0              49.9             16.1              213.0   \n",
      "\n",
      "     body_mass_g  sex  \n",
      "0         3750.0  0.0  \n",
      "1         3800.0  1.0  \n",
      "2         3250.0  1.0  \n",
      "4         3450.0  1.0  \n",
      "5         3650.0  0.0  \n",
      "..           ...  ...  \n",
      "338       4925.0  1.0  \n",
      "340       4850.0  1.0  \n",
      "341       5750.0  0.0  \n",
      "342       5200.0  1.0  \n",
      "343       5400.0  0.0  \n",
      "\n",
      "[333 rows x 7 columns]\n",
      "<bound method DataFrame.info of      species  island  culmen_length_mm  culmen_depth_mm  flipper_length_mm  \\\n",
      "0          0       2              39.1             18.7              181.0   \n",
      "1          0       2              39.5             17.4              186.0   \n",
      "2          0       2              40.3             18.0              195.0   \n",
      "4          0       2              36.7             19.3              193.0   \n",
      "5          0       2              39.3             20.6              190.0   \n",
      "..       ...     ...               ...              ...                ...   \n",
      "338        2       0              47.2             13.7              214.0   \n",
      "340        2       0              46.8             14.3              215.0   \n",
      "341        2       0              50.4             15.7              222.0   \n",
      "342        2       0              45.2             14.8              212.0   \n",
      "343        2       0              49.9             16.1              213.0   \n",
      "\n",
      "     body_mass_g  sex  \n",
      "0         3750.0  0.0  \n",
      "1         3800.0  1.0  \n",
      "2         3250.0  1.0  \n",
      "4         3450.0  1.0  \n",
      "5         3650.0  0.0  \n",
      "..           ...  ...  \n",
      "338       4925.0  1.0  \n",
      "340       4850.0  1.0  \n",
      "341       5750.0  0.0  \n",
      "342       5200.0  1.0  \n",
      "343       5400.0  0.0  \n",
      "\n",
      "[333 rows x 7 columns]>\n",
      "2331\n"
     ]
    }
   ],
   "source": [
    "# Categorial Data\n",
    "df_penguins['sex'] = df_penguins['sex'].map({'MALE': 0, 'FEMALE': 1})\n",
    "df_penguins = df_penguins[df_penguins['sex'].notnull()]\n",
    "df_penguins['species'] = pd.Categorical(df_penguins['species']).codes\n",
    "df_penguins['island'] = pd.Categorical(df_penguins['island']).codes\n",
    "\n",
    "print(df_penguins)\n",
    "print(df_penguins.info)\n",
    "print(df_penguins.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "b02d5c13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Finding min max of non categorial data\n",
    "min_body_mass = df_penguins[\"body_mass_g\"].min()\n",
    "max_body_mass = df_penguins[\"body_mass_g\"].max()\n",
    "min_culmen_length = df_penguins[\"culmen_length_mm\"].min()\n",
    "max_culmen_length = df_penguins[\"culmen_length_mm\"].max()\n",
    "min_culmen_depth = df_penguins[\"culmen_depth_mm\"].min()\n",
    "max_culmen_depth = df_penguins[\"culmen_depth_mm\"].max()\n",
    "min_flipper_length = df_penguins[\"flipper_length_mm\"].min()\n",
    "max_flipper_length = df_penguins[\"flipper_length_mm\"].max()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "a4147870",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rescale dataset columns to the range from 0 to 1\n",
    "\n",
    "df_penguins[\"culmen_length_mm\"] = (df_penguins[\"culmen_length_mm\"] - min_culmen_length) / (max_culmen_length - min_culmen_length)\n",
    "df_penguins[\"culmen_depth_mm\"] = (df_penguins[\"culmen_depth_mm\"] - min_culmen_depth) / (max_culmen_depth - min_culmen_depth)\n",
    "df_penguins[\"flipper_length_mm\"] = (df_penguins[\"flipper_length_mm\"] - min_flipper_length) / (max_flipper_length - min_flipper_length)\n",
    "df_penguins[\"body_mass_g\"] = (df_penguins[\"body_mass_g\"] - min_body_mass) / (max_body_mass - min_body_mass)\n",
    "\n",
    "# print(df_penguins[\"culmen_depth_mm\"])\n",
    "# print(df_penguins[\"culmen_length_mm\"])\n",
    "# print(df_penguins[\"flipper_length_mm\"])\n",
    "# print(df_penguins[\"body_mass_g\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "dbeb5755",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5. a. We can use a binary classifier to predict which gender a penguin belongs\n",
    "# to (female or male). In this case, column sex can be used as Y (target) \n",
    "\n",
    "X = df_penguins.drop(['sex'], axis=1)\n",
    "y = df_penguins['sex']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "4e462365",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train: (266, 6)\n",
      "y_train: (266,)\n",
      "X_test: (67, 6)\n",
      "y_test: (67,)\n"
     ]
    }
   ],
   "source": [
    "# Dividing the dataset in training and testing\n",
    "num_train_samples = int(0.8 * X.shape[0])\n",
    "# print(num_train_samples)\n",
    "X_train = X.iloc[:num_train_samples].values\n",
    "y_train = y.iloc[:num_train_samples].values\n",
    "X_test = X.iloc[num_train_samples:].values\n",
    "y_test = y.iloc[num_train_samples:].values\n",
    "print('X_train:', X_train.shape)\n",
    "print('y_train:', y_train.shape)\n",
    "print('X_test:', X_test.shape)\n",
    "print('y_test:', y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "dae60dbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8656716417910447\n"
     ]
    }
   ],
   "source": [
    "# Executing the Code \n",
    "learning_rate = 1e-3\n",
    "# learning_rate = 0.03\n",
    "\n",
    "iterations = 100000\n",
    "model = LogitRegression(learning_rate, iterations)\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "y_pred = model.predict(X_test)\n",
    "accuracy = np.mean(y_pred == y_test)\n",
    "print('Accuracy:', accuracy)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "47b29e18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "266\n",
      "Shape of X_train: (266, 6)\n",
      "Shape of y_train: (266,)\n",
      "Shape of X_test: (67, 6)\n",
      "Shape of y_test: (67,)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 5. b. We can use a binary classifier to predict if a penguin’s location is\n",
    "# Torgersen island or not. In this case, column island can be used as Y\n",
    "# (target) \n",
    "\n",
    "X = df_penguins.drop('island', axis=1)\n",
    "y = df_penguins['island']\n",
    "\n",
    "\n",
    "# Dividing the dataset in training and testing\n",
    "num_train_samples = int(0.8 * X.shape[0])\n",
    "print(num_train_samples)\n",
    "X_train = X.iloc[:num_train_samples].values\n",
    "y_train = y.iloc[:num_train_samples].values\n",
    "X_test = X.iloc[num_train_samples:].values\n",
    "y_test = y.iloc[num_train_samples:].values\n",
    "print('Shape of X_train:', X_train.shape)\n",
    "print('Shape of y_train:', y_train.shape)\n",
    "print('Shape of X_test:', X_test.shape)\n",
    "print('Shape of y_test:', y_test.shape)\n",
    "\n",
    "# Executing the Code \n",
    "learning_rate = 1e-3\n",
    "iterations = 100000\n",
    "model = LogitRegression(learning_rate, iterations)\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "232c6e2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "results = {\n",
    "    \"accuracy\": accuracy,\n",
    "    \"loss\": model.loss,\n",
    "}\n",
    "with open(\"lokeshsu_assignment1_part1.pickle\", \"wb\") as f:\n",
    "    pickle.dump(results, f)\n",
    "    \n",
    "# with open('lokeshsu_assignment1_part1.pickle', 'rb') as f:\n",
    "#     saved_data = pickle.load(f)\n",
    "\n",
    "# View the data\n",
    "# print(saved_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "8107311b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "plt.plot(model.loss)\n",
    "plt.title('Training Loss')\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfa95699",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1aad506f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}