memorydump_classification.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sahinebrar/MachineLearningExercises/blob/main/memorydump_classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "4F9cjan6qzhz"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import seaborn as sn\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.metrics import confusion_matrix,accuracy_score\n",
        "from sklearn.model_selection import RandomizedSearchCV, GridSearchCV\n",
        "from imblearn.over_sampling import SMOTE\n",
        "\n",
        "from random import randint\n",
        "from sklearn.ensemble import RandomForestClassifier"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MN_pOFLs1KPe",
        "outputId": "e3dc3bc0-c130-453a-f59d-06fddfa0bb49"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "id": "b337QeD5z8ns",
        "outputId": "9503bdba-d7fb-47a6-c2af-3c6f28d0c9c6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'for index in range(0, len(df)):\\n  if df.loc[index, \"Category\"] == \"Benign\": \\n    continue\\n  temp = df.loc[index, \"Category\"].split(\"-\")\\n  df.loc[index, \"Category\"] =  \" \".join([temp[0], \"-\", temp[1]])\\n\\n# writing into the file\\ndf.to_csv(\"MalMem.csv\", index=False)'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "df = pd.read_csv(\"/content/drive/MyDrive/Doktora/MakinaOgrenmesi/MalMem.csv\")\n",
        "\n",
        "'''for index in range(0, len(df)):\n",
        "  if df.loc[index, \"Category\"] == \"Benign\": \n",
        "    continue\n",
        "  temp = df.loc[index, \"Category\"].split(\"-\")\n",
        "  df.loc[index, \"Category\"] =  \" \".join([temp[0], \"-\", temp[1]])\n",
        "\n",
        "# writing into the file\n",
        "df.to_csv(\"MalMem.csv\", index=False)'''"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PfY4HEaxITqy",
        "outputId": "1a50f59a-e0cf-4241-f308-5f6125356720"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 58596 entries, 0 to 58595\n",
            "Data columns (total 57 columns):\n",
            " #   Column                                  Non-Null Count  Dtype  \n",
            "---  ------                                  --------------  -----  \n",
            " 0   Category                                58596 non-null  object \n",
            " 1   pslist.nproc                            58596 non-null  int64  \n",
            " 2   pslist.nppid                            58596 non-null  int64  \n",
            " 3   pslist.avg_threads                      58596 non-null  float64\n",
            " 4   pslist.nprocs64bit                      58596 non-null  int64  \n",
            " 5   pslist.avg_handlers                     58596 non-null  float64\n",
            " 6   dlllist.ndlls                           58596 non-null  int64  \n",
            " 7   dlllist.avg_dlls_per_proc               58596 non-null  float64\n",
            " 8   handles.nhandles                        58596 non-null  int64  \n",
            " 9   handles.avg_handles_per_proc            58596 non-null  float64\n",
            " 10  handles.nport                           58596 non-null  int64  \n",
            " 11  handles.nfile                           58596 non-null  int64  \n",
            " 12  handles.nevent                          58596 non-null  int64  \n",
            " 13  handles.ndesktop                        58596 non-null  int64  \n",
            " 14  handles.nkey                            58596 non-null  int64  \n",
            " 15  handles.nthread                         58596 non-null  int64  \n",
            " 16  handles.ndirectory                      58596 non-null  int64  \n",
            " 17  handles.nsemaphore                      58596 non-null  int64  \n",
            " 18  handles.ntimer                          58596 non-null  int64  \n",
            " 19  handles.nsection                        58596 non-null  int64  \n",
            " 20  handles.nmutant                         58596 non-null  int64  \n",
            " 21  ldrmodules.not_in_load                  58596 non-null  int64  \n",
            " 22  ldrmodules.not_in_init                  58596 non-null  int64  \n",
            " 23  ldrmodules.not_in_mem                   58596 non-null  int64  \n",
            " 24  ldrmodules.not_in_load_avg              58596 non-null  float64\n",
            " 25  ldrmodules.not_in_init_avg              58596 non-null  float64\n",
            " 26  ldrmodules.not_in_mem_avg               58596 non-null  float64\n",
            " 27  malfind.ninjections                     58596 non-null  int64  \n",
            " 28  malfind.commitCharge                    58596 non-null  int64  \n",
            " 29  malfind.protection                      58596 non-null  int64  \n",
            " 30  malfind.uniqueInjections                58596 non-null  float64\n",
            " 31  psxview.not_in_pslist                   58596 non-null  int64  \n",
            " 32  psxview.not_in_eprocess_pool            58596 non-null  int64  \n",
            " 33  psxview.not_in_ethread_pool             58596 non-null  int64  \n",
            " 34  psxview.not_in_pspcid_list              58596 non-null  int64  \n",
            " 35  psxview.not_in_csrss_handles            58596 non-null  int64  \n",
            " 36  psxview.not_in_session                  58596 non-null  int64  \n",
            " 37  psxview.not_in_deskthrd                 58596 non-null  int64  \n",
            " 38  psxview.not_in_pslist_false_avg         58596 non-null  float64\n",
            " 39  psxview.not_in_eprocess_pool_false_avg  58596 non-null  float64\n",
            " 40  psxview.not_in_ethread_pool_false_avg   58596 non-null  float64\n",
            " 41  psxview.not_in_pspcid_list_false_avg    58596 non-null  float64\n",
            " 42  psxview.not_in_csrss_handles_false_avg  58596 non-null  float64\n",
            " 43  psxview.not_in_session_false_avg        58596 non-null  float64\n",
            " 44  psxview.not_in_deskthrd_false_avg       58596 non-null  float64\n",
            " 45  modules.nmodules                        58596 non-null  int64  \n",
            " 46  svcscan.nservices                       58596 non-null  int64  \n",
            " 47  svcscan.kernel_drivers                  58596 non-null  int64  \n",
            " 48  svcscan.fs_drivers                      58596 non-null  int64  \n",
            " 49  svcscan.process_services                58596 non-null  int64  \n",
            " 50  svcscan.shared_process_services         58596 non-null  int64  \n",
            " 51  svcscan.interactive_process_services    58596 non-null  int64  \n",
            " 52  svcscan.nactive                         58596 non-null  int64  \n",
            " 53  callbacks.ncallbacks                    58596 non-null  int64  \n",
            " 54  callbacks.nanonymous                    58596 non-null  int64  \n",
            " 55  callbacks.ngeneric                      58596 non-null  int64  \n",
            " 56  Class                                   58596 non-null  object \n",
            "dtypes: float64(15), int64(40), object(2)\n",
            "memory usage: 25.5+ MB\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "print(df.info())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9taNFFDeIcY3",
        "outputId": "8489dccc-820d-473d-96c1-51f50d4cc00f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "       pslist.nproc  pslist.nppid  pslist.avg_threads  pslist.nprocs64bit  \\\n",
            "count  58596.000000  58596.000000        58596.000000             58596.0   \n",
            "mean      41.394771     14.713837           11.341655                 0.0   \n",
            "std        5.777249      2.656748            1.588231                 0.0   \n",
            "min       21.000000      8.000000            1.650000                 0.0   \n",
            "25%       40.000000     12.000000            9.972973                 0.0   \n",
            "50%       41.000000     15.000000           11.000000                 0.0   \n",
            "75%       43.000000     16.000000           12.861955                 0.0   \n",
            "max      240.000000     72.000000           16.818182                 0.0   \n",
            "\n",
            "       pslist.avg_handlers  dlllist.ndlls  dlllist.avg_dlls_per_proc  \\\n",
            "count         58596.000000   58596.000000               58596.000000   \n",
            "mean            247.509819    1810.805447                  43.707806   \n",
            "std             111.857790     329.782639                   5.742023   \n",
            "min              34.962500     670.000000                   7.333333   \n",
            "25%             208.725000    1556.000000                  38.833333   \n",
            "50%             243.963710    1735.000000                  42.781524   \n",
            "75%             289.974322    2087.000000                  49.605280   \n",
            "max           24845.951220    3443.000000                  53.170732   \n",
            "\n",
            "       handles.nhandles  handles.avg_handles_per_proc  handles.nport  ...  \\\n",
            "count      5.859600e+04                  58596.000000        58596.0  ...   \n",
            "mean       1.025858e+04                    249.560958            0.0  ...   \n",
            "std        4.866864e+03                    145.999866            0.0  ...   \n",
            "min        3.514000e+03                     71.139241            0.0  ...   \n",
            "25%        8.393000e+03                    209.648228            0.0  ...   \n",
            "50%        9.287500e+03                    247.208951            0.0  ...   \n",
            "75%        1.219300e+04                    291.355050            0.0  ...   \n",
            "max        1.047310e+06                  33784.193550            0.0  ...   \n",
            "\n",
            "       svcscan.nservices  svcscan.kernel_drivers  svcscan.fs_drivers  \\\n",
            "count       58596.000000            58596.000000        58596.000000   \n",
            "mean          391.347549              221.406581           25.996245   \n",
            "std             4.529704                1.991087            0.170790   \n",
            "min            94.000000               55.000000            6.000000   \n",
            "25%           389.000000              221.000000           26.000000   \n",
            "50%           389.000000              221.000000           26.000000   \n",
            "75%           395.000000              222.000000           26.000000   \n",
            "max           395.000000              222.000000           26.000000   \n",
            "\n",
            "       svcscan.process_services  svcscan.shared_process_services  \\\n",
            "count              58596.000000                     58596.000000   \n",
            "mean                  25.063417                       116.879514   \n",
            "std                    1.529628                         1.550401   \n",
            "min                    7.000000                        26.000000   \n",
            "25%                   24.000000                       116.000000   \n",
            "50%                   24.000000                       116.000000   \n",
            "75%                   27.000000                       118.000000   \n",
            "max                   27.000000                       118.000000   \n",
            "\n",
            "       svcscan.interactive_process_services  svcscan.nactive  \\\n",
            "count                               58596.0     58596.000000   \n",
            "mean                                    0.0       121.995546   \n",
            "std                                     0.0         2.822858   \n",
            "min                                     0.0        30.000000   \n",
            "25%                                     0.0       121.000000   \n",
            "50%                                     0.0       122.000000   \n",
            "75%                                     0.0       123.000000   \n",
            "max                                     0.0       129.000000   \n",
            "\n",
            "       callbacks.ncallbacks  callbacks.nanonymous  callbacks.ngeneric  \n",
            "count          58596.000000          58596.000000        58596.000000  \n",
            "mean              86.905659              0.000853            7.999881  \n",
            "std                3.134117              0.029199            0.010929  \n",
            "min               50.000000              0.000000            7.000000  \n",
            "25%               87.000000              0.000000            8.000000  \n",
            "50%               87.000000              0.000000            8.000000  \n",
            "75%               88.000000              0.000000            8.000000  \n",
            "max               89.000000              1.000000            8.000000  \n",
            "\n",
            "[8 rows x 55 columns]\n"
          ]
        }
      ],
      "source": [
        "print(df.describe())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QQgzheWHIeIy",
        "outputId": "050512e4-a805-4c24-e6ff-1392e6c1176c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Category                                  0\n",
            "pslist.nproc                              0\n",
            "pslist.nppid                              0\n",
            "pslist.avg_threads                        0\n",
            "pslist.nprocs64bit                        0\n",
            "pslist.avg_handlers                       0\n",
            "dlllist.ndlls                             0\n",
            "dlllist.avg_dlls_per_proc                 0\n",
            "handles.nhandles                          0\n",
            "handles.avg_handles_per_proc              0\n",
            "handles.nport                             0\n",
            "handles.nfile                             0\n",
            "handles.nevent                            0\n",
            "handles.ndesktop                          0\n",
            "handles.nkey                              0\n",
            "handles.nthread                           0\n",
            "handles.ndirectory                        0\n",
            "handles.nsemaphore                        0\n",
            "handles.ntimer                            0\n",
            "handles.nsection                          0\n",
            "handles.nmutant                           0\n",
            "ldrmodules.not_in_load                    0\n",
            "ldrmodules.not_in_init                    0\n",
            "ldrmodules.not_in_mem                     0\n",
            "ldrmodules.not_in_load_avg                0\n",
            "ldrmodules.not_in_init_avg                0\n",
            "ldrmodules.not_in_mem_avg                 0\n",
            "malfind.ninjections                       0\n",
            "malfind.commitCharge                      0\n",
            "malfind.protection                        0\n",
            "malfind.uniqueInjections                  0\n",
            "psxview.not_in_pslist                     0\n",
            "psxview.not_in_eprocess_pool              0\n",
            "psxview.not_in_ethread_pool               0\n",
            "psxview.not_in_pspcid_list                0\n",
            "psxview.not_in_csrss_handles              0\n",
            "psxview.not_in_session                    0\n",
            "psxview.not_in_deskthrd                   0\n",
            "psxview.not_in_pslist_false_avg           0\n",
            "psxview.not_in_eprocess_pool_false_avg    0\n",
            "psxview.not_in_ethread_pool_false_avg     0\n",
            "psxview.not_in_pspcid_list_false_avg      0\n",
            "psxview.not_in_csrss_handles_false_avg    0\n",
            "psxview.not_in_session_false_avg          0\n",
            "psxview.not_in_deskthrd_false_avg         0\n",
            "modules.nmodules                          0\n",
            "svcscan.nservices                         0\n",
            "svcscan.kernel_drivers                    0\n",
            "svcscan.fs_drivers                        0\n",
            "svcscan.process_services                  0\n",
            "svcscan.shared_process_services           0\n",
            "svcscan.interactive_process_services      0\n",
            "svcscan.nactive                           0\n",
            "callbacks.ncallbacks                      0\n",
            "callbacks.nanonymous                      0\n",
            "callbacks.ngeneric                        0\n",
            "Class                                     0\n",
            "dtype: int64\n"
          ]
        }
      ],
      "source": [
        "print(df.isna().sum()) # no missing data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "id": "YK0q0U6NJBhF",
        "outputId": "91509624-a6bc-4321-891a-bc02f1662f68"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "lab=LabelEncoder()\n",
        "df['category']=lab.fit_transform(df['Category'])\n",
        "df['class']=lab.fit_transform(df['Class'])\n",
        "sn.countplot(x = 'Class', data= df)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9sWzUCjQN6Y1",
        "outputId": "cbd0f70b-e2c7-4d01-a720-261956d42ca2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{0: 'Benign',\n",
              " 1: 'Ransomware - Ako',\n",
              " 2: 'Ransomware - Conti',\n",
              " 3: 'Ransomware - Maze',\n",
              " 4: 'Ransomware - Pysa',\n",
              " 5: 'Ransomware - Shade',\n",
              " 6: 'Spyware - 180solutions',\n",
              " 7: 'Spyware - CWS',\n",
              " 8: 'Spyware - Gator',\n",
              " 9: 'Spyware - TIBS',\n",
              " 10: 'Spyware - Transponder',\n",
              " 11: 'Trojan - Emotet',\n",
              " 12: 'Trojan - Reconyc',\n",
              " 13: 'Trojan - Refroso',\n",
              " 14: 'Trojan - Scar',\n",
              " 15: 'Trojan - Zeus'}"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "label_mapping = dict(zip(df['category'], df['Category']))\n",
        "label_mapping"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "id": "bX16jeYHPALX",
        "outputId": "12af144f-152b-4822-bbb7-64ac78744662"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "sn.countplot(x = 'category', data= df)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UCAx1RnMPXRN",
        "outputId": "5e164dcf-96c4-48e3-8bc8-15dc5792571d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(14649, 1)\n"
          ]
        }
      ],
      "source": [
        "# split traing & test \n",
        "x = df[['pslist.nproc', 'pslist.nppid', 'pslist.avg_threads',\n",
        "       'pslist.nprocs64bit', 'pslist.avg_handlers', 'dlllist.ndlls',\n",
        "       'dlllist.avg_dlls_per_proc', 'handles.nhandles',\n",
        "       'handles.avg_handles_per_proc', 'handles.nport', 'handles.nfile',\n",
        "       'handles.nevent', 'handles.ndesktop', 'handles.nkey', 'handles.nthread',\n",
        "       'handles.ndirectory', 'handles.nsemaphore', 'handles.ntimer',\n",
        "       'handles.nsection', 'handles.nmutant', 'ldrmodules.not_in_load',\n",
        "       'ldrmodules.not_in_init', 'ldrmodules.not_in_mem',\n",
        "       'ldrmodules.not_in_load_avg', 'ldrmodules.not_in_init_avg',\n",
        "       'ldrmodules.not_in_mem_avg', 'malfind.ninjections',\n",
        "       'malfind.commitCharge', 'malfind.protection',\n",
        "       'malfind.uniqueInjections', 'psxview.not_in_pslist',\n",
        "       'psxview.not_in_eprocess_pool', 'psxview.not_in_ethread_pool',\n",
        "       'psxview.not_in_pspcid_list', 'psxview.not_in_csrss_handles',\n",
        "       'psxview.not_in_session', 'psxview.not_in_deskthrd',\n",
        "       'psxview.not_in_pslist_false_avg',\n",
        "       'psxview.not_in_eprocess_pool_false_avg',\n",
        "       'psxview.not_in_ethread_pool_false_avg',\n",
        "       'psxview.not_in_pspcid_list_false_avg',\n",
        "       'psxview.not_in_csrss_handles_false_avg',\n",
        "       'psxview.not_in_session_false_avg', 'psxview.not_in_deskthrd_false_avg',\n",
        "       'modules.nmodules', 'svcscan.nservices', 'svcscan.kernel_drivers',\n",
        "       'svcscan.fs_drivers', 'svcscan.process_services',\n",
        "       'svcscan.shared_process_services',\n",
        "       'svcscan.interactive_process_services', 'svcscan.nactive',\n",
        "       'callbacks.ncallbacks', 'callbacks.nanonymous', 'callbacks.ngeneric']]\n",
        "y = df[['category']]\n",
        "x_train,x_test,y_train,y_test=train_test_split(x,y)\n",
        "#smote = SMOTE(random_state=42)\n",
        "#x_train, y_train = smote.fit_resample(x_train, y_train)\n",
        "print(y_test.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "c1uS3eOAIGK3"
      },
      "outputs": [],
      "source": [
        "standardscaler = StandardScaler()\n",
        "x_train_standardscaler = standardscaler.fit_transform(x_train)\n",
        "x_test_standardscaler = standardscaler.transform(x_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "cq07YQgSQvfo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50982ffb-3bf9-4a5c-d584-e20d2c37bdec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/ensemble/_forest.py:424: FutureWarning: `max_features='auto'` has been deprecated in 1.1 and will be removed in 1.3. To keep the past behaviour, explicitly set `max_features='sqrt'` or remove this parameter as it is also the default value for RandomForestClassifiers and ExtraTreesClassifiers.\n",
            "  warn(\n"
          ]
        }
      ],
      "source": [
        "# Random Forest Classifier (Library)\n",
        "\n",
        "#rf=RandomForestClassifier(n_estimators=278, oob_score = True, max_features=30)#\n",
        "rf=RandomForestClassifier(n_estimators=278, min_samples_split=5, min_samples_leaf=2, max_features='auto', max_depth=4, bootstrap= True)\n",
        "history = rf.fit(x_train_standardscaler, y_train.values.ravel())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "aQDBz0eLK3y5"
      },
      "outputs": [],
      "source": [
        "# Random Forest Classifier (Library) Test\n",
        "prediction = rf.predict(x_test_standardscaler)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UJnz87DWL7Bx",
        "outputId": "1d382666-f505-48d5-94df-0a9b6e717069"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.6004505426991603\n"
          ]
        }
      ],
      "source": [
        "acc_randomforest = accuracy_score(y_test, prediction)\n",
        "print(acc_randomforest)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 163
        },
        "id": "fxCR9SaQ-5H0",
        "outputId": "7ff04ac0-3089-4f91-e5c7-222d3a2155e5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'n_estimators': [201, 212, 223, 234, 245, 256, 267, 278, 289, 300], 'max_features': ['auto', 'sqrt'], 'max_depth': [2, 4], 'min_samples_split': [2, 5], 'min_samples_leaf': [1, 2], 'bootstrap': [True, False]}\n",
            "Fitting 10 folds for each of 10 candidates, totalling 100 fits\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/ensemble/_forest.py:424: FutureWarning: `max_features='auto'` has been deprecated in 1.1 and will be removed in 1.3. To keep the past behaviour, explicitly set `max_features='sqrt'` or remove this parameter as it is also the default value for RandomForestClassifiers and ExtraTreesClassifiers.\n",
            "  warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'rf = RandomForestClassifier()\\nrf_random = RandomizedSearchCV(estimator = rf, param_distributions = random_grid, n_iter = 100, cv = 3, verbose=2, random_state=42, n_jobs = -1)\\nrf_random.fit(x_train_standardscaler, y_train.values.ravel())\\nprint(rf_random.best_params_)'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "# Number of trees in random forest\n",
        "n_estimators = [int(x) for x in np.linspace(start = 201, stop = 300, num = 10)]\n",
        "# Number of features to consider at every split\n",
        "max_features = ['auto', 'sqrt']\n",
        "# Maximum number of levels in tree\n",
        "max_depth = [2,4]\n",
        "# Minimum number of samples required to split a node\n",
        "min_samples_split = [2, 5]\n",
        "# Minimum number of samples required at each leaf node\n",
        "min_samples_leaf = [1, 2]\n",
        "# Method of selecting samples for training each tree\n",
        "bootstrap = [True, False]\n",
        "\n",
        "# Create the param grid\n",
        "param_grid = {'n_estimators': n_estimators,\n",
        "               'max_features': max_features,\n",
        "               'max_depth': max_depth,\n",
        "               'min_samples_split': min_samples_split,\n",
        "               'min_samples_leaf': min_samples_leaf,\n",
        "               'bootstrap': bootstrap}\n",
        "print(param_grid)\n",
        "\n",
        "rf_Model = RandomForestClassifier()\n",
        "\n",
        "rf_RandomGrid = RandomizedSearchCV(estimator = rf_Model, param_distributions = param_grid, cv = 10, verbose=2, n_jobs = 4)\n",
        "rf_RandomGrid.fit(x_train_standardscaler, y_train.values.ravel())\n",
        "\n",
        "'''rf = RandomForestClassifier()\n",
        "rf_random = RandomizedSearchCV(estimator = rf, param_distributions = random_grid, n_iter = 100, cv = 3, verbose=2, random_state=42, n_jobs = -1)\n",
        "rf_random.fit(x_train_standardscaler, y_train.values.ravel())\n",
        "print(rf_random.best_params_)'''"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(rf_RandomGrid.best_params_)\n",
        "print (f'Train Accuracy - : {rf_RandomGrid.score(x_train_standardscaler,y_train.values.ravel()):.3f}')\n",
        "print (f'Test Accuracy - : {rf_RandomGrid.score(x_test_standardscaler,y_test):.3f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VF4fQyS33ofo",
        "outputId": "fd7f3d3b-6864-4310-9c7b-487ca9dbd8ed"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'n_estimators': 278, 'min_samples_split': 5, 'min_samples_leaf': 2, 'max_features': 'auto', 'max_depth': 4, 'bootstrap': True}\n",
            "Train Accuracy - : 0.595\n",
            "Test Accuracy - : 0.602\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "random_forest = RandomForestClassifier(n_estimators=200, oob_score = True, max_features=30)\n",
        "\n",
        "# Perform cross-validation\n",
        "cv_scores = cross_val_score(random_forest, x_train_standardscaler, y_train.values.ravel(), cv=5)  # 5-fold cross-validation\n",
        "\n",
        "# Print the cross-validation scores\n",
        "print(\"Cross-validation scores:\", cv_scores)\n",
        "print(\"Mean cross-validation score:\", cv_scores.mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HSDup-WFQv6R",
        "outputId": "53bbd568-1105-4c78-bd93-ebf929d0f622"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cross-validation scores: [0.75324232 0.75870307 0.75935829 0.7598134  0.75537604]\n",
            "Mean cross-validation score: 0.7572986245217319\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 416
        },
        "id": "QCSr_4xwS6Rg",
        "outputId": "79b413a4-19df-4b83-a501-da684c02cc70"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "max_feature:  21  Accuracy:  0.7613488975356679\n",
            "max_feature:  22  Accuracy:  0.7613488975356679\n"
          ]
        },
        {
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-738442d56601>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m21\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m   \u001b[0mclassifier\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mRandomForestClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_estimators\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0moob_score\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_features\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindex\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m   \u001b[0mclassifier\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_train_standardscaler\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m   \u001b[0mprediction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_test_standardscaler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m   \u001b[0macc_standardscaler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maccuracy_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprediction\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/ensemble/_forest.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m    471\u001b[0m             \u001b[0;31m# parallel_backend contexts set at a higher level,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    472\u001b[0m             \u001b[0;31m# since correctness does not rely on using threads.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 473\u001b[0;31m             trees = Parallel(\n\u001b[0m\u001b[1;32m    474\u001b[0m                 \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    475\u001b[0m                 \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m     61\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mdelayed_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m         )\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterable_with_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1086\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_iterating\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_original_iterator\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1087\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1088\u001b[0;31m             \u001b[0;32mwhile\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispatch_one_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1089\u001b[0m                 \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1090\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36mdispatch_one_batch\u001b[0;34m(self, iterator)\u001b[0m\n\u001b[1;32m    899\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    900\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 901\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dispatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtasks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    902\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    903\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m_dispatch\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m    817\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    818\u001b[0m             \u001b[0mjob_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 819\u001b[0;31m             \u001b[0mjob\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    820\u001b[0m             \u001b[0;31m# A job can complete so quickly than its callback is\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    821\u001b[0m             \u001b[0;31m# called before we get here, causing self._jobs to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/_parallel_backends.py\u001b[0m in \u001b[0;36mapply_async\u001b[0;34m(self, func, callback)\u001b[0m\n\u001b[1;32m    206\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mapply_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m         \u001b[0;34m\"\"\"Schedule a func to be run\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImmediateResult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    209\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    210\u001b[0m             \u001b[0mcallback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/_parallel_backends.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m    595\u001b[0m         \u001b[0;31m# Don't delay the application, to avoid keeping the input\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    596\u001b[0m         \u001b[0;31m# arguments in memory\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 597\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    599\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    286\u001b[0m         \u001b[0;31m# change the default number of processes to -1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m             return [func(*args, **kwargs)\n\u001b[0m\u001b[1;32m    289\u001b[0m                     for func, args, kwargs in self.items]\n\u001b[1;32m    290\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    286\u001b[0m         \u001b[0;31m# change the default number of processes to -1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 288\u001b[0;31m             return [func(*args, **kwargs)\n\u001b[0m\u001b[1;32m    289\u001b[0m                     for func, args, kwargs in self.items]\n\u001b[1;32m    290\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    121\u001b[0m             \u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    122\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mconfig_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 123\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/ensemble/_forest.py\u001b[0m in \u001b[0;36m_parallel_build_trees\u001b[0;34m(tree, bootstrap, X, y, sample_weight, tree_idx, n_trees, verbose, class_weight, n_samples_bootstrap)\u001b[0m\n\u001b[1;32m    182\u001b[0m             \u001b[0mcurr_sample_weight\u001b[0m \u001b[0;34m*=\u001b[0m \u001b[0mcompute_sample_weight\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"balanced\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindices\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindices\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    183\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 184\u001b[0;31m         \u001b[0mtree\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcurr_sample_weight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcheck_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    185\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    186\u001b[0m         \u001b[0mtree\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcheck_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/tree/_classes.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[1;32m    887\u001b[0m         \"\"\"\n\u001b[1;32m    888\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 889\u001b[0;31m         super().fit(\n\u001b[0m\u001b[1;32m    890\u001b[0m             \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    891\u001b[0m             \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/tree/_classes.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[1;32m    377\u001b[0m             )\n\u001b[1;32m    378\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 379\u001b[0;31m         \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtree_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    380\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    381\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_outputs_\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mis_classifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "'''for index in range(21,50):\n",
        "  classifier= RandomForestClassifier(n_estimators=200,oob_score = True, max_features=index )  \n",
        "  classifier.fit(x_train_standardscaler, y_train.values.ravel())  \n",
        "  prediction = rf.predict(x_test_standardscaler)\n",
        "  acc_standardscaler = accuracy_score(y_test, prediction)\n",
        "  print(\"max_feature: \", index, \" Accuracy: \", acc_standardscaler)\n",
        "  \n",
        "  \n",
        "  model_random = RandomForestClassifier(max_depth=6,\n",
        "                                      max_features='auto',\n",
        "                                      max_leaf_nodes=6,\n",
        "                                      n_estimators=50)\n",
        "  model_random.fit(x_train_standardscaler, y_train.values.ravel())\n",
        "  y_pred_rand = model_random.predict(x_test_standardscaler)\n",
        "  acc_RandomizedSearchCV = accuracy_score(y_test, y_pred_rand)\n",
        "  print(acc_RandomizedSearchCV)\n",
        "  '''"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0kHT4Fmp2oMQ",
        "outputId": "e6b10ab2-8bab-4ad7-ff91-028dce1a914c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.5741688852481398\n"
          ]
        }
      ],
      "source": [
        "from imblearn.pipeline import Pipeline\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "smote = SMOTE(random_state=42)\n",
        "\n",
        "classifier = GaussianNB()\n",
        "pipeline = Pipeline([('smote', smote), ('classifier', classifier)])\n",
        "\n",
        "param_grid = {'classifier__var_smoothing': [1e-9, 1e-8, 1e-7, 1e-6, 1e-5]}\n",
        "\n",
        "grid_search = GridSearchCV(pipeline, param_grid, cv=5)\n",
        "grid_search.fit(x_train_standardscaler, y_train.values.ravel())\n",
        "\n",
        "best_classifier = grid_search.best_estimator_\n",
        "\n",
        "y_pred = best_classifier.predict(x_test_standardscaler)\n",
        "acc_GaussianNB = accuracy_score(y_test, y_pred)\n",
        "print(acc_GaussianNB)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(grid_search.best_estimator_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4H3dbA8PbHSU",
        "outputId": "95145e64-60f8-4e98-e208-48254f682c94"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pipeline(steps=[('smote', SMOTE(random_state=42)),\n",
            "                ('classifier', GaussianNB(var_smoothing=1e-07))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "classifier_cross = GaussianNB(var_smoothing=1e-07)\n",
        "cv_scores = cross_val_score(classifier, x_train_standardscaler, y_train.values.ravel(), cv=5)  # 5-fold cross-validation\n",
        "\n",
        "# Print the cross-validation scores\n",
        "print(\"Cross-validation scores:\", cv_scores)\n",
        "print(\"Mean cross-validation score:\", cv_scores.mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QI-u2U2tayD6",
        "outputId": "0efc0ba0-95d7-421c-b06e-00027a5d9db1"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cross-validation scores: [0.56393629 0.56564278 0.56422801 0.56434179 0.56422801]\n",
            "Mean cross-validation score: 0.5644753765145722\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}