lab1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Lab1 - Scikit-learn\n",
    "Author: *BHAVYAI GUPTA*\n",
    "\n",
    "## 1. Overview\n",
    "\n",
    "At the end, you are asked to answer the following questions in **Section 5.1 Questions** in the notebook:\n",
    "\n",
    "1. For each task (classification and regression), which model performs best on the validation data using all features?\n",
    "2. For each task (classification and regression), which model performs best on the validation data using two principal components?\n",
    "3. In each task (classification and regression), for each model, how do full feature and two principal component model scores compare on the validation data?\n",
    "4. Do any of the models underfit or overfit? Provide examples."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 2. Function definitions"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def get_classifier_accuracy(model, X, y):\n",
    "    '''Calculate train and validation accuracy of classifier (model)\n",
    "        \n",
    "        Splits feature matrix X and target vector y \n",
    "        with sklearn train_test_split() and random_state=956.\n",
    "        \n",
    "        model (sklearn classifier): Classifier to train and evaluate\n",
    "        X (numpy.array or pandas.DataFrame): Feature matrix\n",
    "        y (numpy.array or pandas.Series): Target vector\n",
    "        \n",
    "        returns: training accuracy, validation accuracy\n",
    "    '''\n",
    "    \n",
    "    # split the data into training set and validation set\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=956)\n",
    "    \n",
    "    # fit the model using training data\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # predict the data on training set\n",
    "    y_train_predicted = model.predict(X_train)\n",
    "\n",
    "    # get the training accuracy\n",
    "    acc_train = accuracy_score(y_train, y_train_predicted)\n",
    "\n",
    "    # predict the data on validation set\n",
    "    y_test_predicted = model.predict(X_test)\n",
    "    \n",
    "    # get the validation accuracy\n",
    "    acc_test = accuracy_score(y_test, y_test_predicted)\n",
    "\n",
    "    return (acc_train, acc_test)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def get_regressor_mse(model, X, y):\n",
    "    '''Calculate train and validation mean-squared error (mse) of regressor (model)\n",
    "        \n",
    "        Splits feature matrix X and target vector y \n",
    "        with sklearn train_test_split() and random_state=956.\n",
    "        \n",
    "        model (sklearn regressor): Regressor to train and evaluate\n",
    "        X (numpy.array or pandas.DataFrame): Feature matrix\n",
    "        y (numpy.array or pandas.Series): Target vector\n",
    "        \n",
    "        returns: training mse, validation mse\n",
    "    '''\n",
    "    \n",
    "    # split the data into training set and validation set\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=956)\n",
    "    \n",
    "    # fit the model using training data\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # predict the data on training set\n",
    "    y_train_predicted = model.predict(X_train)\n",
    "\n",
    "    # get the training mean squared error\n",
    "    mse_training = mean_squared_error(y_train, y_train_predicted)\n",
    "\n",
    "    # predict the data on validation set\n",
    "    y_test_predicted = model.predict(X_test)\n",
    "\n",
    "    # get the validation mean squared error\n",
    "    mse_validation = mean_squared_error(y_test, y_test_predicted)\n",
    "\n",
    "    return (mse_training, mse_validation)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "from sklearn.decomposition import PCA\n",
    "\n",
    "def get_n_principal_components(X, n=2):\n",
    "    '''Extracts n principal componets from feature matrix X using sklearn PCA.\n",
    "        X (pandas.DataFrame): A feature matrix\n",
    "        n (int): number of principal components\n",
    "        \n",
    "        returns: feature matrix with n columns as numpy.array\n",
    "    '''\n",
    "    \n",
    "    # instantiate the model with hyperparameter\n",
    "    model = PCA(n_components=n)\n",
    "    \n",
    "    # fit the model\n",
    "    model.fit(X)\n",
    "\n",
    "    # transform the Feature Matrix\n",
    "    X_nD = model.transform(X)\n",
    "    \n",
    "    return X_nD"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 3. Classification\n",
    "\n",
    "Using yellowbrick spam - classification  \n",
    "https://www.scikit-yb.org/en/latest/api/datasets/spam.html\n",
    "\n",
    "The goal is to compare `LogisticRegression(max_iter=2000)` and `RandomForestClassifier(random_state=88)` classification performance on a validation set with full features and first two principal components."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 3.1 Load data\n",
    "\n",
    "Load the spam data set into feature matrix `X` and target vector `y`.\n",
    "\n",
    "Call `get_n_principal_components()` to obtain feature matrix `X_2D` containing the first two principal components.\n",
    "\n",
    "Print dimensions and type of `X`, `y`, and `X_2D`.\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "from yellowbrick.datasets.loaders import load_spam\n",
    "\n",
    "# loading spam dataset into feature matrix X and target vector y\n",
    "X, y = load_spam()\n",
    "\n",
    "# PCA dimensionality reduction on X\n",
    "X_2D = get_n_principal_components(X, 2)\n",
    "\n",
    "print(\"Dimension of X    = {0}\\nDimension of y    = {1}\\nDimension of X_2D = {2}\".format(X.shape, y.shape, X_2D.shape))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Dimension of X    = (4600, 57)\n",
      "Dimension of y    = (4600,)\n",
      "Dimension of X_2D = (4600, 2)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 3.2 Train and evaluate models\n",
    "\n",
    "1. Import `LogisticRegression` and `RandomForestClassifier` from sklearn\n",
    "2. Instantiate models `LogisticRegression(max_iter=2000)` and `RandomForestClassifier(random_state=88)` in a list.\n",
    "3. create a for loop iterating the models list:\n",
    "    - Call `get_classifier_accuracy()` using all features, i.e. `X`.\n",
    "    - Call `get_classifier_accuracy()` using PCA features, i.e. `X_2D`.\n",
    "    - Print training and validation accuracy for both. Limit output to **3 decimal places**."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# create the list of models\n",
    "model_list = [LogisticRegression(max_iter=2000), RandomForestClassifier(random_state=88)]\n",
    "\n",
    "# loop over the model_list to get accuracy\n",
    "for model in model_list:\n",
    "    print(\"{} model\".format(model.__class__.__name__))\n",
    "    \n",
    "    # calculate the accuracy using all features\n",
    "    acc_train_all, acc_test_all = get_classifier_accuracy(model, X, y)\n",
    "    print(\"  - Using all features\")\n",
    "    print(\"    1. Training accuracy = {0:.3f}\".format(acc_train_all))\n",
    "    print(\"    2. Validation accuracy = {0:.3f}\\n\".format(acc_test_all))\n",
    "\n",
    "\n",
    "    # calculate the accuracy using PCA features\n",
    "    acc_train_pca, acc_test_pca = get_classifier_accuracy(model, X_2D, y)\n",
    "    print(\"  - Using PCA features\")\n",
    "    print(\"    1. Training accuracy = {0:.3f}\".format(acc_train_pca))\n",
    "    print(\"    2. Validation accuracy = {0:.3f}\\n\".format(acc_test_pca))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "LogisticRegression model\n",
      "  - Using all features\n",
      "    1. Training accuracy = 0.934\n",
      "    2. Validation accuracy = 0.917\n",
      "\n",
      "  - Using PCA features\n",
      "    1. Training accuracy = 0.729\n",
      "    2. Validation accuracy = 0.725\n",
      "\n",
      "RandomForestClassifier model\n",
      "  - Using all features\n",
      "    1. Training accuracy = 0.999\n",
      "    2. Validation accuracy = 0.944\n",
      "\n",
      "  - Using PCA features\n",
      "    1. Training accuracy = 0.999\n",
      "    2. Validation accuracy = 0.771\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 3.3 Plot PCA feautures\n",
    "Use a Seaborn `scatterplot` to visulaize the two PCA components using the lables in `y` as `hue`.\n",
    "\n",
    "Label x- and y-axis and add a title."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "# plot the X_2D\n",
    "sns.scatterplot(x=X_2D[:,0], y=X_2D[:,1], hue=y)\n",
    "\n",
    "# add the title\n",
    "plt.title(\"Plot for Spam dataset using two PCA\")\n",
    "\n",
    "# label the axes\n",
    "plt.xlabel('PCA0');\n",
    "plt.ylabel('PCA1');"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 4. Regression\n",
    "\n",
    "Using yellowbrick energy - regression  \n",
    "https://www.scikit-yb.org/en/latest/api/datasets/energy.html\n",
    "\n",
    "The goal is to compare `LinearRegression()` and `RandomForestRegressor(random_state=88)` regression performance on a validation set with full features and first two principal components."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 4.1 Load data\n",
    "\n",
    "Load the energy data set into feature matrix `X` and target vector `y`.\n",
    "\n",
    "Call `get_n_principal_components()` to obtain feature matrix `X_2D` containing the first two principal components.\n",
    "\n",
    "Print dimensions and type of `X`, `y`, and `X_2D`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "from yellowbrick.datasets import load_energy\n",
    "\n",
    "# loading energy dataset into feature matrix X and target vector y\n",
    "X, y = load_energy()\n",
    "\n",
    "# PCA dimensionality reduction on X\n",
    "X_2D = get_n_principal_components(X, 2)\n",
    "\n",
    "print(\"Dimension of X    = {0}\\nDimension of y    = {1}\\nDimension of X_2D = {2}\".format(X.shape, y.shape, X_2D.shape))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Dimension of X    = (768, 8)\n",
      "Dimension of y    = (768,)\n",
      "Dimension of X_2D = (768, 2)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 4.2 Train and evaluate models\n",
    "\n",
    "1. Import `LinearRegression` and `RandomForestRegressor` from sklearn\n",
    "2. Instantiate models `LinearRegression()` and `RandomForestRegressor(random_state=88)` in a list.\n",
    "3. create a for loop iterating the models list:\n",
    "    - Call `get_regressor_mse()` using all features, i.e. `X`.\n",
    "    - Call `get_regressor_mse()` using PCA features, i.e. `X_2D`.\n",
    "    - Print training and validation accuracy for both. Limit output to **1 decimal place**."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "# create the list of models\n",
    "model_list = [LinearRegression(), RandomForestRegressor(random_state=88)]\n",
    "\n",
    "# loop over the model_list to get accuracy\n",
    "for model in model_list:\n",
    "    print(\"{} model\".format(model.__class__.__name__))\n",
    "\n",
    "    # calculate the mse using all features\n",
    "    mse_train_all, mse_test_all = get_regressor_mse(model, X, y)\n",
    "    print(\"  - Using all features\")\n",
    "    print(\"    1. Training mean squared error = {0:.1f}\".format(mse_train_all))\n",
    "    print(\"    2. Validation mean squared error = {0:.1f}\\n\".format(mse_test_all))\n",
    "\n",
    "    # calculate the accuracy using PCA features\n",
    "    mse_train_pca, mse_test_pca = get_regressor_mse(model, X_2D, y)\n",
    "    print(\"  - Using PCA features\")\n",
    "    print(\"    1. Training mean squared error = {0:.1f}\".format(mse_train_pca))\n",
    "    print(\"    2. Validation mean squared error = {0:.1f}\\n\".format(mse_test_pca))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "LinearRegression model\n",
      "  - Using all features\n",
      "    1. Training mean squared error = 8.0\n",
      "    2. Validation mean squared error = 10.3\n",
      "\n",
      "  - Using PCA features\n",
      "    1. Training mean squared error = 22.2\n",
      "    2. Validation mean squared error = 19.6\n",
      "\n",
      "RandomForestRegressor model\n",
      "  - Using all features\n",
      "    1. Training mean squared error = 0.0\n",
      "    2. Validation mean squared error = 0.2\n",
      "\n",
      "  - Using PCA features\n",
      "    1. Training mean squared error = 9.6\n",
      "    2. Validation mean squared error = 8.6\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 4.3 Plot PCA feautures\n",
    "Use a Seaborn `scatterplot` to visulaize the two PCA components using the values in `y` as `hue` and `size`.\n",
    "\n",
    "Label x- and y-axis and add a title."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "# plot the X_2D\n",
    "sns.scatterplot(x=X_2D[:,0], y=X_2D[:,1], hue=y, size=y)\n",
    "\n",
    "# add the title\n",
    "plt.title(\"Plot for Energy dataset using two PCA\")\n",
    "\n",
    "# label the axes\n",
    "plt.xlabel('PCA0');\n",
    "plt.ylabel('PCA1');"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 5. Observations/Interpretation"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 5.1 Questions\n",
    "1. For each task (classification and regression), which model performs best on the validation data using all features?\n",
    "\n",
    "   **Classification:**  \n",
    "   RandomForestClassifier performs better than LogisticRegression. RandomForestClassifier has validation accuracy of 0.944, which is higher than that of LogisticRegression's 0.917.\n",
    "\n",
    "   **Regression:**  \n",
    "   RandomForestRegressor performs better than LinearRegression. RandomForestRegressor has validation mse of 0.2, which is lower than that of LinearRegression's 10.3.\n",
    "\n",
    "\n",
    "2. For each task (classification and regression), which model performs best on the validation data using two principal components?\n",
    "\n",
    "   **Classification:**  \n",
    "   RandomForestClassifier performs better than LogisticRegression. RandomForestClassifier has validation accuracy of 0.771, which is higher than that of LogisticRegression's 0.725.\n",
    "\n",
    "   **Regression:**  \n",
    "   RandomForestRegressor performs better than LinearRegression. RandomForestRegressor has validation mse of 8.6, which is lower than that of LinearRegression's 19.6.\n",
    "\n",
    "\n",
    "3. In each task (classification and regression), for each model, how do full feature and two principal component model scores compare on the validation data?\n",
    "\n",
    "   **Classification:**  \n",
    "   For both LogisticRegression and RandomForestClassifier, the models performs poorly using the PCA features as compared to using the full features. Using PCA decreases the accuracy score in each case.\n",
    "\n",
    "   **Regression:**  \n",
    "   For both LinearRegression and RandomForestRegressor, the models performs poorly using the PCA features as compared to using the full features. Using the PCA increases the mean squared error in each case.\n",
    "\n",
    "\n",
    "4. Do any of the models underfit or overfit? Provide examples.\n",
    "\n",
    "   **Underfitting**  \n",
    "   LogisticRegression with PCA is underfitting. In this model, both the training and validation score are quite low.\n",
    "\n",
    "   **Overfitting**  \n",
    "   RandomForestClassifier with PCA is overfitting. This model performs very well on the training data, but the performs drops on the validation data.\n",
    "\n",
    "\n",
    "### 5.2 Conclusion\n",
    "\n",
    "The supervised models performs better when all the features are used. Using PCA with two components reduces the accuracy score or increases the mean squared error. This is evident in all the four different models we have tested."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 6. Reflection\n",
    "Include a sentence or two about:\n",
    "- what you liked or disliked,\n",
    "- found interesting, confusing, challangeing, motivating\n",
    "while working on this assignment.\n",
    "\n",
    "\n",
    "*ADD YOUR THOUGHTS HERE*"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "1. I find Machine Learning challenging.\n",
    "2. It seems like we are just using predefined functions, without actually understanding what's happening.\n",
    "3. I hope things will get clearer as we advance towards next topics."
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.7 64-bit"
  },
  "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.7"
  },
  "interpreter": {
   "hash": "f4fde45515710cbe4f4cf44a8ddef1b298277709bd6c5462499553af68a98f2e"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}