ML_PROJECT2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.3"
    },
    "colab": {
      "name": "ML_PROJECT2.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Chengeng-Yang/ML_projects/blob/main/ML_PROJECT2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k60ggaeDSTJv"
      },
      "source": [
        "import h5py\n",
        "fid = h5py.File(\"dataset_patchcamelyon.h5\", \"r\")\n",
        "X, Y = fid['X'][:], fid['Y'][:]\n",
        "X = X / 255.\n",
        "fid.close()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h4Cnjf_dSTJ2",
        "outputId": "f57d0f40-f655-43e2-ff97-d631c69564d8"
      },
      "source": [
        "X.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2500, 96, 96, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JpyQQPerSTJ3",
        "outputId": "5ec86692-0544-48df-f944-e34940e1230e"
      },
      "source": [
        "X"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[[224, 111, 191],\n",
              "         [239, 130, 209],\n",
              "         [230, 127, 206],\n",
              "         ...,\n",
              "         [152,  82, 170],\n",
              "         [224, 147, 225],\n",
              "         [212, 131, 200]],\n",
              "\n",
              "        [[177,  63, 150],\n",
              "         [188,  78, 164],\n",
              "         [177,  73, 158],\n",
              "         ...,\n",
              "         [215, 145, 234],\n",
              "         [224, 147, 227],\n",
              "         [215, 135, 208]],\n",
              "\n",
              "        [[208,  99, 192],\n",
              "         [194,  87, 181],\n",
              "         [173,  70, 162],\n",
              "         ...,\n",
              "         [176, 105, 197],\n",
              "         [203, 128, 210],\n",
              "         [211, 133, 208]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[ 88,  31, 134],\n",
              "         [ 94,  38, 137],\n",
              "         [137,  82, 176],\n",
              "         ...,\n",
              "         [158,  99, 189],\n",
              "         [110,  50, 140],\n",
              "         [119,  58, 151]],\n",
              "\n",
              "        [[155,  95, 193],\n",
              "         [132,  75, 170],\n",
              "         [ 85,  29, 118],\n",
              "         ...,\n",
              "         [121,  63, 148],\n",
              "         [ 97,  38, 128],\n",
              "         [127,  68, 160]],\n",
              "\n",
              "        [[151,  90, 185],\n",
              "         [131,  72, 164],\n",
              "         [115,  57, 142],\n",
              "         ...,\n",
              "         [166, 108, 192],\n",
              "         [122,  64, 151],\n",
              "         [ 81,  25, 114]]],\n",
              "\n",
              "\n",
              "       [[[106,  67, 111],\n",
              "         [112,  69, 114],\n",
              "         [ 84,  35,  80],\n",
              "         ...,\n",
              "         [181, 157, 183],\n",
              "         [200, 176, 202],\n",
              "         [117,  92, 121]],\n",
              "\n",
              "        [[ 95,  54,  98],\n",
              "         [117,  71, 117],\n",
              "         [132,  80, 126],\n",
              "         ...,\n",
              "         [194, 170, 194],\n",
              "         [255, 235, 255],\n",
              "         [176, 152, 178]],\n",
              "\n",
              "        [[ 98,  52,  99],\n",
              "         [108,  60, 108],\n",
              "         [ 97,  43,  92],\n",
              "         ...,\n",
              "         [222, 199, 219],\n",
              "         [255, 229, 254],\n",
              "         [188, 162, 189]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[219, 189, 215],\n",
              "         [167, 135, 158],\n",
              "         [194, 156, 179],\n",
              "         ...,\n",
              "         [168, 116, 152],\n",
              "         [197, 144, 174],\n",
              "         [210, 156, 180]],\n",
              "\n",
              "        [[243, 220, 238],\n",
              "         [198, 174, 187],\n",
              "         [196, 169, 178],\n",
              "         ...,\n",
              "         [159, 109, 146],\n",
              "         [207, 159, 185],\n",
              "         [183, 136, 156]],\n",
              "\n",
              "        [[229, 212, 222],\n",
              "         [217, 198, 202],\n",
              "         [250, 229, 228],\n",
              "         ...,\n",
              "         [167, 119, 157],\n",
              "         [136,  92, 117],\n",
              "         [238, 195, 214]]],\n",
              "\n",
              "\n",
              "       [[[172, 107, 191],\n",
              "         [193, 128, 212],\n",
              "         [123,  57, 144],\n",
              "         ...,\n",
              "         [ 85,  40, 125],\n",
              "         [ 80,  37, 126],\n",
              "         [ 76,  38, 125]],\n",
              "\n",
              "        [[152,  95, 174],\n",
              "         [159, 100, 182],\n",
              "         [147,  88, 172],\n",
              "         ...,\n",
              "         [ 94,  44, 131],\n",
              "         [ 86,  41, 126],\n",
              "         [ 82,  38, 125]],\n",
              "\n",
              "        [[150, 104, 176],\n",
              "         [138,  87, 162],\n",
              "         [152,  99, 181],\n",
              "         ...,\n",
              "         [108,  48, 134],\n",
              "         [ 98,  43, 127],\n",
              "         [ 92,  38, 124]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[184, 107, 177],\n",
              "         [168,  95, 168],\n",
              "         [209, 132, 210],\n",
              "         ...,\n",
              "         [118,  60, 145],\n",
              "         [106,  52, 136],\n",
              "         [103,  51, 134]],\n",
              "\n",
              "        [[236, 154, 226],\n",
              "         [215, 137, 212],\n",
              "         [158,  79, 158],\n",
              "         ...,\n",
              "         [119,  65, 153],\n",
              "         [107,  57, 144],\n",
              "         [102,  57, 142]],\n",
              "\n",
              "        [[191, 103, 177],\n",
              "         [142,  60, 136],\n",
              "         [187, 106, 185],\n",
              "         ...,\n",
              "         [121,  68, 158],\n",
              "         [114,  65, 154],\n",
              "         [113,  69, 156]]],\n",
              "\n",
              "\n",
              "       ...,\n",
              "\n",
              "\n",
              "       [[[227, 157, 220],\n",
              "         [186, 103, 175],\n",
              "         [185,  88, 167],\n",
              "         ...,\n",
              "         [111,  62, 153],\n",
              "         [ 76,  29, 123],\n",
              "         [ 85,  38, 134]],\n",
              "\n",
              "        [[214, 134, 203],\n",
              "         [216, 126, 200],\n",
              "         [201, 100, 180],\n",
              "         ...,\n",
              "         [ 91,  45, 143],\n",
              "         [ 91,  46, 147],\n",
              "         [ 87,  42, 145]],\n",
              "\n",
              "        [[179,  89, 163],\n",
              "         [227, 130, 209],\n",
              "         [197,  94, 177],\n",
              "         ...,\n",
              "         [ 98,  56, 158],\n",
              "         [ 78,  37, 143],\n",
              "         [ 90,  48, 156]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[189,  84, 176],\n",
              "         [191,  88, 179],\n",
              "         [176,  77, 168],\n",
              "         ...,\n",
              "         [202, 134, 217],\n",
              "         [171,  94, 176],\n",
              "         [223, 138, 221]],\n",
              "\n",
              "        [[198,  86, 170],\n",
              "         [193,  85, 171],\n",
              "         [216, 117, 208],\n",
              "         ...,\n",
              "         [170, 100, 186],\n",
              "         [188, 104, 190],\n",
              "         [208, 114, 200]],\n",
              "\n",
              "        [[186,  69, 147],\n",
              "         [190,  78, 162],\n",
              "         [183,  84, 174],\n",
              "         ...,\n",
              "         [170,  98, 184],\n",
              "         [188,  98, 186],\n",
              "         [242, 142, 230]]],\n",
              "\n",
              "\n",
              "       [[[123,  69, 145],\n",
              "         [145,  84, 161],\n",
              "         [202, 130, 206],\n",
              "         ...,\n",
              "         [215, 134, 201],\n",
              "         [140,  61, 140],\n",
              "         [184, 104, 193]],\n",
              "\n",
              "        [[ 99,  47, 132],\n",
              "         [ 88,  30, 115],\n",
              "         [116,  48, 131],\n",
              "         ...,\n",
              "         [203, 125, 200],\n",
              "         [210, 132, 218],\n",
              "         [176,  99, 193]],\n",
              "\n",
              "        [[ 72,  24, 123],\n",
              "         [102,  48, 146],\n",
              "         [139,  78, 173],\n",
              "         ...,\n",
              "         [167,  94, 175],\n",
              "         [115,  40, 131],\n",
              "         [121,  47, 144]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[173, 142, 210],\n",
              "         [ 59,  30, 110],\n",
              "         [ 77,  46, 139],\n",
              "         ...,\n",
              "         [210, 101, 182],\n",
              "         [193,  93, 179],\n",
              "         [175,  82, 171]],\n",
              "\n",
              "        [[184, 149, 213],\n",
              "         [ 95,  63, 139],\n",
              "         [ 73,  40, 131],\n",
              "         ...,\n",
              "         [182,  81, 161],\n",
              "         [187,  97, 185],\n",
              "         [149,  65, 159]],\n",
              "\n",
              "        [[172, 133, 196],\n",
              "         [ 78,  44, 120],\n",
              "         [ 65,  32, 123],\n",
              "         ...,\n",
              "         [206, 113, 194],\n",
              "         [197, 114, 206],\n",
              "         [123,  47, 147]]],\n",
              "\n",
              "\n",
              "       [[[104,  71, 100],\n",
              "         [238, 205, 232],\n",
              "         [178, 143, 165],\n",
              "         ...,\n",
              "         [ 29,   6,  16],\n",
              "         [173, 151, 164],\n",
              "         [131, 108, 124]],\n",
              "\n",
              "        [[ 94,  64,  92],\n",
              "         [255, 229, 255],\n",
              "         [143, 110, 131],\n",
              "         ...,\n",
              "         [227, 207, 218],\n",
              "         [255, 247, 255],\n",
              "         [249, 230, 249]],\n",
              "\n",
              "        [[100,  67,  96],\n",
              "         [255, 242, 255],\n",
              "         [195, 161, 185],\n",
              "         ...,\n",
              "         [253, 235, 247],\n",
              "         [220, 203, 221],\n",
              "         [234, 216, 238]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[ 77,  47,  73],\n",
              "         [148, 123, 145],\n",
              "         [255, 247, 255],\n",
              "         ...,\n",
              "         [105,  76, 120],\n",
              "         [ 85,  54,  95],\n",
              "         [136, 106, 142]],\n",
              "\n",
              "        [[ 50,  25,  55],\n",
              "         [ 54,  31,  60],\n",
              "         [194, 174, 201],\n",
              "         ...,\n",
              "         [119,  94, 134],\n",
              "         [112,  87, 126],\n",
              "         [110,  86, 118]],\n",
              "\n",
              "        [[123,  99, 135],\n",
              "         [ 55,  34,  67],\n",
              "         [110,  91, 121],\n",
              "         ...,\n",
              "         [249, 227, 255],\n",
              "         [239, 217, 253],\n",
              "         [176, 155, 186]]]], dtype=uint8)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ABhyXHgcSTJ4"
      },
      "source": [
        "import matplotlib      # MatPlotLib is for making plots & figures\n",
        "import matplotlib.pyplot as plt     # PyPlot is a subset of the library for making MATLAB-style plots"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AocfLkTuSTJ4",
        "outputId": "72608abb-e364-47f3-ab44-72b632970801"
      },
      "source": [
        "plt.imshow(X[0,:, :, :])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7ff38e196e20>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ch-dTpkSSTJ4",
        "outputId": "051d7c69-e4c6-41c3-f7f6-c9f25c03ac59"
      },
      "source": [
        "Y.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2500, 1, 1, 1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lcyukaoaSTJ5",
        "outputId": "7642429b-0d52-4405-a10d-527f208d0537"
      },
      "source": [
        "X0 = X.reshape(2500,-1)\n",
        "X0.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2500, 27648)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y8rbuO61STJ5",
        "outputId": "8de86812-b005-42e6-90d5-aea8dd72e7ad"
      },
      "source": [
        "X[:,:,:,0].shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2500, 96, 96)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-rOpUqAISTJ6",
        "outputId": "d6edfc44-b5b2-4682-d92e-b28779c3f30d"
      },
      "source": [
        "(X[0][0][0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.87843137, 0.43529412, 0.74901961])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VkqJsmQtSTJ6"
      },
      "source": [
        "#SPLIT X,Y\n",
        "from sklearn.model_selection import train_test_split\n",
        "import numpy as np      \n",
        "#redo spliting, use x0_train instead\n",
        "\n",
        "shuffle_index=np.random.permutation(2500)\n",
        "X_S,Y_S = X[shuffle_index],Y[shuffle_index]\n",
        "\n",
        "X0train,X0_test,Y0train,Y0_test=train_test_split(X_S,Y_S,test_size=0.2,random_state=30) #scikilearn\n",
        "X0_train,X0_val,Y0_train,Y0_val=train_test_split(X0train,Y0train,test_size=0.2,random_state=36)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5DoOROcWSTJ6"
      },
      "source": [
        "import numpy as np      \n",
        "#no dimension reduction\n",
        "\n",
        "x0_train,x0_test=X0_train.reshape(1600,-1),X0_test.reshape(500,-1) \n",
        "y0_train,y0_test=Y0_train.reshape(1600,),Y0_test.reshape(500,) \n",
        "\n",
        "#scikilearn: x0_train,x0_test,y0_train,y0_test, for direct processing"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sRSFrf87STJ7"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FwA9fgIASTJ7",
        "outputId": "469afe3d-6807-4d7b-a3e7-1fd262c84150"
      },
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "# max pooling\n",
        "maxpool=tf.keras.layers.MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='valid')\n",
        "\n",
        "x1_train,x1_test = maxpool(X0_train),maxpool(X0_test)\n",
        "\n",
        "# average pooling\n",
        "avepool=tf.keras.layers.AveragePooling2D(pool_size=(2,2),strides=(2,2),padding='valid')\n",
        "\n",
        "x2_train,x2_test = avepool(X0_train),avepool(X0_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Layer max_pooling2d_2 is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
            "\n",
            "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
            "\n",
            "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
            "\n",
            "WARNING:tensorflow:Layer average_pooling2d_1 is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
            "\n",
            "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
            "\n",
            "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tk8c-2EvSTJ7",
        "outputId": "916b262d-26cf-4676-ee50-09e268f78a23"
      },
      "source": [
        "x1_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([1600, 48, 48, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1kkoL6sNSTJ8"
      },
      "source": [
        "x1_train,x1_test=np.asarray(x1_train),np.asarray(x1_test)\n",
        "\n",
        "x1_train,x1_test=x1_train.reshape(1600,-1),x1_test.reshape(500,-1) \n",
        "y1_train,y1_test=Y0_train.reshape(1600,),Y0_test.reshape(500,) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1t35sZJPSTJ8"
      },
      "source": [
        "x2_train,x2_test=np.asarray(x2_train),np.asarray(x2_test)\n",
        "\n",
        "x2_train,x2_test=x2_train.reshape(1600,-1),x2_test.reshape(500,-1) \n",
        "y2_train,y2_test=Y0_train.reshape(1600,),Y0_test.reshape(500,) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IStV20-gSTJ8"
      },
      "source": [
        "x2_val = avepool(X0_val)\n",
        "x2_val=np.asarray(x2_val)\n",
        "x2_val=x2_val.reshape(400,-1)\n",
        "y2_val=Y0_val.reshape(400,)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNhtAfBVSTJ8"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zLYtFzAQSTJ9"
      },
      "source": [
        "# averaging 3 layers\n",
        "x3_train,x3_test = np.average(X0_train, axis=3), np.average(X0_test, axis=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KCPcASU4STJ9",
        "outputId": "1e57d5fb-6b21-4465-e0ff-ae94ac5ad212"
      },
      "source": [
        "x3_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1600, 96, 96)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cBdYRzgISTJ9"
      },
      "source": [
        "x3_train,x3_test=x3_train.reshape(1600,-1),x3_test.reshape(500,-1) \n",
        "y3_train,y3_test=Y0_train.reshape(1600,),Y0_test.reshape(500,) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OlK2PNKdSTJ9",
        "outputId": "33a0cf77-5059-4101-d564-446112478492"
      },
      "source": [
        "x3_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1600, 9216)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s9xwliHGSTJ-"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1WMyWO0XSTJ-"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CDAELhq3STJ-",
        "outputId": "907728b1-acdb-4a6e-a92d-946116065c94"
      },
      "source": [
        "# No dimension reduction\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.naive_bayes import MultinomialNB\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf01 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "\n",
        "param1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,1000,75).tolist(),\n",
        "          \"min_samples_leaf\":np.arange(1,500,50).tolist(),\n",
        "          }\n",
        "\n",
        "search01 = RandomizedSearchCV(clf01, param1, cv = 4,\n",
        "                            n_iter=75, verbose=1)\n",
        "\n",
        "search01.fit(x0_train, y0_train)\n",
        "\n",
        "# Save the parameters\n",
        "RF0 = search01.best_params_\n",
        "print(RF0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:  4.8min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 101, 'min_samples_leaf': 1, 'max_depth': 752}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lBITabgJSTJ-",
        "outputId": "7ae65703-b122-42ad-8537-aa93b5154663"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf01_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF0[\"n_estimators\"],\n",
        "                              max_depth = RF0[\"max_depth\"],\n",
        "                              min_samples_leaf = RF0[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf01_opt.fit(x0_train, y0_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=752, n_estimators=101, n_jobs=-1,\n",
              "                       random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kVrAVNHRSTJ_",
        "outputId": "4f1e6919-6f1d-4a25-89fb-5a1afa6e00be"
      },
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf02 = KNeighborsClassifier()\n",
        "\n",
        "param2 = {\n",
        "    \"n_neighbors\": np.arange(2,250,50),\n",
        "    \"weights\": ['uniform','distance'],\n",
        "    \"p\": [1,2],\n",
        "    \"metric\": ['minkowski', 'euclidean','manhattan']}\n",
        "\n",
        "search02 = RandomizedSearchCV(clf02, param2, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "search02.fit(x0_train, y0_train)\n",
        "\n",
        "# Save the best parameters\n",
        "knn0 = search02.best_params_\n",
        "print(knn0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/home/chengeng/anaconda3/lib/python3.8/site-packages/sklearn/model_selection/_search.py:278: UserWarning: The total space of parameters 60 is smaller than n_iter=75. Running 60 iterations. For exhaustive searches, use GridSearchCV.\n",
            "  warnings.warn(\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 60 candidates, totalling 240 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Done 240 out of 240 | elapsed: 96.3min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'weights': 'distance', 'p': 1, 'n_neighbors': 52, 'metric': 'minkowski'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GyrdpbTASTJ_",
        "outputId": "71be4125-0748-4177-8bec-ff1e46232d4c"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf02_opt = KNeighborsClassifier(\n",
        "    n_neighbors = knn0['n_neighbors'],\n",
        "    weights = knn0['weights'],\n",
        "    p = knn0['p'],\n",
        "    metric = knn0['metric']\n",
        "    )\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf02_opt.fit(x0_train, y0_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(n_neighbors=52, p=1, weights='distance')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m3ZAQbXOSTKA",
        "outputId": "7eb8a612-b145-4b97-a5c0-ce51eedb0aab"
      },
      "source": [
        "# initialize the classifiers\n",
        "clf05 = MultinomialNB(class_prior=None)\n",
        "\n",
        "param5 = {\n",
        "    'alpha': np.arange(0.01, 2, 0.02),\n",
        "    'fit_prior': ['True','False']\n",
        "                }\n",
        "\n",
        "search05 = RandomizedSearchCV(clf05, param5, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "\n",
        "search05.fit(x0_train, y0_train)\n",
        "\n",
        "# Save the best parameters\n",
        "mnb0 = search05.best_params_\n",
        "print(mnb0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n",
            "{'fit_prior': 'False', 'alpha': 1.2499999999999998}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:   55.2s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "12dMNdE5STKA",
        "outputId": "7d635f86-3f67-4776-a2b2-4c6c1f2d7a28"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf05_opt = MultinomialNB(class_prior=None,\n",
        "                            alpha = mnb0['alpha'],\n",
        "                            fit_prior = mnb0['fit_prior'])\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf05_opt.fit(x0_train, y0_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultinomialNB(alpha=1.2499999999999998, fit_prior='False')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2SflVE8YSTKB"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qtc00ocFSTKB",
        "outputId": "7704f059-6b23-425b-c34b-69a6f25fe7bb"
      },
      "source": [
        "#after dimension reduction -X1\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "clf11 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,1000,75).tolist(),\n",
        "          \"min_samples_leaf\":np.arange(1,500,50).tolist(),\n",
        "          }\n",
        "\n",
        "search11 = RandomizedSearchCV(clf11, param1, cv = 4,\n",
        "                            n_iter=75, verbose=1)\n",
        "\n",
        "search11.fit(x1_train, y1_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF1 = search11.best_params_\n",
        "print(RF1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:  2.9min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 201, 'min_samples_leaf': 1, 'max_depth': 77}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z4IepPftSTKB",
        "outputId": "0c2f6c94-fdc9-4763-c3c7-11e837a32e01"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf11_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF1[\"n_estimators\"],\n",
        "                              max_depth = RF1[\"max_depth\"],\n",
        "                              min_samples_leaf = RF1[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf11_opt.fit(x1_train, y1_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=77, n_estimators=201, n_jobs=-1,\n",
              "                       random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t9tE37DuSTKC",
        "outputId": "a6a6b93e-19dc-49ea-f1cd-534a67997e06"
      },
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "\n",
        "clf12 = KNeighborsClassifier()\n",
        "\n",
        "param2 = {\n",
        "    \"n_neighbors\": np.arange(2,250,50),\n",
        "    \"weights\": ['uniform','distance'],\n",
        "    \"p\": [1,2],\n",
        "    \"metric\": ['minkowski', 'euclidean','manhattan']}\n",
        "\n",
        "search12 = RandomizedSearchCV(clf12, param2, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "search12.fit(x1_train, y1_train)\n",
        "\n",
        "# Save the best parameters\n",
        "knn1 = search12.best_params_\n",
        "print(knn1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 60 candidates, totalling 240 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/home/chengeng/anaconda3/lib/python3.8/site-packages/sklearn/model_selection/_search.py:278: UserWarning: The total space of parameters 60 is smaller than n_iter=75. Running 60 iterations. For exhaustive searches, use GridSearchCV.\n",
            "  warnings.warn(\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 240 out of 240 | elapsed: 23.5min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'weights': 'distance', 'p': 1, 'n_neighbors': 202, 'metric': 'minkowski'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NgjOKBZ_STKC",
        "outputId": "d6cffeef-6fb5-456a-be0c-b4f692397b39"
      },
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "# Create the optimal classifier\n",
        "clf12_opt = KNeighborsClassifier(\n",
        "    n_neighbors= knn1['n_neighbors'],\n",
        "    weights= knn1['weights'],\n",
        "    p= knn1['p'],\n",
        "    metric= knn1['metric']\n",
        "    )\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf12_opt.fit(x1_train, y1_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(n_neighbors=202, p=1, weights='distance')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SpxRwrtbSTKC",
        "outputId": "0ddfbb41-2764-49ce-9f26-28e1a08b21f0"
      },
      "source": [
        "from sklearn.naive_bayes import MultinomialNB\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "# initialize the classifiers\n",
        "clf15 = MultinomialNB(class_prior=None)\n",
        "\n",
        "param5 = {\n",
        "    'alpha': np.arange(0.01, 2, 0.02),\n",
        "    'fit_prior': ['True','False']\n",
        "                }\n",
        "\n",
        "search15 = RandomizedSearchCV(clf15, param5, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "\n",
        "search15.fit(x1_train, y1_train)\n",
        "\n",
        "# Save the best parameters\n",
        "mnb1 = search15.best_params_\n",
        "print(mnb1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'fit_prior': 'True', 'alpha': 0.30999999999999994}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:   14.6s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tN9VkJyPSTKD",
        "outputId": "d55176b4-b7dc-4794-97b6-206b1d6db102"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf15_opt = MultinomialNB(class_prior=None,\n",
        "                            alpha = mnb1['alpha'],\n",
        "                            fit_prior = mnb1['fit_prior'])\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf15_opt.fit(x1_train, y1_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultinomialNB(alpha=0.30999999999999994, fit_prior='True')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-1Vt5N4hSTKD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "J3YqAIS7STKD",
        "outputId": "f17077ce-8030-45eb-ce08-1d426163d1a3"
      },
      "source": [
        "#after dimension reduction -X2\n",
        "\n",
        "clf21 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,1000,75).tolist(),\n",
        "          \"min_samples_leaf\":np.arange(1,500,50).tolist(),\n",
        "          }\n",
        "\n",
        "search21 = RandomizedSearchCV(clf21, param1, cv = 4,\n",
        "                            n_iter=75, verbose=1)\n",
        "\n",
        "search21.fit(x2_train, y2_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF2 = search21.best_params_\n",
        "print(RF2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:  2.8min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 351, 'min_samples_leaf': 1, 'max_depth': 527}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HhxOKKbHSTKD",
        "outputId": "4df95fc1-f6a0-453a-938f-7182b1ebdbcb"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf21_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF2[\"n_estimators\"],\n",
        "                              max_depth = RF2[\"max_depth\"],\n",
        "                              min_samples_leaf = RF2[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf21_opt.fit(x2_train, y2_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=527, n_estimators=351, n_jobs=-1,\n",
              "                       random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QCOEe1qBSTKE",
        "outputId": "a831b065-6185-4ef2-bcad-d7ffe1e26e77"
      },
      "source": [
        "clf22 = KNeighborsClassifier()\n",
        "\n",
        "param2 = {\n",
        "    \"n_neighbors\": np.arange(2,250,50),\n",
        "    \"weights\": ['uniform','distance'],\n",
        "    \"p\": [1,2],\n",
        "    \"metric\": ['minkowski', 'euclidean','manhattan']}\n",
        "\n",
        "search22 = RandomizedSearchCV(clf22, param2, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "search22.fit(x2_train, y2_train)\n",
        "\n",
        "# Save the best parameters\n",
        "knn2 = search22.best_params_\n",
        "print(knn2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 60 candidates, totalling 240 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/home/chengeng/anaconda3/lib/python3.8/site-packages/sklearn/model_selection/_search.py:278: UserWarning: The total space of parameters 60 is smaller than n_iter=75. Running 60 iterations. For exhaustive searches, use GridSearchCV.\n",
            "  warnings.warn(\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 240 out of 240 | elapsed: 23.5min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'weights': 'distance', 'p': 1, 'n_neighbors': 52, 'metric': 'minkowski'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AITj5lE-STKE",
        "outputId": "7b75a702-8bf7-4c40-e0f4-8ff887f36e69"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf22_opt = KNeighborsClassifier(\n",
        "    n_neighbors= knn2['n_neighbors'],\n",
        "    weights= knn2['weights'],\n",
        "    p= knn2['p'],\n",
        "    metric= knn2['metric']\n",
        "    )\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf22_opt.fit(x2_train, y2_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(n_neighbors=52, p=1, weights='distance')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pCSuMQ_GSTKE",
        "outputId": "88b19c98-225e-4493-f861-93c4354f7eeb"
      },
      "source": [
        "# initialize the classifiers\n",
        "clf25 = MultinomialNB(class_prior=None)\n",
        "\n",
        "param5 = {\n",
        "    'alpha': np.arange(0.01, 2, 0.02),\n",
        "    'fit_prior': ['True','False']\n",
        "                }\n",
        "\n",
        "search25 = RandomizedSearchCV(clf25, param5, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "\n",
        "search25.fit(x2_train, y2_train)\n",
        "\n",
        "# Save the best parameters\n",
        "mnb2 = search25.best_params_\n",
        "print(mnb2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n",
            "{'fit_prior': 'False', 'alpha': 1.8699999999999997}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:   14.5s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CWbe3hySSTKF",
        "outputId": "236c7e63-ce7d-426b-f75f-52bfbec37d5a"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf25_opt = MultinomialNB(class_prior=None,\n",
        "                            alpha = mnb2['alpha'],\n",
        "                            fit_prior = mnb2['fit_prior'])\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf25_opt.fit(x2_train, y2_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultinomialNB(alpha=1.8699999999999997, fit_prior='False')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fXOa2fJMSTKF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yPUrBQoQSTKF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Jk7g_NLSTKF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cz-qS_UESTKG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lek1jg7iSTKG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nzNRMOjxSTKG"
      },
      "source": [
        "#averaging 3 layers"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "80c6k0guSTKG",
        "outputId": "eeba4707-9bbb-4f76-d3ff-548216b203c1"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "clf31 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "\n",
        "param1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,1000,75).tolist(),\n",
        "          \"min_samples_leaf\":np.arange(1,500,50).tolist(),\n",
        "          }\n",
        "\n",
        "search31 = RandomizedSearchCV(clf31, param1, cv = 4,\n",
        "                            n_iter=75, verbose=1)\n",
        "\n",
        "search31.fit(x3_train, y3_train)\n",
        "\n",
        "# Save the parameters\n",
        "RF3 = search31.best_params_\n",
        "print(RF3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:  3.0min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 451, 'min_samples_leaf': 1, 'max_depth': 902}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S2-ycMbrSTKG",
        "outputId": "a3421107-e007-4970-a918-3a5613005210"
      },
      "source": [
        "# Create the optimal classifier\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "clf31_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF3['n_estimators'], \n",
        "                              max_depth = RF3['max_depth'], \n",
        "                              min_samples_leaf = RF3['min_samples_leaf'], \n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf31_opt.fit(x3_train, y3_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=902, n_estimators=451, n_jobs=-1,\n",
              "                       random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WYSTEiZUSTKH",
        "outputId": "85f19af3-403b-401e-86ec-be4a90776516"
      },
      "source": [
        "clf32 = KNeighborsClassifier()\n",
        "\n",
        "param2 = {\n",
        "    \"n_neighbors\": np.arange(2,250,50),\n",
        "    \"weights\": ['uniform','distance'],\n",
        "    \"p\": [1,2],\n",
        "    \"metric\": ['minkowski', 'euclidean','manhattan']}\n",
        "\n",
        "search32 = RandomizedSearchCV(clf32, param2, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "search32.fit(x3_train, y3_train)\n",
        "\n",
        "# Save the best parameters\n",
        "knn3 = search32.best_params_\n",
        "print(knn3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/home/chengeng/anaconda3/lib/python3.8/site-packages/sklearn/model_selection/_search.py:278: UserWarning: The total space of parameters 60 is smaller than n_iter=75. Running 60 iterations. For exhaustive searches, use GridSearchCV.\n",
            "  warnings.warn(\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 60 candidates, totalling 240 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Done 240 out of 240 | elapsed: 31.3min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'weights': 'distance', 'p': 1, 'n_neighbors': 52, 'metric': 'minkowski'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GXkYobebSTKH",
        "outputId": "e9c639d2-51ee-4028-f347-8c8403c293a2"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf32_opt = KNeighborsClassifier(\n",
        "            n_neighbors= knn3['n_neighbors'],\n",
        "            weights= knn3['weights'], \n",
        "            p= knn3['p'], \n",
        "            metric= knn3['metric'] \n",
        "    )\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf32_opt.fit(x3_train, y3_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(n_neighbors=52, p=1, weights='distance')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "z1ckdRtlSTKH",
        "outputId": "9dd819c5-79b8-46a4-a6cb-a14ac022c6b1"
      },
      "source": [
        "# initialize the classifiers\n",
        "clf35 = MultinomialNB(class_prior=None)\n",
        "\n",
        "param5 = {\n",
        "    'alpha': np.arange(0.01, 2, 0.02),\n",
        "    'fit_prior': ['True','False']\n",
        "                }\n",
        "\n",
        "search35 = RandomizedSearchCV(clf35, param5, cv = 4,\n",
        "                                n_iter=75,\n",
        "                                return_train_score=False,\n",
        "                                verbose=1)\n",
        "\n",
        "search35.fit(x3_train, y3_train)\n",
        "\n",
        "# Save the best parameters\n",
        "mnb3 = search35.best_params_\n",
        "print(mnb3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 75 candidates, totalling 300 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'fit_prior': 'False', 'alpha': 0.6699999999999999}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Done 300 out of 300 | elapsed:   17.6s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p35mloEiSTKH",
        "outputId": "7a0ca954-307f-4e2d-cc96-7b8147ebdf92"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf35_opt = MultinomialNB(class_prior=None,\n",
        "                            alpha = mnb3['alpha'],\n",
        "                            fit_prior = mnb3['fit_prior'])\n",
        "\n",
        "\n",
        "# Predict on test data\n",
        "clf35_opt.fit(x3_train, y3_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultinomialNB(alpha=0.6699999999999999, fit_prior='False')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "50dnoM-CSTKI"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "92kaBeHBSTKI"
      },
      "source": [
        "y0pred1 = clf01_opt.predict(x0_test)\n",
        "y0pred2 = clf02_opt.predict(x0_test)\n",
        "y0pred5 = clf05_opt.predict(x0_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bz4WKMBqSTKI",
        "outputId": "0a9a2449-ab34-4b89-8a9c-d231351a3234"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix\n",
        "print(accuracy_score(y0_test,y0pred1),\n",
        "      accuracy_score(y0_test,y0pred2),\n",
        "      accuracy_score(y0_test,y0pred5))\n",
        "\n",
        "print(precision_score(y0_test,y0pred1),\n",
        "      precision_score(y0_test,y0pred2),\n",
        "      precision_score(y0_test,y0pred5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.802 0.732 0.596\n",
            "0.7725631768953068 0.6823899371069182 0.603448275862069\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HwWz0DgJSTKI"
      },
      "source": [
        "y1pred1 = clf11_opt.predict(x1_test)\n",
        "y1pred2 = clf12_opt.predict(x1_test)\n",
        "y1pred5 = clf15_opt.predict(x1_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iWDbuKnBSTKI",
        "outputId": "37be395a-dd1b-4809-ddff-db1683f050a8"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix\n",
        "print(accuracy_score(y1_test,y1pred1),\n",
        "      accuracy_score(y1_test,y1pred2),\n",
        "      accuracy_score(y1_test,y1pred5))\n",
        "\n",
        "print(precision_score(y1_test,y1pred1),\n",
        "      precision_score(y1_test,y1pred2),\n",
        "      precision_score(y1_test,y1pred5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.778 0.636 0.62\n",
            "0.7473309608540926 0.6268656716417911 0.6401869158878505\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ogvbLjH4STKJ"
      },
      "source": [
        "y2pred1 = clf21_opt.predict(x2_test)\n",
        "y2pred2 = clf22_opt.predict(x2_test)\n",
        "y2pred5 = clf25_opt.predict(x2_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4yOMp7y1STKJ",
        "outputId": "7e9f8584-3349-450d-a17b-d3f47d4b5461"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix\n",
        "print(accuracy_score(y2_test,y2pred1),\n",
        "      accuracy_score(y2_test,y2pred2),\n",
        "      accuracy_score(y2_test,y2pred5))\n",
        "\n",
        "print(precision_score(y2_test,y2pred1),\n",
        "      precision_score(y2_test,y2pred2),\n",
        "      precision_score(y2_test,y2pred5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.808 0.746 0.592\n",
            "0.7730496453900709 0.6880733944954128 0.5982905982905983\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fteO0LfTSTKM"
      },
      "source": [
        "y3pred1 = clf31_opt.predict(x3_test)\n",
        "y3pred2 = clf32_opt.predict(x3_test)\n",
        "y3pred5 = clf35_opt.predict(x3_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oFnjHBUcSTKM",
        "outputId": "4415969d-74bc-43f9-8609-9066f1d9844f"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix\n",
        "print(accuracy_score(y3_test,y3pred1),\n",
        "      accuracy_score(y3_test,y3pred2),\n",
        "      accuracy_score(y3_test,y3pred5))\n",
        "\n",
        "print(precision_score(y3_test,y3pred1),\n",
        "      precision_score(y3_test,y3pred2),\n",
        "      precision_score(y3_test,y3pred5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.802 0.72 0.532\n",
            "0.7915057915057915 0.6697530864197531 0.5298507462686567\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5mzF6ltISTKM",
        "outputId": "f97f396b-f9ad-4363-b59e-87c7f6e3a4fc"
      },
      "source": [
        "x1_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1600, 6912)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrXefMmhSTKM"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8KXjdgApSTKM"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dqI26EwjSTKN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uBl7UJtoSTKN"
      },
      "source": [
        "Correction: Ranges for parameter searching and possible overfitting issue.\n",
        "**These issues were raised during the presentation. After presentation, we carefully reconsidered the hyperparameter search ranges of min_samples_leaf and max depth, reset them for new searches to avoid possible overfitting problem brought by random forest classifier**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lUxQuvYnSTKN"
      },
      "source": [
        "# RF, updated search range1\n",
        "# try to reduce the max depth and modify the range for min samples per leaf to see if the accuracy \n",
        "# on the test data improves"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "EUvVT9yGSTKN",
        "outputId": "2197cc2c-7ff6-46d3-9747-cd39a861be6a"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf01_new = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,500,100).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search01_new = RandomizedSearchCV(clf01_new, param1_new, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search01_new.fit(x0_train, y0_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF0_new = search01_new.best_params_\n",
        "print(RF0_new)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  8.6min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 301, 'min_samples_leaf': 7, 'max_depth': 402}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5q8pteF0STKN",
        "outputId": "9eba6df3-19e9-4072-cbb3-a49f6d0d075b"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf01_new_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF0_new[\"n_estimators\"],\n",
        "                              max_depth = RF0_new[\"max_depth\"],\n",
        "                              min_samples_leaf = RF0_new[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf01_new_opt.fit(x0_train, y0_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=402, min_samples_leaf=7, n_estimators=301,\n",
              "                       n_jobs=-1, random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgFcg122STKO",
        "outputId": "203ba037-7076-4826-8040-3ae343e02358"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf11_new = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,500,100).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search11_new = RandomizedSearchCV(clf11_new, param1_new, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search11_new.fit(x1_train, y1_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF1_new = search11_new.best_params_\n",
        "print(RF1_new)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  3.7min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 251, 'min_samples_leaf': 7, 'max_depth': 302}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oo1C3ljGSTKO",
        "outputId": "9eb7f00d-25fd-40b6-fd13-0f7826f5ed3b"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf11_new_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF1_new[\"n_estimators\"],\n",
        "                              max_depth = RF1_new[\"max_depth\"],\n",
        "                              min_samples_leaf = RF1_new[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf11_new_opt.fit(x1_train, y1_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=302, min_samples_leaf=7, n_estimators=251,\n",
              "                       n_jobs=-1, random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "lYa-xBvVSTKO",
        "outputId": "e92f972d-e6f1-40dd-e58b-74180940d5b7"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf21_new = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,500,100).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search21_new = RandomizedSearchCV(clf21_new, param1_new, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search21_new.fit(x2_train, y2_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF2_new = search21_new.best_params_\n",
        "print(RF2_new)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  4.1min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 351, 'min_samples_leaf': 1, 'max_depth': 302}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KicLTH4USTKP",
        "outputId": "34174e47-9a60-4775-b2fd-f889001b394e"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf21_new_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF2_new[\"n_estimators\"],\n",
        "                              max_depth = RF2_new[\"max_depth\"],\n",
        "                              min_samples_leaf = RF2_new[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf21_new_opt.fit(x2_train, y2_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=302, n_estimators=351, n_jobs=-1,\n",
              "                       random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-2sYBqJ6STKP",
        "outputId": "41005b9d-ffb1-402c-f6a2-80b78cc725ed"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf31_new = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,500,100).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search31_new = RandomizedSearchCV(clf31_new, param1_new, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search31_new.fit(x3_train, y3_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF3_new = search31_new.best_params_\n",
        "print(RF3_new)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  4.8min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 201, 'min_samples_leaf': 13, 'max_depth': 402}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SZBdJigESTKP",
        "outputId": "8f0f8e8f-2e8a-4f2b-bb0c-9542c2cd2c4c"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf31_new_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF3_new[\"n_estimators\"],\n",
        "                              max_depth = RF3_new[\"max_depth\"],\n",
        "                              min_samples_leaf = RF3_new[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf31_new_opt.fit(x3_train, y3_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=402, min_samples_leaf=13, n_estimators=201,\n",
              "                       n_jobs=-1, random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-HFLuHYuSTKP"
      },
      "source": [
        "y0pred1_new = clf01_new_opt.predict(x0_test)\n",
        "y1pred1_new = clf11_new_opt.predict(x1_test)\n",
        "y2pred1_new = clf21_new_opt.predict(x2_test)\n",
        "y3pred1_new = clf31_new_opt.predict(x3_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IoMepv8ESTKQ",
        "outputId": "b1c320e8-2818-4e0a-aa96-37cc50a5dd6f"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix\n",
        "print(accuracy_score(y0_test,y0pred1_new),\n",
        "      accuracy_score(y1_test,y1pred1_new),\n",
        "      accuracy_score(y2_test,y2pred1_new),\n",
        "      accuracy_score(y3_test,y3pred1_new)\n",
        "     )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.792 0.774 0.808 0.798\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DZqPr1rxSTKQ"
      },
      "source": [
        "Reduced search range and modified min sample per leaf maintain or slightly decrease the accuracy on the test data.\n",
        "Among them, still average pooling gives the best accuracy comparable to the one without dimension reduction."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UEQphaoUSTKQ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MrF9mxgDSTKQ"
      },
      "source": [
        "# RF, updated search range2\n",
        "# try to reduce the max depth a little bit more to see if the accuracy on the test data improves"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "ET1LmuCaSTKQ",
        "outputId": "1d604b4d-80ee-43e2-eecf-5b234bab86e1"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf01_new1 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,250,50).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search01_new1 = RandomizedSearchCV(clf01_new1, param1_new1, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search01_new1.fit(x0_train, y0_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF0_new1 = search01_new1.best_params_\n",
        "print(RF0_new1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  8.0min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 301, 'min_samples_leaf': 7, 'max_depth': 52}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_rV8fCxISTKR",
        "outputId": "ec694215-b7c8-49ed-bc07-33dc144fa89c"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf01_new1_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF0_new1[\"n_estimators\"],\n",
        "                              max_depth = RF0_new1[\"max_depth\"],\n",
        "                              min_samples_leaf = RF0_new1[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf01_new1_opt.fit(x0_train, y0_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=52, min_samples_leaf=7, n_estimators=301,\n",
              "                       n_jobs=-1, random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Po3hoRMSTKR",
        "outputId": "868c369d-fd14-434d-ab36-23907028fa69"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf11_new1 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,250,50).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search11_new1 = RandomizedSearchCV(clf11_new1, param1_new1, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search11_new1.fit(x1_train, y1_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF1_new1 = search11_new1.best_params_\n",
        "print(RF1_new1)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  3.7min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 251, 'min_samples_leaf': 7, 'max_depth': 202}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b9YjYrq2STKR",
        "outputId": "2861d9fe-803f-4f6e-f817-72d6bfa0b8ec"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf11_new1_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF1_new1[\"n_estimators\"],\n",
        "                              max_depth = RF1_new1[\"max_depth\"],\n",
        "                              min_samples_leaf = RF1_new1[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf11_new1_opt.fit(x1_train, y1_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=202, min_samples_leaf=7, n_estimators=251,\n",
              "                       n_jobs=-1, random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "ixi3WJGlSTKR",
        "outputId": "037a041a-ba99-471e-99a8-5882c1eb35fe"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf21_new1 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,250,50).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search21_new1 = RandomizedSearchCV(clf21_new1, param1_new1, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search21_new1.fit(x2_train, y2_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF2_new1 = search21_new1.best_params_\n",
        "print(RF2_new1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  4.3min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 51, 'min_samples_leaf': 1, 'max_depth': 202}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VcmsmYyFSTKS",
        "outputId": "808a0937-c27d-407a-a44c-13f3462e0540"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf21_new1_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF2_new1[\"n_estimators\"],\n",
        "                              max_depth = RF2_new1[\"max_depth\"],\n",
        "                              min_samples_leaf = RF2_new1[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf21_new1_opt.fit(x2_train, y2_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=202, n_estimators=51, n_jobs=-1,\n",
              "                       random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "63i_YSZySTKS",
        "outputId": "09a2eb49-1f76-4483-912f-3cdce79ed04f"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "clf31_new1 = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36)\n",
        "param1_new1 = {\"n_estimators\": np.arange(1,500,50).tolist(),\n",
        "          \"max_depth\":np.arange(2,250,50).tolist(),        # reduced\n",
        "          \"min_samples_leaf\":np.arange(1,50,6).tolist(),    # adjusted\n",
        "          }\n",
        "\n",
        "search31_new1 = RandomizedSearchCV(clf31_new1, param1_new1, cv = 4,\n",
        "                            n_iter=100, verbose=1)\n",
        "\n",
        "search31_new1.fit(x3_train, y3_train)\n",
        "\n",
        "## Save the parameters \n",
        "RF3_new1 = search31_new1.best_params_\n",
        "print(RF3_new1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 4 folds for each of 100 candidates, totalling 400 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done 400 out of 400 | elapsed:  4.8min finished\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'n_estimators': 251, 'min_samples_leaf': 7, 'max_depth': 202}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9gJWFP0bSTKS",
        "outputId": "17069455-7f33-4809-b54c-300490f02184"
      },
      "source": [
        "# Create the optimal classifier\n",
        "clf31_new1_opt = RandomForestClassifier(criterion='gini',\n",
        "                              n_jobs=-1,\n",
        "                              random_state = 36,\n",
        "                              n_estimators = RF3_new1[\"n_estimators\"],\n",
        "                              max_depth = RF3_new1[\"max_depth\"],\n",
        "                              min_samples_leaf = RF3_new1[\"min_samples_leaf\"]\n",
        "                              )\n",
        "\n",
        "# Predict on test data\n",
        "clf31_new1_opt.fit(x3_train, y3_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(max_depth=202, min_samples_leaf=7, n_estimators=251,\n",
              "                       n_jobs=-1, random_state=36)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tnjntf4dSTKT"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mtGv4cFaSTKT"
      },
      "source": [
        "y0pred1_new1 = clf01_new1_opt.predict(x0_test)\n",
        "y1pred1_new1 = clf11_new1_opt.predict(x1_test)\n",
        "y2pred1_new1 = clf21_new1_opt.predict(x2_test)\n",
        "y3pred1_new1 = clf31_new1_opt.predict(x3_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7vs3BwKPSTKT",
        "outputId": "9c0b2d96-1f5f-4c32-b728-f95e4dae9442"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix\n",
        "print(accuracy_score(y0_test,y0pred1_new1),\n",
        "      accuracy_score(y1_test,y1pred1_new1),\n",
        "      accuracy_score(y2_test,y2pred1_new1),\n",
        "      accuracy_score(y3_test,y3pred1_new1)\n",
        "     )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.792 0.774 0.792 0.806\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f1yX-NctSTKT"
      },
      "source": [
        "Reduced search range actually decrease the accuracy on the test data.\n",
        "Among them, still average pooling gives the best accuracy comparable to the one without dimension reduction.\n",
        "Even if the dimension strategy of averaging 3 channels yield accuracy close to that of average pooling, considering efficiency, average pooling is better because it has fewer dimensions (48*48*2) than the former do (96*96)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kBR1K51BSTKT"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E9dS9VTjSTKU"
      },
      "source": [
        "Compare RF with average pooling and 3 different search ranges in other metrics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gKqzhJBLSTKU",
        "outputId": "a4b8bcb1-713a-4d93-b2d8-2f8ed6b4be96"
      },
      "source": [
        "# RF, previous search range, average pooling\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix,f1_score\n",
        "\n",
        "print(precision_score(y2_test,y2pred1))\n",
        "print(recall_score(y2_test,y2pred1))\n",
        "print(f1_score(y2_test,y2pred1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.7473309608540926\n",
            "0.84\n",
            "0.7909604519774012\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_cWLW68CSTKU",
        "outputId": "bfb483c4-7664-4fd3-fc7e-f07ac44bf1bc"
      },
      "source": [
        "# RF, updated search range1, average pooling\n",
        "print(precision_score(y2_test,y2pred1_new))\n",
        "print(recall_score(y2_test,y2pred1_new))\n",
        "print(f1_score(y2_test,y2pred1_new))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.7730496453900709\n",
            "0.872\n",
            "0.8195488721804511\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IXuQn_iASTKU",
        "outputId": "426d7151-9581-4670-87c4-218e90cde37d"
      },
      "source": [
        "# RF, updated search range2, average pooling\n",
        "print(precision_score(y2_test,y2pred1_new1))\n",
        "print(recall_score(y2_test,y2pred1_new1))\n",
        "print(f1_score(y2_test,y2pred1_new1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.7570422535211268\n",
            "0.86\n",
            "0.8052434456928839\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EEr1zC8rSTKU"
      },
      "source": [
        "Because RF with search range 1 yields comparable accuaracy to RF with previous search range, and outruns in other metrics, it's reasonable to proceed with the best hyperparameters found in the search range 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0L4Lu8xKSTKV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wBUpMF5STKV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I1KSf-gbSTKV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NXjlolmtSTKV"
      },
      "source": [
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}