Machine Learning for SVM, Logistic, Linear regression, Decision tree.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Import the required libraries**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All Libraries required for this lab are listed below. The libraries pre-installed on Skills Network Labs are commented.\n",
    "#!pip install -qy pandas==1.3.4 numpy==1.21.4 seaborn==0.9.0 matplotlib==3.5.0 scikit-learn==0.20.1\n",
    "# Note: If your environment doesn't support \"!mamba install\", use \"!pip install\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Surpress warnings:\n",
    "def warn(*args, **kwargs):\n",
    "    pass\n",
    "import warnings\n",
    "warnings.warn = warn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn import preprocessing\n",
    "import numpy as np\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import jaccard_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import log_loss\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "import sklearn.metrics as metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install jupyterlite-pyodide-kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing the Dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"Weather_dataa.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>Date</th>\n",
       "      <th>MinTemp</th>\n",
       "      <th>MaxTemp</th>\n",
       "      <th>Rainfall</th>\n",
       "      <th>Evaporation</th>\n",
       "      <th>Sunshine</th>\n",
       "      <th>WindGustDir</th>\n",
       "      <th>WindGustSpeed</th>\n",
       "      <th>WindDir9am</th>\n",
       "      <th>WindDir3pm</th>\n",
       "      <th>...</th>\n",
       "      <th>Humidity9am</th>\n",
       "      <th>Humidity3pm</th>\n",
       "      <th>Pressure9am</th>\n",
       "      <th>Pressure3pm</th>\n",
       "      <th>Cloud9am</th>\n",
       "      <th>Cloud3pm</th>\n",
       "      <th>Temp9am</th>\n",
       "      <th>Temp3pm</th>\n",
       "      <th>RainToday</th>\n",
       "      <th>RainTomorrow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2/1/2008</td>\n",
       "      <td>19.5</td>\n",
       "      <td>22.4</td>\n",
       "      <td>15.6</td>\n",
       "      <td>6.2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>W</td>\n",
       "      <td>41</td>\n",
       "      <td>S</td>\n",
       "      <td>SSW</td>\n",
       "      <td>...</td>\n",
       "      <td>92</td>\n",
       "      <td>84</td>\n",
       "      <td>1017.6</td>\n",
       "      <td>1017.4</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>20.7</td>\n",
       "      <td>20.9</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2/2/2008</td>\n",
       "      <td>19.5</td>\n",
       "      <td>25.6</td>\n",
       "      <td>6.0</td>\n",
       "      <td>3.4</td>\n",
       "      <td>2.7</td>\n",
       "      <td>W</td>\n",
       "      <td>41</td>\n",
       "      <td>W</td>\n",
       "      <td>E</td>\n",
       "      <td>...</td>\n",
       "      <td>83</td>\n",
       "      <td>73</td>\n",
       "      <td>1017.9</td>\n",
       "      <td>1016.4</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>22.4</td>\n",
       "      <td>24.8</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2/3/2008</td>\n",
       "      <td>21.6</td>\n",
       "      <td>24.5</td>\n",
       "      <td>6.6</td>\n",
       "      <td>2.4</td>\n",
       "      <td>0.1</td>\n",
       "      <td>W</td>\n",
       "      <td>41</td>\n",
       "      <td>ESE</td>\n",
       "      <td>ESE</td>\n",
       "      <td>...</td>\n",
       "      <td>88</td>\n",
       "      <td>86</td>\n",
       "      <td>1016.7</td>\n",
       "      <td>1015.6</td>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "      <td>23.5</td>\n",
       "      <td>23.0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2/4/2008</td>\n",
       "      <td>20.2</td>\n",
       "      <td>22.8</td>\n",
       "      <td>18.8</td>\n",
       "      <td>2.2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>W</td>\n",
       "      <td>41</td>\n",
       "      <td>NNE</td>\n",
       "      <td>E</td>\n",
       "      <td>...</td>\n",
       "      <td>83</td>\n",
       "      <td>90</td>\n",
       "      <td>1014.2</td>\n",
       "      <td>1011.8</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>21.4</td>\n",
       "      <td>20.9</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2/5/2008</td>\n",
       "      <td>19.7</td>\n",
       "      <td>25.7</td>\n",
       "      <td>77.4</td>\n",
       "      <td>4.8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>W</td>\n",
       "      <td>41</td>\n",
       "      <td>NNE</td>\n",
       "      <td>W</td>\n",
       "      <td>...</td>\n",
       "      <td>88</td>\n",
       "      <td>74</td>\n",
       "      <td>1008.3</td>\n",
       "      <td>1004.8</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>22.5</td>\n",
       "      <td>25.5</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 22 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       Date  MinTemp  MaxTemp  Rainfall  Evaporation  Sunshine WindGustDir  \\\n",
       "0  2/1/2008     19.5     22.4      15.6          6.2       0.0           W   \n",
       "1  2/2/2008     19.5     25.6       6.0          3.4       2.7           W   \n",
       "2  2/3/2008     21.6     24.5       6.6          2.4       0.1           W   \n",
       "3  2/4/2008     20.2     22.8      18.8          2.2       0.0           W   \n",
       "4  2/5/2008     19.7     25.7      77.4          4.8       0.0           W   \n",
       "\n",
       "   WindGustSpeed WindDir9am WindDir3pm  ...  Humidity9am  Humidity3pm  \\\n",
       "0             41          S        SSW  ...           92           84   \n",
       "1             41          W          E  ...           83           73   \n",
       "2             41        ESE        ESE  ...           88           86   \n",
       "3             41        NNE          E  ...           83           90   \n",
       "4             41        NNE          W  ...           88           74   \n",
       "\n",
       "   Pressure9am  Pressure3pm  Cloud9am  Cloud3pm  Temp9am  Temp3pm  RainToday  \\\n",
       "0       1017.6       1017.4         8         8     20.7     20.9        Yes   \n",
       "1       1017.9       1016.4         7         7     22.4     24.8        Yes   \n",
       "2       1016.7       1015.6         7         8     23.5     23.0        Yes   \n",
       "3       1014.2       1011.8         8         8     21.4     20.9        Yes   \n",
       "4       1008.3       1004.8         8         8     22.5     25.5        Yes   \n",
       "\n",
       "   RainTomorrow  \n",
       "0           Yes  \n",
       "1           Yes  \n",
       "2           Yes  \n",
       "3           Yes  \n",
       "4           Yes  \n",
       "\n",
       "[5 rows x 22 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preprocessing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One Hot Encoding\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform one hot encoding to convert categorical variables to binary variables.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sydney_processed = pd.get_dummies(data=df, columns=['RainToday', 'WindGustDir', 'WindDir9am', 'WindDir3pm'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we replace the values of the 'RainTomorrow' column changing them from a categorical column to a binary column. We do not use the `get_dummies` method because we would end up with two columns for 'RainTomorrow' and we do not want, since 'RainTomorrow' is our target.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sydney_processed.replace(['No', 'Yes'], [0,1], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Data and Test Data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we set our 'features' or x values and our Y or target variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sydney_processed.drop('Date',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sydney_processed = df_sydney_processed.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = df_sydney_processed.drop(columns='RainTomorrow', axis=1)\n",
    "Y = df_sydney_processed['RainTomorrow']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear Regression\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use the `train_test_split` function to split the `features` and `Y` dataframes with a `test_size` of `0.2` and the `random_state` set to `10`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_test, y_train, y_test = train_test_split(features, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create and train a Linear Regression model called LinearReg using the training data (`x_train`, `y_train`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "LinearReg = LinearRegression().fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now use the `predict` method on the testing data (`x_test`) and save it to the array `predictions`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = LinearReg.predict(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the `predictions` and the `y_test` dataframe calculate the value for each metric using the appropriate function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
    "\n",
    "LinearRegression_MAE = mean_absolute_error(y_test, predictions)\n",
    "LinearRegression_MSE = mean_squared_error(y_test, predictions)\n",
    "LinearRegression_R2 = r2_score(y_test, predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Show the MAE, MSE, and R2 in a tabular format using data frame for the linear model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Metric     Value\n",
      "0  Linear Reg MAE  0.258230\n",
      "1  Linear Reg MSE  0.118023\n",
      "2   Linear Reg R²  0.352222\n"
     ]
    }
   ],
   "source": [
    "Report1 = pd.DataFrame({\n",
    "    \"Metric\": [\"Linear Reg MAE\", \"Linear Reg MSE\", \"Linear Reg R²\"],\n",
    "    \"Value\": [LinearRegression_MAE, LinearRegression_MSE, LinearRegression_R2]\n",
    "})\n",
    "\n",
    "print(Report1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KNN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create and train a KNN model called KNN using the training data (`x_train`, `y_train`) with the `n_neighbors` parameter set to `4`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "KNN = KNeighborsClassifier(n_neighbors=4).fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now use the `predict` method on the testing data (`x_test`) and save it to the array `predictions`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = KNN.predict(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the `predictions` and the `y_test` dataframe calculate the value for each metric using the appropriate function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               Metric     Value\n",
      "0  KNN Accuracy Score  0.828851\n",
      "1   KNN Jaccard Index  0.404255\n",
      "2        KNN F1 Score  0.575758\n"
     ]
    }
   ],
   "source": [
    "KNN_Accuracy_Score = accuracy_score(y_test, predictions)\n",
    "KNN_JaccardIndex = jaccard_score(y_test, predictions)\n",
    "KNN_F1_Score = f1_score(y_test, predictions)\n",
    "\n",
    "Report2 = pd.DataFrame({\n",
    "    \"Metric\": [\"KNN Accuracy Score\", \"KNN Jaccard Index\", \"KNN F1 Score\"],\n",
    "    \"Value\": [KNN_Accuracy_Score, KNN_JaccardIndex, KNN_F1_Score]\n",
    "})\n",
    "\n",
    "print(Report2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create and train a Decision Tree model called Tree using the training data (`x_train`, `y_train`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "Tree = DecisionTreeClassifier().fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now use the `predict` method on the testing data (`x_test`) and save it to the array `predictions`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = Tree.predict(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the `predictions` and the `y_test` dataframe calculate the value for each metric using the appropriate function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                Metric     Value\n",
      "0  Tree Accuracy Score  0.773839\n",
      "1   Tree Jaccard Index  0.391447\n",
      "2        Tree F1 Score  0.562648\n"
     ]
    }
   ],
   "source": [
    "Tree_Accuracy_Score = accuracy_score(y_test, predictions)\n",
    "Tree_JaccardIndex = jaccard_score(y_test, predictions)\n",
    "Tree_F1_Score = f1_score(y_test, predictions)\n",
    "\n",
    "Report3 = pd.DataFrame({\n",
    "    \"Metric\": [\"Tree Accuracy Score\", \"Tree Jaccard Index\", \"Tree F1 Score\"],\n",
    "    \"Value\": [Tree_Accuracy_Score, Tree_JaccardIndex, Tree_F1_Score]\n",
    "})\n",
    "\n",
    "print(Report3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use the `train_test_split` function to split the `features` and `Y` dataframes with a `test_size` of `0.2` and the `random_state` set to `1`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_test, y_train, y_test = train_test_split(features, Y, test_size=0.2, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q13) Create and train a LogisticRegression model called LR using the training data (`x_train`, `y_train`) with the `solver` parameter set to `liblinear`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "LR = LogisticRegression(solver='liblinear').fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now, use the `predict` and `predict_proba` methods on the testing data (`x_test`) and save it as 2 arrays `predictions` and `predict_proba`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = LR.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict_proba = LR.predict_proba(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the `predictions`, `predict_proba` and the `y_test` dataframe calculate the value for each metric using the appropriate function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              Metric     Value\n",
      "0  LR Accuracy Score  0.835115\n",
      "1   LR Jaccard Index  0.504587\n",
      "2        LR F1 Score  0.670732\n",
      "3        LR Log Loss  0.381427\n"
     ]
    }
   ],
   "source": [
    "LR_Accuracy_Score = accuracy_score(y_test, predictions)\n",
    "LR_JaccardIndex = jaccard_score(y_test, predictions)\n",
    "LR_F1_Score = f1_score(y_test, predictions)\n",
    "LR_Log_Loss = log_loss(y_test, predict_proba)\n",
    "\n",
    "Report4 = pd.DataFrame({\n",
    "    \"Metric\": [\"LR Accuracy Score\", \"LR Jaccard Index\", \"LR F1 Score\", \"LR Log Loss\"],\n",
    "    \"Value\": [LR_Accuracy_Score, LR_JaccardIndex, LR_F1_Score, LR_Log_Loss]\n",
    "})\n",
    "\n",
    "print(Report4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create and train a SVM model called SVM using the training data (`x_train`, `y_train`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "SVM = SVC().fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now use the `predict` method on the testing data (`x_test`) and save it to the array `predictions`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = SVM.predict(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the `predictions` and the `y_test` dataframe calculate the value for each metric using the appropriate function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               Metric     Value\n",
      "0  SVM Accuracy Score  0.722137\n",
      "1   SVM Jaccard Index  0.000000\n",
      "2        SVM F1 Score  0.000000\n"
     ]
    }
   ],
   "source": [
    "SVM_Accuracy_Score = accuracy_score(y_test, predictions)\n",
    "SVM_JaccardIndex = jaccard_score(y_test, predictions)\n",
    "SVM_F1_Score = f1_score(y_test, predictions)\n",
    "\n",
    "Report5 = pd.DataFrame({\n",
    "    \"Metric\": [\"SVM Accuracy Score\", \"SVM Jaccard Index\", \"SVM F1 Score\"],\n",
    "    \"Value\": [SVM_Accuracy_Score, SVM_JaccardIndex, SVM_F1_Score]\n",
    "})\n",
    "\n",
    "print(Report5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Show the Accuracy,Jaccard Index,F1-Score and LogLoss in a tabular format using data frame for all of the above models.\n",
    "\n",
    "\\*LogLoss is only for Logistic Regression Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                 Metric     Value\n",
      "0        Linear Reg MAE  0.258230\n",
      "1        Linear Reg MSE  0.118023\n",
      "2         Linear Reg R²  0.352222\n",
      "3    KNN Accuracy Score  0.828851\n",
      "4     KNN Jaccard Index  0.404255\n",
      "5          KNN F1 Score  0.575758\n",
      "6   Tree Accuracy Score  0.773839\n",
      "7    Tree Jaccard Index  0.391447\n",
      "8         Tree F1 Score  0.562648\n",
      "9     LR Accuracy Score  0.835115\n",
      "10     LR Jaccard Index  0.504587\n",
      "11          LR F1 Score  0.670732\n",
      "12          LR Log Loss  0.381427\n",
      "13   SVM Accuracy Score  0.722137\n",
      "14    SVM Jaccard Index  0.000000\n",
      "15         SVM F1 Score  0.000000\n"
     ]
    }
   ],
   "source": [
    "Final_Report = pd.concat([Report1, Report2, Report3, Report4, Report5], ignore_index=True)\n",
    "\n",
    "print(Final_Report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.11.7"
  },
  "prev_pub_hash": "ba039b1c59dfa11e53b73e3fc8c403e1e8b43c7aedf6f7e0b1d1e7914b44d98a"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}