diff --git "a/HAR_Part_2.ipynb" "b/HAR_Part_2.ipynb"
new file mode 100644--- /dev/null
+++ "b/HAR_Part_2.ipynb"
@@ -0,0 +1,1184 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "gpuClass": "standard"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Applying Machine Learning Models"
+      ],
+      "metadata": {
+        "id": "sQGcMFmd1LwL"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "drl_NkpR1AUz"
+      },
+      "outputs": [],
+      "source": [
+        "#importing required libraries \n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import itertools\n",
+        "import matplotlib.pyplot as plt\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "from datetime import datetime\n",
+        "\n",
+        "from sklearn import linear_model\n",
+        "from sklearn import metrics\n",
+        "\n",
+        "from sklearn.model_selection import GridSearchCV\n",
+        "from sklearn.svm import LinearSVC\n",
+        "from sklearn.svm import SVC\n",
+        "from sklearn.tree import DecisionTreeClassifier\n",
+        "from sklearn.ensemble import RandomForestClassifier\n",
+        "from sklearn.ensemble import GradientBoostingClassifier"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Loading Data form File"
+      ],
+      "metadata": {
+        "id": "Lm6VtVdM1bCS"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train = pd.read_csv('/content/drive/MyDrive/UCI_HAR_Dataset/csv_files/train.csv')\n",
+        "test = pd.read_csv('/content/drive/MyDrive/UCI_HAR_Dataset/csv_files/test.csv')\n",
+        "print(train.shape, test.shape)"
+      ],
+      "metadata": {
+        "id": "2T3Z0hWP1aK4",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "2caee9cb-bbd7-4d4d-8e28-d2209b176a29"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "(7352, 564) (2947, 564)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train.head(2)"
+      ],
+      "metadata": {
+        "id": "C9HrxSH97urK",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 222
+        },
+        "outputId": "1064d9e7-2505-4979-ae84-bf57d41e29f4"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "   tBodyAcc-mean()-X  tBodyAcc-mean()-Y  tBodyAcc-mean()-Z  tBodyAcc-std()-X  \\\n",
+              "0           0.288585          -0.020294          -0.132905         -0.995279   \n",
+              "1           0.278419          -0.016411          -0.123520         -0.998245   \n",
+              "\n",
+              "   tBodyAcc-std()-Y  tBodyAcc-std()-Z  tBodyAcc-mad()-X  tBodyAcc-mad()-Y  \\\n",
+              "0         -0.983111         -0.913526         -0.995112         -0.983185   \n",
+              "1         -0.975300         -0.960322         -0.998807         -0.974914   \n",
+              "\n",
+              "   tBodyAcc-mad()-Z  tBodyAcc-max()-X  ...  angle(tBodyAccMean,gravity)  \\\n",
+              "0         -0.923527         -0.934724  ...                    -0.112754   \n",
+              "1         -0.957686         -0.943068  ...                     0.053477   \n",
+              "\n",
+              "   angle(tBodyAccJerkMean),gravityMean)  angle(tBodyGyroMean,gravityMean)  \\\n",
+              "0                              0.030400                         -0.464761   \n",
+              "1                             -0.007435                         -0.732626   \n",
+              "\n",
+              "   angle(tBodyGyroJerkMean,gravityMean)  angle(X,gravityMean)  \\\n",
+              "0                             -0.018446             -0.841247   \n",
+              "1                              0.703511             -0.844788   \n",
+              "\n",
+              "   angle(Y,gravityMean)  angle(Z,gravityMean)  subject  Activity  ActivityName  \n",
+              "0              0.179941             -0.058627        1         5      STANDING  \n",
+              "1              0.180289             -0.054317        1         5      STANDING  \n",
+              "\n",
+              "[2 rows x 564 columns]"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-71be3a7f-4477-4b31-a1c9-52240847aa30\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <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>tBodyAcc-mean()-X</th>\n",
+              "      <th>tBodyAcc-mean()-Y</th>\n",
+              "      <th>tBodyAcc-mean()-Z</th>\n",
+              "      <th>tBodyAcc-std()-X</th>\n",
+              "      <th>tBodyAcc-std()-Y</th>\n",
+              "      <th>tBodyAcc-std()-Z</th>\n",
+              "      <th>tBodyAcc-mad()-X</th>\n",
+              "      <th>tBodyAcc-mad()-Y</th>\n",
+              "      <th>tBodyAcc-mad()-Z</th>\n",
+              "      <th>tBodyAcc-max()-X</th>\n",
+              "      <th>...</th>\n",
+              "      <th>angle(tBodyAccMean,gravity)</th>\n",
+              "      <th>angle(tBodyAccJerkMean),gravityMean)</th>\n",
+              "      <th>angle(tBodyGyroMean,gravityMean)</th>\n",
+              "      <th>angle(tBodyGyroJerkMean,gravityMean)</th>\n",
+              "      <th>angle(X,gravityMean)</th>\n",
+              "      <th>angle(Y,gravityMean)</th>\n",
+              "      <th>angle(Z,gravityMean)</th>\n",
+              "      <th>subject</th>\n",
+              "      <th>Activity</th>\n",
+              "      <th>ActivityName</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0.288585</td>\n",
+              "      <td>-0.020294</td>\n",
+              "      <td>-0.132905</td>\n",
+              "      <td>-0.995279</td>\n",
+              "      <td>-0.983111</td>\n",
+              "      <td>-0.913526</td>\n",
+              "      <td>-0.995112</td>\n",
+              "      <td>-0.983185</td>\n",
+              "      <td>-0.923527</td>\n",
+              "      <td>-0.934724</td>\n",
+              "      <td>...</td>\n",
+              "      <td>-0.112754</td>\n",
+              "      <td>0.030400</td>\n",
+              "      <td>-0.464761</td>\n",
+              "      <td>-0.018446</td>\n",
+              "      <td>-0.841247</td>\n",
+              "      <td>0.179941</td>\n",
+              "      <td>-0.058627</td>\n",
+              "      <td>1</td>\n",
+              "      <td>5</td>\n",
+              "      <td>STANDING</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>0.278419</td>\n",
+              "      <td>-0.016411</td>\n",
+              "      <td>-0.123520</td>\n",
+              "      <td>-0.998245</td>\n",
+              "      <td>-0.975300</td>\n",
+              "      <td>-0.960322</td>\n",
+              "      <td>-0.998807</td>\n",
+              "      <td>-0.974914</td>\n",
+              "      <td>-0.957686</td>\n",
+              "      <td>-0.943068</td>\n",
+              "      <td>...</td>\n",
+              "      <td>0.053477</td>\n",
+              "      <td>-0.007435</td>\n",
+              "      <td>-0.732626</td>\n",
+              "      <td>0.703511</td>\n",
+              "      <td>-0.844788</td>\n",
+              "      <td>0.180289</td>\n",
+              "      <td>-0.054317</td>\n",
+              "      <td>1</td>\n",
+              "      <td>5</td>\n",
+              "      <td>STANDING</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>2 rows × 564 columns</p>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-71be3a7f-4477-4b31-a1c9-52240847aa30')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-71be3a7f-4477-4b31-a1c9-52240847aa30 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-71be3a7f-4477-4b31-a1c9-52240847aa30');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ]
+          },
+          "metadata": {},
+          "execution_count": 3
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### **Making Data for Model**"
+      ],
+      "metadata": {
+        "id": "bm1Q842V7x1j"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "X_train = train.drop(['subject', 'Activity', 'ActivityName'], axis=1)\n",
+        "y_train = train.ActivityName\n",
+        "\n",
+        "X_test = test.drop(['subject', 'Activity', 'ActivityName'], axis=1)\n",
+        "y_test = test.ActivityName\n",
+        "\n",
+        "print('X_train and y_train : ({},{})'.format(X_train.shape, y_train.shape))\n",
+        "print('X_test  and y_test  : ({},{})'.format(X_test.shape, y_test.shape))"
+      ],
+      "metadata": {
+        "id": "2iKFWEvy7vet",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4f2cf9f4-98e6-42b8-f1a0-11b8257aa3cd"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "X_train and y_train : ((7352, 561),(7352,))\n",
+            "X_test  and y_test  : ((2947, 561),(2947,))\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Creat a model with our Dataset**"
+      ],
+      "metadata": {
+        "id": "K88PMVcEAOd6"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#Labels that are useful in plotting confusion matrix\n",
+        "labels=['LAYING', 'SITTING','STANDING','WALKING','WALKING_DOWNSTAIRS','WALKING_UPSTAIRS']"
+      ],
+      "metadata": {
+        "id": "d0IitEyHAb5U"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Let's define a function to plot the confusion matrix**"
+      ],
+      "metadata": {
+        "id": "doaaVuPrAXfc"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def plot_confusion_matrix(cm, classes,\n",
+        "                          normalize=False,\n",
+        "                          title='Confusion matrix',\n",
+        "                          cmap=plt.cm.Blues):\n",
+        "    if normalize:\n",
+        "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
+        "\n",
+        "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
+        "    plt.title(title)\n",
+        "    plt.colorbar()\n",
+        "    tick_marks = np.arange(len(classes))\n",
+        "    plt.xticks(tick_marks, classes, rotation=90)\n",
+        "    plt.yticks(tick_marks, classes)\n",
+        "\n",
+        "    fmt = '.2f' if normalize else 'd'\n",
+        "    thresh = cm.max() / 2.\n",
+        "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
+        "        plt.text(j, i, format(cm[i, j], fmt),\n",
+        "                 horizontalalignment=\"center\",\n",
+        "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
+        "\n",
+        "    plt.tight_layout()\n",
+        "    plt.ylabel('True label')\n",
+        "    plt.xlabel('Predicted label')"
+      ],
+      "metadata": {
+        "id": "UeaZTd0qAfv9"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Let's define a function to run any model specified**"
+      ],
+      "metadata": {
+        "id": "B5QFLapTBNGA"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from datetime import datetime\n",
+        "def perform_model(model, X_train, y_train, X_test, y_test, class_labels, cm_normalize=True, \\\n",
+        "                 print_cm=True, cm_cmap=plt.cm.Greens):\n",
+        "    \n",
+        "    \n",
+        "    # to store results at various phases\n",
+        "    results = dict()\n",
+        "    \n",
+        "    # time at which model starts training \n",
+        "    train_start_time = datetime.now()\n",
+        "    print('training the model..')\n",
+        "    model.fit(X_train, y_train)\n",
+        "    print('Done....!\\n')\n",
+        "    train_end_time = datetime.now()\n",
+        "    results['training_time'] =  train_end_time - train_start_time\n",
+        "    print('==> training time:- {}\\n'.format(results['training_time']))\n",
+        "    \n",
+        "    \n",
+        "    # predict test data\n",
+        "    print('Predicting test data')\n",
+        "    test_start_time = datetime.now()\n",
+        "    y_pred = model.predict(X_test)\n",
+        "    test_end_time = datetime.now()\n",
+        "    print('Done....!\\n')\n",
+        "    results['testing_time'] = test_end_time - test_start_time\n",
+        "    print('==> testing time:- {}\\n'.format(results['testing_time']))\n",
+        "    results['predicted'] = y_pred\n",
+        "   \n",
+        "\n",
+        "    # calculate overall accuracty of the model\n",
+        "    accuracy = metrics.accuracy_score(y_true=y_test, y_pred=y_pred)\n",
+        "    # store accuracy in results\n",
+        "    results['accuracy'] = accuracy\n",
+        "    print('==> Accuracy:- {}\\n'.format(accuracy))\n",
+        "   \n",
+        "    \n",
+        "    \n",
+        "    # confusion matrix\n",
+        "    cm = metrics.confusion_matrix(y_test, y_pred)\n",
+        "    results['confusion_matrix'] = cm\n",
+        "    if print_cm: \n",
+        "        print('\\n ********Confusion Matrix********')\n",
+        "        print('\\n {}'.format(cm))\n",
+        "        \n",
+        "    # plot confusin matrix\n",
+        "    plt.figure(figsize=(6,6))\n",
+        "    plt.grid(b=False)\n",
+        "    plot_confusion_matrix(cm, classes=class_labels, normalize=True, title='Normalized confusion matrix', cmap = cm_cmap)\n",
+        "    plt.show()\n",
+        "    \n",
+        "    # get classification report\n",
+        "    print('****************| Classifiction Report |****************')\n",
+        "    classification_report = metrics.classification_report(y_test, y_pred)\n",
+        "   \n",
+        "    # store report in results\n",
+        "    results['classification_report'] = classification_report\n",
+        "    print(classification_report)\n",
+        "    \n",
+        "    # add the trained  model to the results\n",
+        "    results['model'] = model\n",
+        "    \n",
+        "    return results"
+      ],
+      "metadata": {
+        "id": "II4zsTIdBeXT"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Define function to print the gridsearch Parameters**"
+      ],
+      "metadata": {
+        "id": "NJWTvtZmCiPD"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "def print_grid_search_attributes(model):\n",
+        "    # Estimator that gave highest score among all the estimators formed in GridSearch\n",
+        "    print('\\n\\n==> Best Estimator:')\n",
+        "    print('\\t{}\\n'.format(model.best_estimator_))\n",
+        "\n",
+        "\n",
+        "    # parameters that gave best results while performing grid search\n",
+        "    print('\\n==> Best parameters:')\n",
+        "    print('\\tParameters of best estimator : {}'.format(model.best_params_))\n",
+        "\n",
+        "\n",
+        "    #  number of cross validation splits\n",
+        "    print('\\n==> No. of CrossValidation sets:')\n",
+        "    print('\\tTotal numbre of cross validation sets: {}'.format(model.n_splits_))\n",
+        "\n",
+        "\n",
+        "    # Average cross validated score of the best estimator, from the Grid Search \n",
+        "    print('\\n==> Best Score:')\n",
+        "    print('\\tAverage Cross Validate scores of best estimator : {}'.format(model.best_score_))"
+      ],
+      "metadata": {
+        "id": "SUmk6iANChqE"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### 1. Logistic Regression with Grid Search"
+      ],
+      "metadata": {
+        "id": "SED_FTJ9C_0a"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import warnings\n",
+        "from sklearn.exceptions import ConvergenceWarning\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "warnings.simplefilter(action='ignore', category=ConvergenceWarning)\n",
+        "\n",
+        "#Grid search\n",
+        "parameters = {'C':[0.01, 0.1, 1, 10, 20, 30], 'penalty':['l2','l1']}\n",
+        "log_reg = linear_model.LogisticRegression()\n",
+        "log_reg_grid = GridSearchCV(log_reg, param_grid=parameters, cv=3, verbose=1, n_jobs=-1)\n",
+        "log_reg_grid_results =  perform_model(log_reg_grid, X_train, y_train, X_test, y_test, class_labels=labels)\n",
+        "\n",
+        "# observe the attributes of the model \n",
+        "print_grid_search_attributes(log_reg_grid_results['model'])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "PB5MBnOqDGpK",
+        "outputId": "75410cc9-e23b-4573-f8ee-d8b73ed679a1"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "training the model..\n",
+            "Fitting 3 folds for each of 12 candidates, totalling 36 fits\n",
+            "Done....!\n",
+            "\n",
+            "==> training time:- 0:00:41.661560\n",
+            "\n",
+            "Predicting test data\n",
+            "Done....!\n",
+            "\n",
+            "==> testing time:- 0:00:00.014502\n",
+            "\n",
+            "==> Accuracy:- 0.9579233118425518\n",
+            "\n",
+            "\n",
+            " ********Confusion Matrix********\n",
+            "\n",
+            " [[537   0   0   0   0   0]\n",
+            " [  0 430  58   0   0   3]\n",
+            " [  0  16 516   0   0   0]\n",
+            " [  0   0   0 492   3   1]\n",
+            " [  0   0   0   4 403  13]\n",
+            " [  0   0   0  24   2 445]]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x432 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "****************| Classifiction Report |****************\n",
+            "                    precision    recall  f1-score   support\n",
+            "\n",
+            "            LAYING       1.00      1.00      1.00       537\n",
+            "           SITTING       0.96      0.88      0.92       491\n",
+            "          STANDING       0.90      0.97      0.93       532\n",
+            "           WALKING       0.95      0.99      0.97       496\n",
+            "WALKING_DOWNSTAIRS       0.99      0.96      0.97       420\n",
+            "  WALKING_UPSTAIRS       0.96      0.94      0.95       471\n",
+            "\n",
+            "          accuracy                           0.96      2947\n",
+            "         macro avg       0.96      0.96      0.96      2947\n",
+            "      weighted avg       0.96      0.96      0.96      2947\n",
+            "\n",
+            "\n",
+            "\n",
+            "==> Best Estimator:\n",
+            "\tLogisticRegression(C=1)\n",
+            "\n",
+            "\n",
+            "==> Best parameters:\n",
+            "\tParameters of best estimator : {'C': 1, 'penalty': 'l2'}\n",
+            "\n",
+            "==> No. of CrossValidation sets:\n",
+            "\tTotal numbre of cross validation sets: 3\n",
+            "\n",
+            "==> Best Score:\n",
+            "\tAverage Cross Validate scores of best estimator : 0.938249555228048\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### 2. Linear SVC with GridSearch"
+      ],
+      "metadata": {
+        "id": "7s-e9KL9Dazr"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "parameters = {'C':[0.125, 0.5, 1, 2, 8, 16]}\n",
+        "lr_svc = LinearSVC(tol=0.00005)\n",
+        "lr_svc_grid = GridSearchCV(lr_svc, param_grid=parameters, n_jobs=-1, verbose=1)\n",
+        "lr_svc_grid_results = perform_model(lr_svc_grid, X_train, y_train, X_test, y_test, class_labels=labels)\n",
+        "\n",
+        "# observe the attributes of the model \n",
+        "print_grid_search_attributes(lr_svc_grid_results['model'])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "Jfpz4EZiDaBf",
+        "outputId": "47659c7b-86f7-42d5-9f2e-6462be171e83"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "training the model..\n",
+            "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
+            "Done....!\n",
+            "\n",
+            "==> training time:- 0:02:10.736328\n",
+            "\n",
+            "Predicting test data\n",
+            "Done....!\n",
+            "\n",
+            "==> testing time:- 0:00:00.012594\n",
+            "\n",
+            "==> Accuracy:- 0.9667458432304038\n",
+            "\n",
+            "\n",
+            " ********Confusion Matrix********\n",
+            "\n",
+            " [[537   0   0   0   0   0]\n",
+            " [  2 428  58   0   0   3]\n",
+            " [  0   9 522   1   0   0]\n",
+            " [  0   0   0 496   0   0]\n",
+            " [  0   0   0   3 412   5]\n",
+            " [  0   0   0  17   0 454]]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x432 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "****************| Classifiction Report |****************\n",
+            "                    precision    recall  f1-score   support\n",
+            "\n",
+            "            LAYING       1.00      1.00      1.00       537\n",
+            "           SITTING       0.98      0.87      0.92       491\n",
+            "          STANDING       0.90      0.98      0.94       532\n",
+            "           WALKING       0.96      1.00      0.98       496\n",
+            "WALKING_DOWNSTAIRS       1.00      0.98      0.99       420\n",
+            "  WALKING_UPSTAIRS       0.98      0.96      0.97       471\n",
+            "\n",
+            "          accuracy                           0.97      2947\n",
+            "         macro avg       0.97      0.97      0.97      2947\n",
+            "      weighted avg       0.97      0.97      0.97      2947\n",
+            "\n",
+            "\n",
+            "\n",
+            "==> Best Estimator:\n",
+            "\tLinearSVC(C=0.5, tol=5e-05)\n",
+            "\n",
+            "\n",
+            "==> Best parameters:\n",
+            "\tParameters of best estimator : {'C': 0.5}\n",
+            "\n",
+            "==> No. of CrossValidation sets:\n",
+            "\tTotal numbre of cross validation sets: 5\n",
+            "\n",
+            "==> Best Score:\n",
+            "\tAverage Cross Validate scores of best estimator : 0.9423364179118282\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### 3. Kernel SVM with GridSearch"
+      ],
+      "metadata": {
+        "id": "hjRIYxO1Ea50"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "parameters = {'C':[2,8,16],\\\n",
+        "              'gamma': [ 0.0078125, 0.125, 2]}\n",
+        "rbf_svm = SVC(kernel='rbf')\n",
+        "rbf_svm_grid = GridSearchCV(rbf_svm,param_grid=parameters, n_jobs=-1)\n",
+        "rbf_svm_grid_results = perform_model(rbf_svm_grid, X_train, y_train, X_test, y_test, class_labels=labels)\n",
+        "\n",
+        "# observe the attributes of the model \n",
+        "print_grid_search_attributes(rbf_svm_grid_results['model'])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "oSWIPupPEbGs",
+        "outputId": "830a2f6d-705d-4f16-92f8-ab4204c7eb9f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "training the model..\n",
+            "Done....!\n",
+            "\n",
+            "==> training time:- 0:07:39.387062\n",
+            "\n",
+            "Predicting test data\n",
+            "Done....!\n",
+            "\n",
+            "==> testing time:- 0:00:01.752974\n",
+            "\n",
+            "==> Accuracy:- 0.9626739056667798\n",
+            "\n",
+            "\n",
+            " ********Confusion Matrix********\n",
+            "\n",
+            " [[537   0   0   0   0   0]\n",
+            " [  0 441  48   0   0   2]\n",
+            " [  0  12 520   0   0   0]\n",
+            " [  0   0   0 489   2   5]\n",
+            " [  0   0   0   4 397  19]\n",
+            " [  0   0   0  17   1 453]]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x432 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "****************| Classifiction Report |****************\n",
+            "                    precision    recall  f1-score   support\n",
+            "\n",
+            "            LAYING       1.00      1.00      1.00       537\n",
+            "           SITTING       0.97      0.90      0.93       491\n",
+            "          STANDING       0.92      0.98      0.95       532\n",
+            "           WALKING       0.96      0.99      0.97       496\n",
+            "WALKING_DOWNSTAIRS       0.99      0.95      0.97       420\n",
+            "  WALKING_UPSTAIRS       0.95      0.96      0.95       471\n",
+            "\n",
+            "          accuracy                           0.96      2947\n",
+            "         macro avg       0.96      0.96      0.96      2947\n",
+            "      weighted avg       0.96      0.96      0.96      2947\n",
+            "\n",
+            "\n",
+            "\n",
+            "==> Best Estimator:\n",
+            "\tSVC(C=16, gamma=0.0078125)\n",
+            "\n",
+            "\n",
+            "==> Best parameters:\n",
+            "\tParameters of best estimator : {'C': 16, 'gamma': 0.0078125}\n",
+            "\n",
+            "==> No. of CrossValidation sets:\n",
+            "\tTotal numbre of cross validation sets: 5\n",
+            "\n",
+            "==> Best Score:\n",
+            "\tAverage Cross Validate scores of best estimator : 0.9447834551903698\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### 4. Decision Trees with GridSearchCV"
+      ],
+      "metadata": {
+        "id": "4RF5aOZeEizo"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "parameters = {'max_depth':np.arange(3,10,2)}\n",
+        "dt = DecisionTreeClassifier()\n",
+        "dt_grid = GridSearchCV(dt,param_grid=parameters, n_jobs=-1)\n",
+        "dt_grid_results = perform_model(dt_grid, X_train, y_train, X_test, y_test, class_labels=labels)\n",
+        "\n",
+        "# observe the attributes of the model \n",
+        "print_grid_search_attributes(dt_grid_results['model'])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "-HbZkItNEjCf",
+        "outputId": "37de1ab5-da98-4a0d-b2af-1b91f1847a42"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "training the model..\n",
+            "Done....!\n",
+            "\n",
+            "==> training time:- 0:00:37.518427\n",
+            "\n",
+            "Predicting test data\n",
+            "Done....!\n",
+            "\n",
+            "==> testing time:- 0:00:00.006978\n",
+            "\n",
+            "==> Accuracy:- 0.8768238887003733\n",
+            "\n",
+            "\n",
+            " ********Confusion Matrix********\n",
+            "\n",
+            " [[537   0   0   0   0   0]\n",
+            " [  0 374 117   0   0   0]\n",
+            " [  0  60 472   0   0   0]\n",
+            " [  0   0   0 473  17   6]\n",
+            " [  0   0   0  27 345  48]\n",
+            " [  0   0   0  67  21 383]]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x432 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "****************| Classifiction Report |****************\n",
+            "                    precision    recall  f1-score   support\n",
+            "\n",
+            "            LAYING       1.00      1.00      1.00       537\n",
+            "           SITTING       0.86      0.76      0.81       491\n",
+            "          STANDING       0.80      0.89      0.84       532\n",
+            "           WALKING       0.83      0.95      0.89       496\n",
+            "WALKING_DOWNSTAIRS       0.90      0.82      0.86       420\n",
+            "  WALKING_UPSTAIRS       0.88      0.81      0.84       471\n",
+            "\n",
+            "          accuracy                           0.88      2947\n",
+            "         macro avg       0.88      0.87      0.87      2947\n",
+            "      weighted avg       0.88      0.88      0.88      2947\n",
+            "\n",
+            "\n",
+            "\n",
+            "==> Best Estimator:\n",
+            "\tDecisionTreeClassifier(max_depth=9)\n",
+            "\n",
+            "\n",
+            "==> Best parameters:\n",
+            "\tParameters of best estimator : {'max_depth': 9}\n",
+            "\n",
+            "==> No. of CrossValidation sets:\n",
+            "\tTotal numbre of cross validation sets: 5\n",
+            "\n",
+            "==> Best Score:\n",
+            "\tAverage Cross Validate scores of best estimator : 0.853654924920342\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### 5. Random Forest Classifier with GridSearch"
+      ],
+      "metadata": {
+        "id": "g9b081RwEtjp"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "params = {'n_estimators': np.arange(10,201,20), 'max_depth':np.arange(3,15,2)}\n",
+        "rfc = RandomForestClassifier()\n",
+        "rfc_grid = GridSearchCV(rfc, param_grid=params, n_jobs=-1)\n",
+        "rfc_grid_results = perform_model(rfc_grid, X_train, y_train, X_test, y_test, class_labels=labels)\n",
+        "\n",
+        "# observe the attributes of the model \n",
+        "print_grid_search_attributes(rfc_grid_results['model'])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "JGrZ3NXdEuWF",
+        "outputId": "8a214001-4d0d-4992-ff81-d2f43bd0601f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "training the model..\n",
+            "Done....!\n",
+            "\n",
+            "==> training time:- 0:24:49.189297\n",
+            "\n",
+            "Predicting test data\n",
+            "Done....!\n",
+            "\n",
+            "==> testing time:- 0:00:00.033684\n",
+            "\n",
+            "==> Accuracy:- 0.9195792331184255\n",
+            "\n",
+            "\n",
+            " ********Confusion Matrix********\n",
+            "\n",
+            " [[537   0   0   0   0   0]\n",
+            " [  0 428  63   0   0   0]\n",
+            " [  0  40 492   0   0   0]\n",
+            " [  0   0   0 481  11   4]\n",
+            " [  0   0   0  28 354  38]\n",
+            " [  0   0   0  46   7 418]]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x432 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "****************| Classifiction Report |****************\n",
+            "                    precision    recall  f1-score   support\n",
+            "\n",
+            "            LAYING       1.00      1.00      1.00       537\n",
+            "           SITTING       0.91      0.87      0.89       491\n",
+            "          STANDING       0.89      0.92      0.91       532\n",
+            "           WALKING       0.87      0.97      0.92       496\n",
+            "WALKING_DOWNSTAIRS       0.95      0.84      0.89       420\n",
+            "  WALKING_UPSTAIRS       0.91      0.89      0.90       471\n",
+            "\n",
+            "          accuracy                           0.92      2947\n",
+            "         macro avg       0.92      0.92      0.92      2947\n",
+            "      weighted avg       0.92      0.92      0.92      2947\n",
+            "\n",
+            "\n",
+            "\n",
+            "==> Best Estimator:\n",
+            "\tRandomForestClassifier(max_depth=13, n_estimators=50)\n",
+            "\n",
+            "\n",
+            "==> Best parameters:\n",
+            "\tParameters of best estimator : {'max_depth': 13, 'n_estimators': 50}\n",
+            "\n",
+            "==> No. of CrossValidation sets:\n",
+            "\tTotal numbre of cross validation sets: 5\n",
+            "\n",
+            "==> Best Score:\n",
+            "\tAverage Cross Validate scores of best estimator : 0.9243778816761239\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### 6. Comparing all models"
+      ],
+      "metadata": {
+        "id": "CQ7KUMbqFJ0x"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print('\\n                     Accuracy     Error')\n",
+        "print('                     ----------   --------')\n",
+        "print('Logistic Regression : {:.04}%       {:.04}%'.format(log_reg_grid_results['accuracy'] * 100,\\\n",
+        "                                                  100-(log_reg_grid_results['accuracy'] * 100)))\n",
+        "\n",
+        "print('Linear SVC          : {:.04}%       {:.04}% '.format(lr_svc_grid_results['accuracy'] * 100,\\\n",
+        "                                                        100-(lr_svc_grid_results['accuracy'] * 100)))\n",
+        "\n",
+        "print('rbf SVM classifier  : {:.04}%      {:.04}% '.format(rbf_svm_grid_results['accuracy'] * 100,\\\n",
+        "                                                          100-(rbf_svm_grid_results['accuracy'] * 100)))\n",
+        "\n",
+        "print('DecisionTree        : {:.04}%      {:.04}% '.format(dt_grid_results['accuracy'] * 100,\\\n",
+        "                                                        100-(dt_grid_results['accuracy'] * 100)))\n",
+        "\n",
+        "print('Random Forest       : {:.04}%      {:.04}% '.format(rfc_grid_results['accuracy'] * 100,\\\n",
+        "                                                           100-(rfc_grid_results['accuracy'] * 100)))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "euXHQqyWFLnI",
+        "outputId": "7073f45b-3fe4-4cd1-82c2-d1d49bbca09d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "                     Accuracy     Error\n",
+            "                     ----------   --------\n",
+            "Logistic Regression : 95.79%       4.208%\n",
+            "Linear SVC          : 96.67%       3.325% \n",
+            "rbf SVM classifier  : 96.27%      3.733% \n",
+            "DecisionTree        : 87.68%      12.32% \n",
+            "Random Forest       : 91.96%      8.042% \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Plotting graph to show Accuracy with every Model "
+      ],
+      "metadata": {
+        "id": "pF98YyQn500P"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x= [\"Logistic Regression\",\"Linear SVC\",\"rbf SVM classifie\",\"DecisionTree\",\"Random Forest\"]\n",
+        "y= [95.79,96.67,96.27,87.68,91.96]\n",
+        "plt.bar(x,y, color=['green', 'blue', 'black', 'red','purple'])\n",
+        "plt.xlabel(\"Models\")\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.title('Comparison of Model Accuracy')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 295
+        },
+        "id": "eBEqWYuQ5_uJ",
+        "outputId": "202e91ed-28c8-4c0f-8f81-85fcc3ac8bc4"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAi0UlEQVR4nO3dd5hdVdn+8e9NAiShhZCIEEpAmhSJEBFEhRdQAZEgTRBIgijwqliQpi9K8IcICAKiqCglSO9FlBZApAUSCEnoRUpoGTCUQGjJ8/tjrbOzczhn5sxkZk6SuT/XNdfsvteuz1pr772OIgIzMzOARZqdADMzm384KJiZWcFBwczMCg4KZmZWcFAwM7OCg4KZmRUcFGyBIGkvSTc2Ox0VkvpKulbSG5Iu7cb13ibp2w1OG5LW6Oo02cLFQaGHkfRNSeMlzZD0kqR/Svp8s9PVlog4PyK+3Ox0lOwKLA8sFxG7VY+UNDrflH9YNfyHefjobkpnqySdI+lDSSs0Oy02f3BQ6EEkHQycAhxLuqGtApwODG9istokqXez01DDqsDjEfFhK9M8DoyoGjYyD286SUsAuwBvAHt387rnx2NqOCj0GJKWAX4JfC8iroiItyPig4i4NiIOzdMsLukUSS/mv1MkLZ7HbSlpqqTDJE3LpYydJG0v6XFJ/5X0s9L6Rku6TNLFkt6SdL+kDUvjj5D0VB73sKSvl8aNknSnpJMlvQaMzsPuyOOVx02T9KakyZLWr2ynpHMltUh6VtKRkhYpLfcOSSdKmi7pP5K2a2WffTJX17wu6SFJO+bhRwO/AL6RS1z71VnEfUA/Sevl+dYD+uTh5fV8R9KTeR9eI2nF0rgvSXo0V1P9HlDVvN+S9EjenhskrVpve2rYBXiddF6MrFruAEln5/NguqSrSuOGS5qY9/1TkrbNw5+RtE1putGSzsvdQ3IJaT9JzwG35OGXSno5b9/tlX2Vx/WVdFI+jm/kY9dX0nWSDqpK76TyOWQd56DQc2xGuiFd2co0/wdsCgwFNgQ2AY4sjf94XsZg0k3xL6Qc5sbAF4CfS1qtNP1w4FJgAHABcJWkRfO4p/I8ywBHA+dVVWF8FniaVKL5VVU6vwx8EVgrz7878Foed1oetjqwBSmnvm/Vch8DBgInAGdKmutGC5DTeS1wI/Ax4CDgfElrR8RRpNLWxRGxZEScWT1/yd+YU1oYmfvL69kK+HXehhWAZ4GL8riBwBWkYzCQtM82L807HPgZsDMwCPg3cGEraak2Mk9/EbCOpI2r0t0PWC9v/8l5nZsA5wKHAv1Jx+GZdqxzC+CTwFdy/z+BNfM67gfOL017Iunc+hzpHDoMmA2MoVSyyZmNwcB17UiH1RMR/usBf8BewMttTPMUsH2p/yvAM7l7S2Am0Cv3LwUE8NnS9BOAnXL3aOCe0rhFgJeAL9RZ90RgeO4eBTxXNX4UcEfu3opUBbMpsEhpml7A+8C6pWEHALeVlvFkaVy/vA0fr5GeLwAvVy3/QmB0afvOa2VfjgbOI1XRPQcsmv+vnIdXlnMmcEJpviWBD4AhpGBS3ocCpgLfzv3/BPar2sfvAKvm/gDWqJO+VUg32KG5/wbg1Ny9Qh63bI35/gycXGeZzwDbVO+D3D0kp2f1VvZZ/zzNMnlbZgIb1piuDzAdWDP3nwic3uxrbGH5c0mh53gNGKjW63JXJOVUK57Nw4plRMSs3D0z/3+lNH4m6aZW8XylIyJmk25oKwJIGpGrIF6X9DqwPik3/JF5q0XELcDvgT8A0ySdIWnpPP+iNbZhcKn/5dJy3smd5TRXrAg8n9Ndb1ltiojngCdJJYsnIqJ6u+ba5xExg3SsBlfSUBoXzL1fVgVOLe3D/5ICRyNp3Ad4JCIm5v7zgW/mEtLKwH8jYnqN+VYmZR46qki/pF6SjstVUG8yp8QxMP/1qbWuiHgXuBjYO1cN7klVCcw6zkGh57gbeA/YqZVpXiTdaCpWycM6auVKR754VwJezPXefwG+T3p7pz8whbnry1ttvjcifhcRGwPrkqqRDgVeJeWyq7fhhQ6k/UVg5crziHlc1rnAT/L/Wusp0qv08He5vJ6XmHsfqtxPusEeEBH9S399I+KuBtI0Alg91+e/DPyWdCPePi93gKT+NeZ7HvhEnWW+TSp9VXy8xjTl4/pNUhXjNqTSwZA8XKRj+W4r6xpDKv1uDbwTEXfXmc7ayUGhh4iIN0jPAf6g9IC4n6RFJW0n6YQ82YXAkZIG5frsX5CqOjpqY0k759LJj0hB6R5gCdLNoQVA0r6kkkJDJH1G0mdzrvZt0s1jdi7FXAL8StJSOfgc3MFtGEeqijks76ctga+R6/vb6WLSc5BLaoy7ENhX0lClh/rHAuMi4hlSHfl6pX34A+a+0f4J+GnpQfYykj7yemw1SZuRbrabkJ4fDSXt/wuAERHxEqlq6nRJy+bt/2Ke/cyc3q0lLSJpsKR18riJwB55+mGk13ZbsxTpnHiNFEyOrYzIJbSzgN9KWjGXKjbL+4gcBGYDJ+FSQqdyUOhBIuIk0k3ySNIN+XlSbv2qPMkxwHhgEjCZ9ODvmHlY5dXAN0j1v/sAO0d64+lh0sV8N6n6aQPgznYsd2lSSWM6qerlNeA3edxBpEDxNHAH6UZ3VnsTHhHvk4LAdqRc6+mkG+ajHVjWzIi4OSJm1hh3M/Bz4HJSyeATwB553KvAbsBxpG1ck9J+iogrgeOBi3L1y5Sc3raMBK6OiMkR8XLlDzgV2EHSANLx+gB4FJhGCupExL2kB/cnk15l/RdzSjo/z+mfTnp54II20nEu6fi9ADxMyjCUHUI6D+8jVY0dz9z3rHNJ5868ZFysivKDGrNOpfRx1hoR0a3vv1vPIWkEsH9EzPcfXy5IXFIwswWOpH7Ad4Ezmp2WhY2DgpktUCR9hVT9+QptV1FZO7n6yMzMCi4pmJlZocsapZJ0FrADMC0iKu3SDCC9njeE9KHK7hExPb9/fSrpHel3gFERcX9b6xg4cGAMGTKkS9JvZrawmjBhwqsRMajWuK5sqfAc0len5Q92jgDGRsRxko7I/YeTXqNbM/99Fvhj/t+qIUOGMH78+E5OtpnZwk3Ss/XGdVn1UUTcTnq3uGw46UtE8v+dSsPPjeQeoL/cvruZWbfr7mcKy+evJSG1QbN87h7M3G26TKWdbcyYmdm8a9qD5ty4V7tffZK0v9Ivh41vaWnpgpSZmfVc3R0UXqlUC+X/0/LwF5i7oa+VqNPwWEScERHDImLYoEE1n5OYmVkHdXdQuIY5v/A0ktQ2TmX4CCWbAm+UqpnMzKybdOUrqReSfphloKSpwFGkhr0uUfr5wmdJvzYF8A/S66hPkl5J3fcjCzQzsy7XZUEhIvasM2rrGtMG8L2uSouZmTXGXzSbmVnBQcHMzApd+UWzzcektqdZELg9R7PO5aBgPY4WlogIuJVj62w9Nijo6IXoxnCUbwxm1jn8TMHMzAoOCmZmVnBQMDOzgoOCmZkVHBTMzKzgoGBmZgUHBTMzK/TY7xTMrOc5Wkc3Owmd5qg4qkuW65KCmZkVHBTMzKzgoGBmZgUHBTMzKzgomJlZwUHBzMwKDgpmZlZwUDAzs4I/XjPraRaWX57zr851CZcUzMys4KBgZmYFBwUzMys4KJiZWcFBwczMCg4KZmZWcFAwM7OCg4KZmRUcFMzMrOCgYGZmBQcFMzMrOCiYmVmhKUFB0o8lPSRpiqQLJfWRtJqkcZKelHSxpMWakTYzs56s24OCpMHAD4BhEbE+0AvYAzgeODki1gCmA/t1d9rMzHq6ZlUf9Qb6SuoN9ANeArYCLsvjxwA7NSdpZmY9V7cHhYh4ATgReI4UDN4AJgCvR8SHebKpwOBa80vaX9J4SeNbWlq6I8lmZj1GM6qPlgWGA6sBKwJLANs2On9EnBERwyJi2KBBg7oolWZmPVMzqo+2Af4TES0R8QFwBbA50D9XJwGsBLzQhLSZmfVozQgKzwGbSuonScDWwMPArcCueZqRwNVNSJuZWY/WjGcK40gPlO8HJuc0nAEcDhws6UlgOeDM7k6bmVlP17vtSTpfRBwFHFU1+GlgkyYkx8zMMn/RbGZmBQcFMzMrOCiYmVnBQcHMzAoOCmZmVnBQMDOzgoOCmZkVHBTMzKzgoGBmZgUHBTMzKzgomJlZwUHBzMwKDgpmZlZwUDAzs4KDgpmZFRwUzMys4KBgZmYFBwUzMys4KJiZWcFBwczMCg4KZmZWcFAwM7OCg4KZmRUcFMzMrOCgYGZmBQcFMzMrOCiYmVnBQcHMzAoOCmZmVnBQMDOzgoOCmZkVHBTMzKzgoGBmZgUHBTMzKzQlKEjqL+kySY9KekTSZpIGSLpJ0hP5/7LNSJuZWU/WrJLCqcD1EbEOsCHwCHAEMDYi1gTG5n4zM+tG3R4UJC0DfBE4EyAi3o+I14HhwJg82Rhgp+5Om5lZT9dmUJD0NUmdGTxWA1qAsyU9IOmvkpYAlo+Il/I0LwPL10nP/pLGSxrf0tLSickyM7NGbvbfAJ6QdIKkdTphnb2BjYA/RsSngbepqiqKiACi1swRcUZEDIuIYYMGDeqE5JiZWUWbQSEi9gY+DTwFnCPp7pxbX6qD65wKTI2Icbn/MlKQeEXSCgD5/7QOLt/MzDqooWqhiHiTdPO+CFgB+Dpwv6SD2rvCiHgZeF7S2nnQ1sDDwDXAyDxsJHB1e5dtZmbzpndbE0jaEdgXWAM4F9gkIqZJ6ke6mZ/WgfUeBJwvaTHg6bz8RYBLJO0HPAvs3oHlmpnZPGgzKAC7ACdHxO3lgRHxTr6Bt1tETASG1Ri1dUeWZ2ZmnaORoDAaqLwVhKS+pDeFnomIsV2VMDMz636NPFO4FJhd6p+Vh5mZ2UKmkaDQOyLer/Tk7sW6LklmZtYsjQSFlvywGQBJw4FXuy5JZmbWLI08UziQ9KbQ7wEBzwMjujRVZmbWFG0GhYh4CthU0pK5f0aXp8rMzJqikZICkr4KrAf0kQRARPyyC9NlZmZN0EiDeH8itX90EKn6aDdg1S5Ol5mZNUEjD5o/FxEjgOkRcTSwGbBW1ybLzMyaoZGg8G7+/46kFYEPSO0fmZnZQqaRZwrXSuoP/Aa4n9Sk9V+6MlFmZtYcrQaF/OM6Y/Mvo10u6e9An4h4ozsSZ2Zm3avV6qOImA38odT/ngOCmdnCq5FnCmMl7aLKu6hmZrbQaiQoHEBqAO89SW9KekvSm12cLjMza4JGvmju6M9umpnZAqaRX177Yq3h1T+6Y2ZmC75GXkk9tNTdB9gEmABs1SUpMjOzpmmk+uhr5X5JKwOndFWCzMyseRp50FxtKvDJzk6ImZk1XyPPFE4jfcUMKYgMJX3ZbGZmC5lGnimML3V/CFwYEXd2UXrMzKyJGgkKlwHvRsQsAEm9JPWLiHe6NmlmZtbdGvqiGehb6u8L3Nw1yTEzs2ZqJCj0Kf8EZ+7u13VJMjOzZmkkKLwtaaNKj6SNgZldlyQzM2uWRp4p/Ai4VNKLpJ/j/Djp5znNzGwh08jHa/dJWgdYOw96LCI+6NpkmZlZM7RZfSTpe8ASETElIqYAS0r6btcnzczMulsjzxS+k395DYCImA58p8tSZGZmTdNIUOhV/oEdSb2AxbouSWZm1iyNPGi+HrhY0p9z/wHAP7suSWZm1iyNBIXDgf2BA3P/JNIbSGZmtpBps/ooImYD44BnSL+lsBXwSNcmy8zMmqFuSUHSWsCe+e9V4GKAiPifzlhxfjYxHnghInaQtBpwEbAc6Ud89omI9ztjXWZm1pjWSgqPkkoFO0TE5yPiNGBWJ677h8xd4jgeODki1gCmA/t14rrMzKwBrQWFnYGXgFsl/UXS1qQvmueZpJWArwJ/zf0iBaDL8iRjgJ06Y11mZta4ukEhIq6KiD2AdYBbSc1dfEzSHyV9eR7XewpwGDA79y8HvB4RH+b+qcDgWjNK2l/SeEnjW1pa5jEZZmZW1siD5rcj4oL8W80rAQ+Q3kjqEEk7ANMiYkJH5o+IMyJiWEQMGzRoUEeTYWZmNTTySmohf818Rv7rqM2BHSVtD/QBlgZOBfpL6p1LCysBL8zDOszMrAMa+aK5U0XETyNipYgYAuwB3BIRe5GqqHbNk40Eru7utJmZ9XTdHhRacThwsKQnSc8YzmxyeszMepx2VR91toi4Dbgtdz9N+jjOzMyaZH4qKZiZWZM5KJiZWcFBwczMCg4KZmZWcFAwM7OCg4KZmRUcFMzMrOCgYGZmBQcFMzMrOCiYmVnBQcHMzAoOCmZmVnBQMDOzgoOCmZkVHBTMzKzgoGBmZgUHBTMzKzgomJlZwUHBzMwKDgpmZlZwUDAzs4KDgpmZFRwUzMys4KBgZmYFBwUzMys4KJiZWcFBwczMCg4KZmZWcFAwM7OCg4KZmRUcFMzMrOCgYGZmBQcFMzMrOCiYmVmh24OCpJUl3SrpYUkPSfphHj5A0k2Snsj/l+3utJmZ9XTNKCl8CPwkItYFNgW+J2ld4AhgbESsCYzN/WZm1o26PShExEsRcX/ufgt4BBgMDAfG5MnGADt1d9rMzHq6pj5TkDQE+DQwDlg+Il7Ko14Glq8zz/6Sxksa39LS0j0JNTPrIZoWFCQtCVwO/Cgi3iyPi4gAotZ8EXFGRAyLiGGDBg3qhpSamfUcTQkKkhYlBYTzI+KKPPgVSSvk8SsA05qRNjOznqwZbx8JOBN4JCJ+Wxp1DTAyd48Eru7utJmZ9XS9m7DOzYF9gMmSJuZhPwOOAy6RtB/wLLB7E9JmZtajdXtQiIg7ANUZvXV3psXMzObmL5rNzKzgoGBmZgUHBTMzKzgomJlZwUHBzMwKDgpmZlZwUDAzs4KDgpmZFRwUzMys4KBgZmYFBwUzMys4KJiZWcFBwczMCg4KZmZWcFAwM7OCg4KZmRUcFMzMrOCgYGZmBQcFMzMrOCiYmVnBQcHMzAoOCmZmVnBQMDOzgoOCmZkVHBTMzKzgoGBmZgUHBTMzKzgomJlZwUHBzMwKDgpmZlZwUDAzs4KDgpmZFRwUzMys4KBgZmaF+SooSNpW0mOSnpR0RLPTY2bW08w3QUFSL+APwHbAusCektZtbqrMzHqW+SYoAJsAT0bE0xHxPnARMLzJaTIz61F6NzsBJYOB50v9U4HPVk8kaX9g/9w7Q9Jj3ZC2eTEQeLUrV6DR6srFz4uu3/b5dtO7ftsBNP/ugK7f/p687cBojZ6X2VetN2J+CgoNiYgzgDOanY5GSRofEcOanY5m8Lb3zG2Hnr39C/q2z0/VRy8AK5f6V8rDzMysm8xPQeE+YE1Jq0laDNgDuKbJaTIz61Hmm+qjiPhQ0veBG4BewFkR8VCTk9UZFpiqri7gbe+5evL2L9DbrohodhrMzGw+MT9VH5mZWZM5KJiZWWGBCAqSZnTCMoZJ+l0r44dI+maj09eY/7bcRMeDku6TNHQek9xpJO1Ybjak1v6UdKCkEd2crh0kPZD32cOSDpC0haS7q6brLekVSSvm/kMkPSppYt7XI+qdI5LWydM9IOkTVeO+JWmypEmSpkgaLmmkpAurphsoqUXS4vk4P6fSBwKSrmrPOSpptKRDGp2+geXdVer+jaSH8v/Zkp7N/Q9K+omkDl3zkn4paZtWxnfo/JH0lXx8Jkqaka+hiZLObccyZuV5pki6VlL/9qajznJHSfp9Zyyrarm3lbZzoqRdO3sdeT1z3dMaFhHz/R8woxvWsSXw93mY/zZgWO7eF7ipk9LVa0HcnzXWKWCRUv+iwIvASrl/cWBtUkbleWDV0rTbArfk7gNJLyMsnfuXBkbV2ybgCODIGsNXAp4Clsn9SwKr5eW9CvQrTXsg6cWHynGeBHw+9/cHxrVnnwKjgUO6aD+/UTlnymkCPgbcDBzd3ce+HWkvrqGq4a1eA1XbOQb4v05Kzyjg9921nQ3M17ud03fonrZAlBRqkTRU0j05l3elpGXz8M/kYRNzbmlKHr6lpL/n7i1KUfoBSUsBxwFfyMN+XDX9kpLOLuUqd2kjeXeTvtBG0hKSzpJ0b17X8Dy8n6RLcg75SknjJA3L42ZIOknSg8BmkvbO80+U9GdJvfLfOTl3NFnSj/O8P8jLnCTpojysyPFIGgL0yePHSlolD58o6d+S7pI0M+d+75X0uKQv5Gl65X16X57/gNL+GSvp/pyWyjYOyTmic4EpzP0dylKkt99eA4iI9yLisYiYDVxCeiW5Yg+gknv/GXAMcF9e7t3ArXl9J+dc8VhJgyRtD/wI+F9Jt1Ydo48BbwEz8vpnRMR/IuJN4F/A1+qsH1ITLJX07QxcUeskyGkakffVg5L+VmP8d/L+fFDS5ZL65eG75WP7oKTb87D1SufBJElr5uEz8v9rSMFtgqRvAItpTolkKVIg/r98nNetdSzzcg7Px/FBScflYeco52glHVc6x07Mw4rSj+pfm7dJOr76vKqz357J094P7Cbpy5LuzufYpZKWzNNtDPSVNEHSDcBDzLn2NsnzPJDP67Xz8FGSrpB0vaQnJJ1QWu++OW33ApuXhg+RdEuN6+YcSX/M2/u00n3jLEmPSDqn3vbV2N4B+ZqblJf1qdJ+/ZukO4G/5fP68nzc7pO0eZ6uzXtao2lpeu6gwYj3kVwYKbe2Re7+JXBK7p4CbJa7jwOmVEdN4Fpg89y9JOnmVIyvMf3xleXn/mVbi/6kG9GxuftYYO/c3R94HFgCOAT4cx6+PvBhaf4Ads/dn8zpXTT3nw6MADamVBoB+uf/LwKLVw0bRc7x5GW9m7u/BVyVuycCD5Jy6vcC0/Pw7YGbc/f+5Fw3KWc/npS77s2cnPtA4ElSyWAIMBvYtM5x/SswjXTD3YtckgCGAQ+U1jMNGEDKxU+vtdy8z/bK3b8obe9oauTKSa893wA8B5wNfK00blfgyty9Yt6nldz3baTmVyblZdyY01PrHF0vH++BuX9AdZqA5UrTHwMclLsnA4OrjuNppW1cDOhbfX1Udb9fWs9YYE3gdVKjk4/WOZbbAXeRS0qlNJ+T98tywGPMeXOxf41tqndt3gacVH1e1bmGngEOK51TtwNL5P7D8zFeNKd1Rh6+B/AfYNvcvzQ5dw1sA1xeuh6eBpYB+gDPkjIsK5DOh0F5/97J3NfNyBrXzTmkTIJIbbW9CWxAuo4mAEPr3CseI11zE/M+PQ04Ko/fCphY2q8TSsf6AuaUUlcBHmn0ntbo33zznUJ7SFqGdDL+Kw8aA1yqVJe4VERU6qQvAHaosYg7gd9KOh+4IiKmqvV2VLahlHONiOl1pjtf6cO7JYGhediXgR1LObY+pIP5eeDUvLwpkiaVljMLuDx3b00KAPflNPYl3SSvBVaXdBpwHenmBOmCPF/SVcBVNdK4GSkAAfwNOKE0bkpEzJb0DumigHRCDilty6c0pw50GdKNZipwrKQvkm7Wg4Hl8zTPRsQ9NdJBRHxb0gak/XsI8CVgVESMVyp9rE0KiuMi4r+Sli7NXr3c2cDFufs8Wsm953XPkrQt8BnSPj5Z0sYRMZq0P0/P69uddDOZVZp9FnAH6ZzoGxHP1Dl/tgIujYhX8zr/W2Oa9SUdQ8owLEkKVJDO0XMkXVLalrtJOf2VSOftE61tY0XOVX8OuJRUYvgNKdiNqHEstwHOjoh36qT5DeBd4EylkvTfq9ZV89osTVLZlvJ5VU/leG5Kajn5zryfFyPti7VJGaolJM0kBYm3gJtK2zQml6gij68YGxFv5DQ/TGoLaCBwW0S05OEXA2vl6TcjlQrho9fNtRERkiYDr0TE5Dz/Q3kbJ9bYtr0iYnylR9LngV0AIuIWScuVzvdrImJm7t4GWLd0vi2dj29772l1LbDVR/MiIo4Dvk26wd4paZ1OWvRewOqkC+G0PEzALhExNP+tEhGPtLGcd0s3IQFjSvOvHRGjc2DakJTrOJCU6wb4KqkJ8o1IgaQ9gf/DUnfljJrFnI8cRcrJVtKyWkTcmLd7ELBxRAwFXiEFP4C3W1thREyOiJNJAaFcLXch6aZbVN1EqtqZQcrVtbpc0k2g9QmSeyPi13k9lYtyJnA98HU+WnVUcRHwO1JV17w4B/h+RGwAHE3ebxFxIHAkaVsnSFouIi4AdgRmAv+QtFWD61iEVELYOf/fgHTjrHUsWxURH5JaNL6MlOG6vsE0VLyX/5fPq3oqx1ikUnElretGxH55+EPA2xHRl1QymAJ8L8/3/4BbI2J9UnVgn9Ky3yt1N5KW1lSWNbtqubPncbkV5XN9EVIJubIvBkeq+uy0e9oCGRRyhJ9eqpPcB/hXRLwOvCWp0rrqHrXml/SJfDM6ntS8xjqkHMZSdVZ5E3NONCp1pHXSFsDPgU3zgbkBOEg5bEv6dJ70TlIuFKXfjdigziLHArtK+liedoCkVSUNJFW3XE66eWyk9GbJyhFxK6mIvQwp91l2F3NO1L2Af9fblhpuINXPL5rTspakJfJ6pkXEB5L+h1ZaYKzIJYEtS4OGkorxFRcCe5Ny21eXhv+adLEvUlrOiNxfyfV+k5STb239K0raqI31H0wq8cz1NlT275yWWgGj4hZSffhyeZ0DakyzFPBS3qd7ldL3iYgYFxG/AFqAlSWtDjwdEb8j7ZNPtbaNFTmYPg9cCVTepnmI2sfyJmBfzXm2MVeac650mYj4B/BjUsakvK6a12Yj6WzFPcDmktbIaVhC0lqkKphBzLmPfQCcAvwkZ4aWYU77aaMaWM84YIucS18U2K007i7m3E/ae9004t95ueTr4tV83KrdCBxU6VF+y7ED97S6FpTqo36Sppb6fwuMBP6UT96nSW/8AOwH/EXSbNLJ+EaN5f0o37xmky6Of+buWUoPd88BHihNfwzwB6WH1rNIObq61RMRMVPSScChwPdJJ+qkfNP+DymHdTqpaPswqX73oVppjYiHJR0J3Jjn/4AUoGYCZ2vOK4Y/JdVxn5eL8AJ+FxGvVxUjDwKekfR+3ubpkg6uty1V/koqDt+fg1wLsBNwPnBtLj6Pz9vTFgGHSfpz3pa3KV24EfGIpLeBCRFRzin9kZR7Pjgfjw+Ak/L8m+R9NQ34RhvrXxQ4Uek113fzthxYGn8TcC5wZg70c8nDTmxtBRHxkKRfAf+SNIt0To2qmuznpJtRS/5fuYh/k6s9RMoYPEgK9PtI+gB4mfS8qjW9gR9L2pd04xTpeO1Gqpp5mKpjGRHX5xvN+HyO/IP0cL9iKeBqSX3y8mqdO/WuzQ6JiBZJo4ALJS2eBx8ZEY/n6q8J+brtTb7WgD1JVTxj8jlxXQPreUnSaFIm4HXmrvY5iHS9HUraV/O0TTWMBs5SqkZ+h7QPa/kB6V40ibS9t5PO2zbvablE3qaFrpkLSUtGROVtjCOAFSLih01O1kco/dLcohHxrtL78zcDa0f6gSEzs6ZYUEoK7fFVST8lbduzNFZsbIZ+wK25mCrguw4IZtZsC11JwczMOm6BfNBsZmZdw0HBzMwKDgpmZlZwUDCrQVJIOq/U31uppdS/tzZfjeU8k78pmadpzLqLg4JZbW+TmqDom/u/xJwPocwWWg4KZvX9g9RsCKSPoYqvl1W/VcvlJN2o1FrrX5nTXAiq0dpteWX5S93rlFonnaLU0qlZt3JQMKvvImCP/PXup0hfHFccTWrJ9VOkL34rPwpzFHBHRKxHalai0sTyJ0lfWW+e24eaRalZi2xb4MWI2DC319PedoXM5tnC+PGaWaeIiElKvz+xJ6nUUFavVcsvklvTjIjrJFVa1K3X2m3ZZOAkSceTmjzu7PZ1zNrkoGDWumtIbRxtSWr3vqMqrd3+tN4EuS2fjUi/NXCMpLER8ct5WKdZu7n6yKx1Z5F+wnJy1fB6rVreTmqlFUnbAZUWdWu2dlteYG6c752IOI/0mwflVlzNuoVLCmatiIippN9NqDaa2q1aHk1qzfMhUnPLz+Xl1Gvtttxc9wak1lFn5/H/2/lbZNY6t31kZmYFVx+ZmVnBQcHMzAoOCmZmVnBQMDOzgoOCmZkVHBTMzKzgoGBmZoX/D7ON513go8wVAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "\n",
+        "\n",
+        "*  From the result, we can choose  ___Linear SVC___ or ___rbf SVM___ as our ML Model.\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "qPvqZk9cFadn"
+      }
+    }
+  ]
+}
\ No newline at end of file