▶smartFactoryFINAL_teamShare (4).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 팀 스마일C 코드 제출\n",
        "* 팀원: 정우섭, 김유민, 김유진, 장동언, 황정묵\n",
        "* PRIVATE SCORE: 0.65887 \n",
        "* PRIVATE RANKING: 36"
      ],
      "metadata": {
        "id": "ZJBm2amd3Lb5"
      },
      "id": "ZJBm2amd3Lb5"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 개발 환경\n",
        "* OS : \n",
        "* 라이브러리 버전 : "
      ],
      "metadata": {
        "id": "CwuGPDTVMXHe"
      },
      "id": "CwuGPDTVMXHe"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 0.Data Load"
      ],
      "metadata": {
        "id": "QIfodgpc3HP6"
      },
      "id": "QIfodgpc3HP6"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6ab709fe",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6ab709fe",
        "outputId": "376336a1-1e38-402d-bcff-a2c6c94c5f41"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting catboost\n",
            "  Downloading catboost-1.1.1-cp38-none-manylinux1_x86_64.whl (76.6 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.6/76.6 MB\u001b[0m \u001b[31m10.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.16.0 in /usr/local/lib/python3.8/dist-packages (from catboost) (1.22.4)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (from catboost) (3.5.3)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.8/dist-packages (from catboost) (1.10.1)\n",
            "Requirement already satisfied: pandas>=0.24.0 in /usr/local/lib/python3.8/dist-packages (from catboost) (1.3.5)\n",
            "Requirement already satisfied: plotly in /usr/local/lib/python3.8/dist-packages (from catboost) (5.5.0)\n",
            "Requirement already satisfied: graphviz in /usr/local/lib/python3.8/dist-packages (from catboost) (0.10.1)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.8/dist-packages (from catboost) (1.15.0)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.8/dist-packages (from pandas>=0.24.0->catboost) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas>=0.24.0->catboost) (2022.7.1)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->catboost) (23.0)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib->catboost) (0.11.0)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->catboost) (4.38.0)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib->catboost) (8.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->catboost) (3.0.9)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->catboost) (1.4.4)\n",
            "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from plotly->catboost) (8.2.2)\n",
            "Installing collected packages: catboost\n",
            "Successfully installed catboost-1.1.1\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: lightgbm in /usr/local/lib/python3.8/dist-packages (2.2.3)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.8/dist-packages (from lightgbm) (1.2.1)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.8/dist-packages (from lightgbm) (1.10.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from lightgbm) (1.22.4)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from scikit-learn->lightgbm) (1.2.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from scikit-learn->lightgbm) (3.1.0)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting optuna\n",
            "  Downloading optuna-3.1.0-py3-none-any.whl (365 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m365.3/365.3 KB\u001b[0m \u001b[31m28.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting cmaes>=0.9.1\n",
            "  Downloading cmaes-0.9.1-py3-none-any.whl (21 kB)\n",
            "Collecting colorlog\n",
            "  Downloading colorlog-6.7.0-py2.py3-none-any.whl (11 kB)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from optuna) (23.0)\n",
            "Collecting alembic>=1.5.0\n",
            "  Downloading alembic-1.9.4-py3-none-any.whl (210 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m210.5/210.5 KB\u001b[0m \u001b[31m20.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: tqdm in /usr/local/lib/python3.8/dist-packages (from optuna) (4.64.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from optuna) (1.22.4)\n",
            "Requirement already satisfied: sqlalchemy>=1.3.0 in /usr/local/lib/python3.8/dist-packages (from optuna) (1.4.46)\n",
            "Requirement already satisfied: PyYAML in /usr/local/lib/python3.8/dist-packages (from optuna) (6.0)\n",
            "Collecting Mako\n",
            "  Downloading Mako-1.2.4-py3-none-any.whl (78 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.7/78.7 KB\u001b[0m \u001b[31m10.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: importlib-metadata in /usr/local/lib/python3.8/dist-packages (from alembic>=1.5.0->optuna) (6.0.0)\n",
            "Requirement already satisfied: importlib-resources in /usr/local/lib/python3.8/dist-packages (from alembic>=1.5.0->optuna) (5.12.0)\n",
            "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.8/dist-packages (from sqlalchemy>=1.3.0->optuna) (2.0.2)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.8/dist-packages (from importlib-metadata->alembic>=1.5.0->optuna) (3.15.0)\n",
            "Requirement already satisfied: MarkupSafe>=0.9.2 in /usr/local/lib/python3.8/dist-packages (from Mako->alembic>=1.5.0->optuna) (2.1.2)\n",
            "Installing collected packages: Mako, colorlog, cmaes, alembic, optuna\n",
            "Successfully installed Mako-1.2.4 alembic-1.9.4 cmaes-0.9.1 colorlog-6.7.0 optuna-3.1.0\n"
          ]
        }
      ],
      "source": [
        "!pip install catboost\n",
        "!pip install lightgbm\n",
        "!pip install optuna   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "94682a80",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94682a80",
        "outputId": "29cf1634-c74c-45ed-ab81-defbc7b69c9a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import random\n",
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt   \n",
        "import seaborn as sns \n",
        "\n",
        "# model evaluation, preprocessing \n",
        "import sklearn\n",
        "from sklearn import preprocessing, metrics\n",
        "from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler, MinMaxScaler\n",
        "from sklearn.model_selection import train_test_split, KFold, cross_validate\n",
        "from sklearn.metrics import accuracy_score, classification_report, f1_score, roc_auc_score, log_loss\n",
        "\n",
        "# sequential model modeling \n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras import regularizers\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense,Dropout, Activation\n",
        "from keras import backend as K \n",
        "from keras import regularizers\n",
        "from keras.layers import Dense,Dropout, Activation, BatchNormalization, Conv2D, Flatten  \n",
        "from keras import optimizers, metrics, callbacks\n",
        "from keras.backend import clear_session\n",
        "\n",
        "# optuna Hyper-params tuning\n",
        "import optuna\n",
        "from optuna import Trial\n",
        "from optuna.samplers import TPESampler\n",
        "from optuna.visualization import plot_optimization_history, plot_param_importances, plot_parallel_coordinate, plot_contour\n",
        "\n",
        "# ML classification models \n",
        "from lightgbm import LGBMClassifier\n",
        "from catboost import CatBoostClassifier\n",
        "from sklearn.ensemble import BaggingClassifier, GradientBoostingClassifier, RandomForestClassifier\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.linear_model import RidgeClassifierCV\n",
        "from xgboost import XGBClassifier\n",
        "\n",
        "# Google Drive mount\n",
        "from google.colab import drive \n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# seed fixing for reproduction \n",
        "import torch \n",
        "import random as rn \n",
        "\n",
        "def seed_everything(seed):\n",
        "    random.seed(seed)\n",
        "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
        "    np.random.seed(seed)\n",
        "seed_everything(37) # Seed 고정\n",
        "seed_num=37\n",
        "\n",
        "def seed_everything(seed):\n",
        "    random.seed(seed)\n",
        "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
        "    np.random.seed(seed)\n",
        "    torch.manual_seed(seed)\n",
        "    torch.cuda.manual_seed(seed)  # type: ignore\n",
        "    torch.backends.cudnn.deterministic = True  # type: ignore\n",
        "    torch.backends.cudnn.benchmark = True  # type: ignore\n",
        "seed_everything(37)\n",
        "seed_num=37\n",
        "seed=37\n",
        "\n",
        "np.random.seed(seed_num)\n",
        "rn.seed(seed_num) \n",
        "tf.random.set_seed(seed_num)\n",
        "session_conf = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)\n",
        "sess = tf.compat.v1.Session(config=session_conf)\n",
        "K.set_session(sess)\n",
        "\n",
        "class config:   \n",
        "    seed = 37  \n",
        "    device = \"cuda:0\"            \n",
        "\n",
        "def seed_everything(seed: int = 37):\n",
        "    random.seed(seed)\n",
        "    np.random.seed(seed)\n",
        "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
        "    tf.random.set_seed(seed)\n",
        "seed_everything(config.seed)\n",
        "tf.random.set_seed(37) # tensorflow global seed \n",
        "print(config.seed)     "
      ],
      "metadata": {
        "id": "0AdADLxT1DoQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dfcc6a42-f2f2-47b3-e91d-ad5e3f3a1715"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "37\n"
          ]
        }
      ],
      "id": "0AdADLxT1DoQ"
    },
    {
      "cell_type": "code",
      "source": [
        "train_df = pd.read_csv('/content/drive/MyDrive/train.csv')\n",
        "test_df = pd.read_csv('/content/drive/MyDrive/test.csv')\n",
        "submit = pd.read_csv('/content/drive/MyDrive/sample_submission.csv')\n",
        "\n",
        "train_x = train_df.drop(columns=['PRODUCT_ID', 'TIMESTAMP', 'Y_Class','Y_Quality'])\n",
        "train_y = train_df['Y_Class']\n",
        "test_x = test_df.drop(columns=['PRODUCT_ID', 'TIMESTAMP'])   "
      ],
      "metadata": {
        "id": "lQROx2fcxIW7"
      },
      "execution_count": null,
      "outputs": [],
      "id": "lQROx2fcxIW7"
    },
    {
      "cell_type": "markdown",
      "id": "wqkW_3EbQxj1",
      "metadata": {
        "id": "wqkW_3EbQxj1"
      },
      "source": [
        "# 1.Data & Features"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.1 EDA"
      ],
      "metadata": {
        "id": "ZK3O2Kd24yP_"
      },
      "id": "ZK3O2Kd24yP_"
    },
    {
      "cell_type": "code",
      "source": [
        "# random 20 features list (모두 NaN인 컬럼 제외하고, 랜덤 20개 feature의 상관관계 히트맵)\n",
        "Xs = train_df.iloc[:,4:].columns\n",
        "null_count = train_df.isnull().sum().to_dict()\n",
        "cols = pd.DataFrame({i for i in null_count if null_count[i]<250 and i in Xs})\n",
        "cols_name = list(cols[0])  # not_all_NAN features name in list \n",
        "\n",
        "import random\n",
        "a = ['Y_Quality']\n",
        "for i in range(20):\n",
        "    num = random.randint(1,2875)\n",
        "    a.append(cols_name[i])\n",
        "\n",
        "# heatmap: `random X features` and `Y_Quality` correlation\n",
        "corr = train_df[a].corr()  # correlation matrix\n",
        "fig, ax = plt.subplots(figsize=(15,10))\n",
        "sns.heatmap(corr, annot=True, fmt='.2f', cmap='Blues', linewidths=2);"
      ],
      "metadata": {
        "id": "E1vfXTKcK9Dt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 632
        },
        "outputId": "4b34c631-ff1e-4488-b45f-4030db5dae6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x720 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "id": "E1vfXTKcK9Dt"
    },
    {
      "cell_type": "code",
      "source": [
        "# feature 중요도\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "qual_col = ['LINE', 'PRODUCT_CODE']\n",
        "for i in qual_col:\n",
        "    le = LabelEncoder()\n",
        "    le = le.fit(train_x[i])\n",
        "    train_x[i] = le.transform(train_x[i])\n",
        "    for label in np.unique(test_x[i]):\n",
        "        if label not in le.classes_:\n",
        "            le.classes_ = np.append(le.classes_, label)\n",
        "    test_x[i] = le.transform(test_x[i])\n",
        "\n",
        "train_x = train_x.fillna(0)\n",
        "test_x = test_x.fillna(0)\n",
        "X_train, X_test, y_train, y_test=train_test_split(train_x,train_y,test_size=0.3,random_state=seed_num)\n",
        "\n",
        "%matplotlib inline\n",
        "RF = RandomForestRegressor(random_state=0, max_depth=5, min_samples_leaf=8, min_samples_split=8,n_estimators=200)\n",
        "RF.fit(X_train, y_train)\n",
        "ftr_importances_values = RF.feature_importances_\n",
        "ftr_importances = pd.Series(ftr_importances_values, index=X_train.columns)\n",
        "ftr_top = ftr_importances.sort_values(ascending=False)[:20]\n",
        " \n",
        "plt.figure(figsize=(10, 10))\n",
        "sns.barplot(x=ftr_top, y=ftr_top.index)\n",
        "plt.show()      "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 592
        },
        "id": "lLsOtCgTSvRA",
        "outputId": "30753655-fa00-44b3-91c7-f9313c8ea62f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "id": "lLsOtCgTSvRA"
    },
    {
      "cell_type": "code",
      "source": [
        "ftr_top = pd.DataFrame(ftr_top)\n",
        "ftr_top_idx = list(ftr_top.index)\n",
        "x=train_x.loc[:,ftr_top_idx]\n",
        "y=train_y\n",
        "\n",
        "model = GradientBoostingClassifier(random_state=37).fit(X_train, y_train)\n",
        "print('Done.')\n",
        "y_pred = model.predict(X_test)\n",
        "test_x=test_x.loc[:,ftr_top_idx]\n",
        "preds = model.predict(test_x)\n",
        "sns.countplot(x=preds);      "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "cAqWZJ7NSva4",
        "outputId": "ea4c336d-235e-4247-c7d4-c7054c9541f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Done.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "id": "cAqWZJ7NSva4"
    },
    {
      "cell_type": "code",
      "source": [
        "# feature distribution \n",
        "train_x.describe()    "
      ],
      "metadata": {
        "id": "GdugZkQrSvJS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 394
        },
        "outputId": "233242ad-180e-4fce-aef9-e9724169ce2d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "             LINE  PRODUCT_CODE         X_1         X_2    X_3         X_4  \\\n",
              "count  598.000000    598.000000  598.000000  598.000000  598.0  598.000000   \n",
              "mean     3.214047      1.157191    1.406355    0.544265    0.0    0.583612   \n",
              "std      1.703579      0.983298    4.655332    0.461135    0.0    0.493372   \n",
              "min      0.000000      0.000000    0.000000    0.000000    0.0    0.000000   \n",
              "25%      2.000000      0.000000    0.000000    0.000000    0.0    0.000000   \n",
              "50%      4.000000      2.000000    2.000000    0.892157    0.0    1.000000   \n",
              "75%      5.000000      2.000000    2.000000    0.931373    0.0    1.000000   \n",
              "max      5.000000      2.000000  103.000000    1.000000    0.0    1.000000   \n",
              "\n",
              "              X_5    X_6         X_7         X_8  ...      X_2866      X_2867  \\\n",
              "count  598.000000  598.0  598.000000  598.000000  ...  598.000000  598.000000   \n",
              "mean     0.551383    0.0    0.459381    0.533141  ...    0.141039    0.130564   \n",
              "std      0.467361    0.0    0.392067    0.450953  ...    0.318552    0.295577   \n",
              "min      0.000000    0.0    0.000000    0.000000  ...    0.000000    0.000000   \n",
              "25%      0.000000    0.0    0.000000    0.000000  ...    0.000000    0.000000   \n",
              "50%      0.909091    0.0    0.725806    0.909091  ...    0.000000    0.000000   \n",
              "75%      0.909091    0.0    0.806452    0.909091  ...    0.000000    0.000000   \n",
              "max      1.000000    0.0    1.000000    1.000000  ...    1.000000    1.000000   \n",
              "\n",
              "           X_2868      X_2869      X_2870      X_2871  X_2872  X_2873  X_2874  \\\n",
              "count  598.000000  598.000000  598.000000  598.000000   598.0   598.0   598.0   \n",
              "mean     0.137318    0.144148    0.139755    0.165552     0.0     0.0     0.0   \n",
              "std      0.310467    0.327595    0.312991    0.371989     0.0     0.0     0.0   \n",
              "min      0.000000    0.000000    0.000000    0.000000     0.0     0.0     0.0   \n",
              "25%      0.000000    0.000000    0.000000    0.000000     0.0     0.0     0.0   \n",
              "50%      0.000000    0.000000    0.000000    0.000000     0.0     0.0     0.0   \n",
              "75%      0.000000    0.000000    0.000000    0.000000     0.0     0.0     0.0   \n",
              "max      1.000000    1.000000    1.000000    1.000000     0.0     0.0     0.0   \n",
              "\n",
              "       X_2875  \n",
              "count   598.0  \n",
              "mean      0.0  \n",
              "std       0.0  \n",
              "min       0.0  \n",
              "25%       0.0  \n",
              "50%       0.0  \n",
              "75%       0.0  \n",
              "max       0.0  \n",
              "\n",
              "[8 rows x 2877 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-3f6e4f9b-c31c-43fe-8317-2818b5de14e5\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>LINE</th>\n",
              "      <th>PRODUCT_CODE</th>\n",
              "      <th>X_1</th>\n",
              "      <th>X_2</th>\n",
              "      <th>X_3</th>\n",
              "      <th>X_4</th>\n",
              "      <th>X_5</th>\n",
              "      <th>X_6</th>\n",
              "      <th>X_7</th>\n",
              "      <th>X_8</th>\n",
              "      <th>...</th>\n",
              "      <th>X_2866</th>\n",
              "      <th>X_2867</th>\n",
              "      <th>X_2868</th>\n",
              "      <th>X_2869</th>\n",
              "      <th>X_2870</th>\n",
              "      <th>X_2871</th>\n",
              "      <th>X_2872</th>\n",
              "      <th>X_2873</th>\n",
              "      <th>X_2874</th>\n",
              "      <th>X_2875</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.0</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.0</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>...</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.000000</td>\n",
              "      <td>598.0</td>\n",
              "      <td>598.0</td>\n",
              "      <td>598.0</td>\n",
              "      <td>598.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>3.214047</td>\n",
              "      <td>1.157191</td>\n",
              "      <td>1.406355</td>\n",
              "      <td>0.544265</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.583612</td>\n",
              "      <td>0.551383</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.459381</td>\n",
              "      <td>0.533141</td>\n",
              "      <td>...</td>\n",
              "      <td>0.141039</td>\n",
              "      <td>0.130564</td>\n",
              "      <td>0.137318</td>\n",
              "      <td>0.144148</td>\n",
              "      <td>0.139755</td>\n",
              "      <td>0.165552</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>1.703579</td>\n",
              "      <td>0.983298</td>\n",
              "      <td>4.655332</td>\n",
              "      <td>0.461135</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.493372</td>\n",
              "      <td>0.467361</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.392067</td>\n",
              "      <td>0.450953</td>\n",
              "      <td>...</td>\n",
              "      <td>0.318552</td>\n",
              "      <td>0.295577</td>\n",
              "      <td>0.310467</td>\n",
              "      <td>0.327595</td>\n",
              "      <td>0.312991</td>\n",
              "      <td>0.371989</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>...</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>2.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>...</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>4.000000</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>0.892157</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.909091</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.725806</td>\n",
              "      <td>0.909091</td>\n",
              "      <td>...</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>5.000000</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>0.931373</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.909091</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.806452</td>\n",
              "      <td>0.909091</td>\n",
              "      <td>...</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>5.000000</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>103.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>...</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>8 rows × 2877 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3f6e4f9b-c31c-43fe-8317-2818b5de14e5')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-3f6e4f9b-c31c-43fe-8317-2818b5de14e5 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-3f6e4f9b-c31c-43fe-8317-2818b5de14e5');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ],
      "id": "GdugZkQrSvJS"
    },
    {
      "cell_type": "code",
      "source": [
        "# feature histogram with KDE (밀도그래프) \n",
        "# 임의의 feature에 대한 histplot + 밀도 곡선 출력\n",
        "num = random.randint(1,2875)\n",
        "sns.histplot(train_x[f'X_{num}'], kde=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "fceMKvgyg2Kg",
        "outputId": "7af724ba-e6cd-47be-d0ac-4d921e97d9fb"
      },
      "id": "fceMKvgyg2Kg",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<AxesSubplot:xlabel='X_1712', ylabel='Count'>"
            ]
          },
          "metadata": {},
          "execution_count": 117
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualize random 20 features distribution \n",
        "# imbalanced feature distribution (NO Gaussian distribution shape) --> MinMaxscaler\n",
        "fig, axes = plt.subplots(5,4,figsize=(16,12))\n",
        "ax= axes.flatten()\n",
        "\n",
        "for i in range(20): \n",
        "    num = random.randint(1,2875)\n",
        "    ax[i].hist(train_x[f'X_{num}']);    "
      ],
      "metadata": {
        "id": "xskVkfufSvDg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 700
        },
        "outputId": "11175f8c-e10f-4c58-fbbc-8a3a8d2db3ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1152x864 with 20 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "id": "xskVkfufSvDg"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.2 Preprocessing\n",
        "1. Label Encoding: categorical values `LINE`, `PRODUCT_CODE`\n",
        "2. Missing values: fillna(0) \n",
        "3. scaling: StandardScaler "
      ],
      "metadata": {
        "id": "xuPOUxQ7Su9m"
      },
      "id": "xuPOUxQ7Su9m"
    },
    {
      "cell_type": "code",
      "source": [
        "train_df = pd.read_csv('/content/drive/MyDrive/train.csv')\n",
        "test_df = pd.read_csv('/content/drive/MyDrive/test.csv')\n",
        "submit = pd.read_csv('/content/drive/MyDrive/sample_submission.csv')\n",
        "\n",
        "train_x = train_df.drop(columns=['PRODUCT_ID', 'TIMESTAMP', 'Y_Class','Y_Quality'])\n",
        "train_y = train_df['Y_Class']\n",
        "test_x = test_df.drop(columns=['PRODUCT_ID', 'TIMESTAMP'])   "
      ],
      "metadata": {
        "id": "kZ1PM_Zrtzph"
      },
      "id": "kZ1PM_Zrtzph",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1) qualitative to quantitative\n",
        "qual_col = ['LINE', 'PRODUCT_CODE']\n",
        "for i in qual_col:\n",
        "    le = LabelEncoder()    # one-hot encoding (X): get_dummies(test_df) is not allowed (data leakage)   \n",
        "    le = le.fit(train_x[i])\n",
        "    train_x[i] = le.transform(train_x[i])\n",
        "    for label in np.unique(test_x[i]): \n",
        "        if label not in le.classes_: \n",
        "            le.classes_ = np.append(le.classes_, label)\n",
        "    test_x[i] = le.transform(test_x[i]) \n"
      ],
      "metadata": {
        "id": "3AbGp2rBuxuW"
      },
      "id": "3AbGp2rBuxuW",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 2) Missing Values \n",
        "train_x = train_x.fillna(0)\n",
        "test_x = test_x.fillna(0)"
      ],
      "metadata": {
        "id": "GZ72F04guy3o"
      },
      "id": "GZ72F04guy3o",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c66d3bf4"
      },
      "outputs": [],
      "source": [
        "# 3) MinMaxscaling: only `X_???` values (continuous)\n",
        "Xs = train_x.select_dtypes(include=float).iloc[:,1:].columns.tolist()\n",
        "scaler = MinMaxScaler().fit(train_x.loc[:, Xs])\n",
        "train_x.loc[:, Xs] = scaler.transform(train_x.loc[:, Xs])\n",
        "test_x.loc[:, Xs] = scaler.transform(test_x.loc[:, Xs])\n",
        "\n",
        "X_train, X_test, y_train, y_test=train_test_split(train_x,train_y,test_size=0.3,random_state=seed_num)"
      ],
      "id": "c66d3bf4"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2.Modeling"
      ],
      "metadata": {
        "id": "hIoaatyGu9Zq"
      },
      "id": "hIoaatyGu9Zq"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.1 ML models\n",
        "- 여러 Machine Learning Classifier 모델들의 test set Accuracy score 도출 \n",
        "    - Ensemble에서 각 모델의 weight(가중치) 정하기 위한 근거로 사용하기 위함\n",
        "1. RandomForestClassifier\n",
        "2. GradientboostingClassiifer\n",
        "3. XGBClassifier\n",
        "4. LGBMClassifier\n",
        "5. CatboostClassifier\n",
        "6. RidgeClassifier\n",
        "7. BaggingClassifier"
      ],
      "metadata": {
        "id": "GQGMvepMJy87"
      },
      "id": "GQGMvepMJy87"
    },
    {
      "cell_type": "code",
      "source": [
        "from catboost import CatBoostClassifier\n",
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "from sklearn.ensemble import StackingClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "models = [\n",
        "    RandomForestClassifier(random_state=seed_num), \n",
        "    GradientBoostingClassifier(random_state=seed_num),      \n",
        "    XGBClassifier(random_state=seed_num),\n",
        "    LGBMClassifier(objective='multiclass', random_state=seed_num),\n",
        "    CatBoostClassifier(objective='MultiClass',\n",
        "                                   task_type='GPU',\n",
        "                                   one_hot_max_size=2, random_seed=seed_num,\n",
        "                                   iterations=4000, verbose=False,\n",
        "                                   learning_rate=0.05\n",
        "                                   ),\n",
        "    RidgeClassifierCV(),  # RidgeClassifier: no seed setting argument  \n",
        "    BaggingClassifier(random_state=seed_num)]"
      ],
      "metadata": {
        "id": "m61QOAHA8lvG"
      },
      "execution_count": null,
      "outputs": [],
      "id": "m61QOAHA8lvG"
    },
    {
      "cell_type": "code",
      "source": [
        "# find weights for each model \n",
        "model_list = ['RF', 'GBC', 'XGB', 'LGBM', 'Catboost', 'Ridge', 'Bagging']\n",
        "i=0\n",
        "model_acc = {}\n",
        "\n",
        "for model in models:  \n",
        "    if i == 4: \n",
        "        preds = model.fit(X_train, y_train).predict(X_test)\n",
        "        preds = preds.reshape(1,180)\n",
        "        preds = list(preds[0])\n",
        "    else: \n",
        "        preds = model.fit(X_train, y_train).predict(X_test)\n",
        "\n",
        "    globals()[f'preds_{model_list[i]}'] = preds   # set variable name for each model prediction results  \n",
        "  \n",
        "    score = sklearn.metrics.accuracy_score(y_test, preds)\n",
        "    model_acc[model_list[i]] = score\n",
        "    i += 1   \n",
        "\n",
        "print(model_acc)   "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "304d9609-a64a-4b6b-f483-12d7a0630313",
        "id": "qfV3aJaS8lvI"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'RF': 0.7888888888888889, 'GBC': 0.8111111111111111, 'XGB': 0.7722222222222223, 'LGBM': 0.7888888888888889, 'Catboost': 0.8166666666666667, 'Ridge': 0.7611111111111111, 'Bagging': 0.75}\n"
          ]
        }
      ],
      "id": "qfV3aJaS8lvI"
    },
    {
      "cell_type": "code",
      "source": [
        "# ML models accuracy comparison plot \n",
        "model_name = list(model_acc.keys())\n",
        "model_acc = list(model_acc.values())\n",
        "acc_dic = {'model': model_name, 'acc': model_acc}\n",
        "acc_df = pd.DataFrame(acc_dic)\n",
        "acc_df = acc_df.set_index('model')\n",
        "\n",
        "acc_df.plot(kind='barh', figsize=(14,8),\n",
        "            title='Model Comparison - accuracy score');"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "PihsvBmKhfOd",
        "outputId": "621a6f76-39ab-46df-a397-94057d4a7cee"
      },
      "id": "PihsvBmKhfOd",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1008x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.2 sequential MLP "
      ],
      "metadata": {
        "id": "_KIk0bpq4IHj"
      },
      "id": "_KIk0bpq4IHj"
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn \n",
        "import torch.nn.functional as F \n",
        "\n",
        "class MultilayerPerceptron(nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim1, hidden_dim2, hidden_dim3, output_dim):\n",
        "        \"\"\"\n",
        "        parameters: \n",
        "            input_dim (int): 입력 벡터 크기\n",
        "            hidden_dim1 (int): 첫 번째 Linear 층의 출력 크기\n",
        "            hidden_dim2 (int): 두 번째 Linear 층의 출력 크기 \n",
        "            output_dim (int): 세 번째 Linear 층의 출력 크기 \n",
        "        \"\"\"\n",
        "        super(MultilayerPerceptron, self).__init__()\n",
        "        self.fc1 = nn.Linear(input_dim, hidden_dim1)\n",
        "        self.fc2 = nn.Linear(hidden_dim1, hidden_dim2)\n",
        "        self.fc3 = nn.Linear(hidden_dim2, hidden_dim3)\n",
        "        self.fc4 = nn.Linear(hidden_dim3, output_dim)\n",
        "\n",
        "    def forward(self, x_in, apply_softmax=False):\n",
        "        \"\"\"\n",
        "        MLP의 정방향 계산 \n",
        "\n",
        "        parameters:\n",
        "            x_in (torch.Tensor): 입력 데이터 텐서\n",
        "                x_in.shape는 (batch, input_dim)\n",
        "            apply_softmax (multiclasses): softmax activation function \n",
        "        return: \n",
        "            result Tensor\n",
        "            tesnor.shape: (batch, output_dim)\n",
        "        \"\"\"\n",
        "        intermediate1 = F.relu(self.fc1(x_in))   # activation function\n",
        "        intermediate2 = F.relu(self.fc2(intermediate1))   # activation function\n",
        "        intermediate3 = F.relu(self.fc3(intermediate2))   # activation function\n",
        "        output = self.fc4(intermediate3)    \n",
        "\n",
        "\n",
        "        if apply_softmax: \n",
        "            output = F.softmax(output, dim=1)   # output layer: softmax activation function\n",
        "        return output "
      ],
      "metadata": {
        "id": "8wlnknVPi0NX"
      },
      "id": "8wlnknVPi0NX",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def describe(x): \n",
        "    print(f'Type: {x.type()}')\n",
        "    print(f'shape: {x.shape}')\n",
        "    # print(f'value: {x}') \n",
        "\n",
        "batch_size = 256 \n",
        "input_dim = train_x.shape[-1]\n",
        "hidden_dim1 = 1024\n",
        "hidden_dim2 = 512\n",
        "hidden_dim3 = 256\n",
        "output_dim = 3 \n",
        "\n",
        "# model design \n",
        "mlp = MultilayerPerceptron(input_dim, hidden_dim1, hidden_dim2, hidden_dim3, output_dim)\n",
        "print(mlp)\n",
        "x_input = torch.rand(batch_size, input_dim)\n",
        "y_output = mlp(x_input, apply_softmax=True)  # result: probabilities format \n",
        "a = y_output\n",
        "describe(y_output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fp5qXV02kPeC",
        "outputId": "e94a2e80-08ac-4713-854f-ab987cb017c3"
      },
      "id": "Fp5qXV02kPeC",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MultilayerPerceptron(\n",
            "  (fc1): Linear(in_features=2877, out_features=1024, bias=True)\n",
            "  (fc2): Linear(in_features=1024, out_features=512, bias=True)\n",
            "  (fc3): Linear(in_features=512, out_features=256, bias=True)\n",
            "  (fc4): Linear(in_features=256, out_features=3, bias=True)\n",
            ")\n",
            "Type: torch.FloatTensor\n",
            "shape: torch.Size([256, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FLHA36Z1iEhW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "e608dd99-322b-4bbb-d2b2-e480ed26f890"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "prediction=[]\n",
        "\n",
        "for i in a: \n",
        "    i = list(i)\n",
        "    prediction.append(i.index(max(i)))\n",
        "\n",
        "sns.countplot(x=prediction);    "
      ],
      "id": "FLHA36Z1iEhW"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k1KBJb0mIYUI"
      },
      "outputs": [],
      "source": [
        "submit = pd.read_csv('/content/drive/MyDrive/sample_submission.csv')\n",
        "submit['Y_Class'] = prediction\n",
        "\n",
        "submit.to_csv('MLP-ANN-smartFactorySubmission.csv', index=False)     "
      ],
      "id": "k1KBJb0mIYUI"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3.Params Optimization\n",
        "1. GridSearch \n",
        "2. Optuna\n",
        "3. RandomizedSearchCV"
      ],
      "metadata": {
        "id": "wE74J0d04SNc"
      },
      "id": "wE74J0d04SNc"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.1 GradientBoosting"
      ],
      "metadata": {
        "id": "Fn79mJ8rn4Jn"
      },
      "id": "Fn79mJ8rn4Jn"
    },
    {
      "cell_type": "code",
      "source": [
        "gb_class = GradientBoostingClassifier(random_state = 37) \n",
        "\n",
        "kf = KFold(n_splits=5, shuffle=True, random_state=37)\n",
        "# kf = sklearn.model_selection.StratifiedKFoldKFold(n_splits=5, shuffle=True, random_state=37)\n",
        "\n",
        "# stratified --> too many Class 0, Class 2 over-predicted \n",
        "# non-stratified --> training score 77.0 \n",
        "\n",
        "scores = cross_validate(gb_class, X_train, y_train, \n",
        "                        cv = kf, scoring = \"accuracy\", \n",
        "                        return_train_score = True, n_jobs = -1) "
      ],
      "metadata": {
        "id": "zHCvGdc9H067"
      },
      "execution_count": null,
      "outputs": [],
      "id": "zHCvGdc9H067"
    },
    {
      "cell_type": "code",
      "source": [
        "print(scores) \n",
        "scoring = scores['test_score'].mean()\n",
        "print(f'Best Accuracy: {round(scoring, 2)*100}')  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vsgw8TQrtpmQ",
        "outputId": "0da07f57-e8e8-4849-bf04-8e59c889e06c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'fit_time': array([0.40023923, 0.41092181, 0.39718652, 0.42171001, 0.30059123]), 'score_time': array([0.00424504, 0.00317955, 0.00248575, 0.00245333, 0.00216508]), 'test_score': array([0.75      , 0.71428571, 0.69047619, 0.71084337, 0.69879518]), 'train_score': array([0.90419162, 0.90718563, 0.91317365, 0.92238806, 0.90746269])}\n",
            "Best Accuracy: 71.0\n"
          ]
        }
      ],
      "id": "Vsgw8TQrtpmQ"
    },
    {
      "cell_type": "code",
      "source": [
        "def objective(trial, X, y, cv, scoring):\n",
        "  \"\"\"\n",
        "  An objective function to tune hyperparameters of Gradient Boosting Classifier.\n",
        "  Args:\n",
        "    trial: an Optuna trial\n",
        "    X: DataFrame object, features\n",
        "    y: Series object, Labels\n",
        "    cv: k folds to cross-validate\n",
        "    scoring: String, evaluation metric\n",
        "  Return:\n",
        "    Mean test accuracy\n",
        "  \"\"\"\n",
        "\n",
        "  params = {\n",
        "    \"n_estimators\": trial.suggest_int(\"n_estimators\", 100, 5000, step = 100),\n",
        "    \"learning_rate\": trial.suggest_float(\"learning_rate\", 1e-4, 0.3, log = True),\n",
        "    \"max_depth\": trial.suggest_int(\"max_depth\", 3, 9),\n",
        "    \"subsample\": trial.suggest_float(\"subsample\", 0.5, 0.9, step = 0.1),\n",
        "    \"max_features\": trial.suggest_categorical(\"max_features\", [\"auto\", \"sqrt\", \"log2\"]),\n",
        "    \"random_state\": 42,\n",
        "    }\n",
        "  # Perform cross validation\n",
        "  gb_class = GradientBoostingClassifier(**params)\n",
        "\n",
        "  # Compute scores\n",
        "  scores = cross_validate(gb_class, X, y, cv = cv, scoring = scoring, n_jobs = -1)\n",
        "  accuracy = scores[\"test_score\"].mean()\n",
        "\n",
        "  return accuracy"
      ],
      "metadata": {
        "id": "p3-9ibAcp96Q"
      },
      "execution_count": null,
      "outputs": [],
      "id": "p3-9ibAcp96Q"
    },
    {
      "cell_type": "code",
      "source": [
        "study = optuna.create_study(direction = \"maximize\")\n",
        "\n",
        "kf = sklearn.model_selection.StratifiedKFold(n_splits=5, shuffle=True, random_state=37)\n",
        "\n",
        "func = lambda trial: objective(trial, X_train, y_train, \n",
        "                               cv = kf, scoring = \"accuracy\")\n",
        "\n",
        "# %%time\n",
        "# Start optimizing with 100 trials\n",
        "study.optimize(func, n_trials = 10)\n",
        "\n",
        "print(f\"The highest accuracy reached by this study: {(study.best_value) * 100}%.\")\n",
        "print(\"Best params:\")\n",
        "for key, value in study.best_params.items():\n",
        "    print(f\"\\t{key}: {value}\")    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 800
        },
        "id": "gerDxJOEt9hE",
        "outputId": "ff277c69-8a47-4e9e-9648-41a776f2e041"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\u001b[32m[I 2023-03-01 15:15:54,013]\u001b[0m A new study created in memory with name: no-name-6926a03d-1efe-4862-95f6-591a38f14305\u001b[0m\n",
            "\u001b[33m[W 2023-03-01 15:16:03,251]\u001b[0m Trial 0 failed with parameters: {'n_estimators': 4000, 'learning_rate': 0.23414076793735694, 'max_depth': 3, 'subsample': 0.8, 'max_features': 'log2'} because of the following error: KeyboardInterrupt().\u001b[0m\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/optuna/study/_optimize.py\", line 200, in _run_trial\n",
            "    value_or_values = func(trial)\n",
            "  File \"<ipython-input-66-03e1837b5db3>\", line 5, in <lambda>\n",
            "    func = lambda trial: objective(trial, X_train, y_train,\n",
            "  File \"<ipython-input-65-8a203aa46cbb>\", line 26, in objective\n",
            "    scores = cross_validate(gb_class, X, y, cv = cv, scoring = scoring, n_jobs = -1)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\", line 267, in cross_validate\n",
            "    results = parallel(\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/joblib/parallel.py\", line 1098, in __call__\n",
            "    self.retrieve()\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/joblib/parallel.py\", line 975, in retrieve\n",
            "    self._output.extend(job.get(timeout=self.timeout))\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/joblib/_parallel_backends.py\", line 567, in wrap_future_result\n",
            "    return future.result(timeout=timeout)\n",
            "  File \"/usr/lib/python3.8/concurrent/futures/_base.py\", line 439, in result\n",
            "    self._condition.wait(timeout)\n",
            "  File \"/usr/lib/python3.8/threading.py\", line 302, in wait\n",
            "    waiter.acquire()\n",
            "KeyboardInterrupt\n",
            "\u001b[33m[W 2023-03-01 15:16:03,256]\u001b[0m Trial 0 failed with value None.\u001b[0m\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-66-03e1837b5db3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m# %%time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# Start optimizing with 100 trials\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mstudy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_trials\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"The highest accuracy reached by this study: {(study.best_value) * 100}%.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/optuna/study/study.py\u001b[0m in \u001b[0;36moptimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m    423\u001b[0m         \"\"\"\n\u001b[1;32m    424\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 425\u001b[0;31m         _optimize(\n\u001b[0m\u001b[1;32m    426\u001b[0m             \u001b[0mstudy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    427\u001b[0m             \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_optimize\u001b[0;34m(study, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m     64\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mn_jobs\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m             _optimize_sequential(\n\u001b[0m\u001b[1;32m     67\u001b[0m                 \u001b[0mstudy\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m                 \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_optimize_sequential\u001b[0;34m(study, func, n_trials, timeout, catch, callbacks, gc_after_trial, reseed_sampler_rng, time_start, progress_bar)\u001b[0m\n\u001b[1;32m    161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    162\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 163\u001b[0;31m             \u001b[0mfrozen_trial\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_run_trial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstudy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    164\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m             \u001b[0;31m# The following line mitigates memory problems that can be occurred in some\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    249\u001b[0m         \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc_err\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    250\u001b[0m     ):\n\u001b[0;32m--> 251\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mfunc_err\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    252\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mfrozen_trial\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    253\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    198\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mget_heartbeat_thread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trial_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstudy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_storage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    199\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 200\u001b[0;31m             \u001b[0mvalue_or_values\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    201\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mexceptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTrialPruned\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    202\u001b[0m             \u001b[0;31m# TODO(mamu): Handle multi-objective cases.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-66-03e1837b5db3>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mkf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel_selection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStratifiedKFold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_splits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshuffle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m37\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m func = lambda trial: objective(trial, X_train, y_train, \n\u001b[0m\u001b[1;32m      6\u001b[0m                                cv = kf, scoring = \"accuracy\")\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-65-8a203aa46cbb>\u001b[0m in \u001b[0;36mobjective\u001b[0;34m(trial, X, y, cv, scoring)\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m   \u001b[0;31m# Compute scores\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m   \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_validate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgb_class\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscoring\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscoring\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m   \u001b[0maccuracy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"test_score\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\u001b[0m in \u001b[0;36mcross_validate\u001b[0;34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, return_train_score, return_estimator, error_score)\u001b[0m\n\u001b[1;32m    265\u001b[0m     \u001b[0;31m# independent, and that it is pickle-able.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    266\u001b[0m     \u001b[0mparallel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpre_dispatch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpre_dispatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 267\u001b[0;31m     results = parallel(\n\u001b[0m\u001b[1;32m    268\u001b[0m         delayed(_fit_and_score)(\n\u001b[1;32m    269\u001b[0m             \u001b[0mclone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1096\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1097\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mretrieval_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1098\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mretrieve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1099\u001b[0m             \u001b[0;31m# Make sure that we get a last message telling us we are done\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1100\u001b[0m             \u001b[0melapsed_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_start_time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36mretrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    973\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    974\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'supports_timeout'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 975\u001b[0;31m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    976\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    977\u001b[0m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/joblib/_parallel_backends.py\u001b[0m in \u001b[0;36mwrap_future_result\u001b[0;34m(future, timeout)\u001b[0m\n\u001b[1;32m    565\u001b[0m         AsyncResults.get from multiprocessing.\"\"\"\n\u001b[1;32m    566\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 567\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfuture\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    568\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mCfTimeoutError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    569\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.8/concurrent/futures/_base.py\u001b[0m in \u001b[0;36mresult\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    437\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__get_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    438\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 439\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_condition\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    440\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    441\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_state\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mCANCELLED\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCANCELLED_AND_NOTIFIED\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.8/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    300\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m    \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    301\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 302\u001b[0;31m                 \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    303\u001b[0m                 \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    304\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "id": "gerDxJOEt9hE"
    },
    {
      "cell_type": "code",
      "source": [
        "import imblearn\n",
        "\n",
        "# Trial 8 finished with value: 0.7976750700280112 and \n",
        "# param = {'n_estimators': 2500, 'learning_rate': 0.24437231062646464, 'max_depth': 7, 'subsample': 0.9, 'max_features': 'sqrt'}\n",
        "\n",
        "# value: 0.7926050420168067 \n",
        "param= {'n_estimators': 1400, 'learning_rate': 0.007793231258605556, 'max_depth': 6, 'subsample': 0.8, 'max_features': 'sqrt'}\n",
        "\n",
        "GBC =  GradientBoostingClassifier(random_state=37, **param,                              \n",
        "                                  ).fit(train_x, train_y)\n",
        "preds = GBC.predict(test_x)\n",
        "sns.countplot(x=preds);\n",
        "preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 574
        },
        "id": "S4zxDMJ4YGGd",
        "outputId": "b3732692-a4ad-4cac-fdc6-0c5c63fcb791"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:493: FutureWarning: The feature names should match those that were passed during fit. Starting version 1.2, an error will be raised.\n",
            "Feature names seen at fit time, yet now missing:\n",
            "- LINE\n",
            "- PRODUCT_CODE\n",
            "- X_1\n",
            "- X_10\n",
            "- X_100\n",
            "- ...\n",
            "\n",
            "  warnings.warn(message, FutureWarning)\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-67-58403fe7bb6d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      9\u001b[0m GBC =  GradientBoostingClassifier(random_state=37, **param,                              \n\u001b[1;32m     10\u001b[0m                                   ).fit(train_x, train_y)\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mpreds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGBC\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_x\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcountplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpreds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0mpreds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_gb.py\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m   1357\u001b[0m             \u001b[0mThe\u001b[0m \u001b[0mpredicted\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1358\u001b[0m         \"\"\"\n\u001b[0;32m-> 1359\u001b[0;31m         \u001b[0mraw_predictions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecision_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1360\u001b[0m         \u001b[0mencoded_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss_\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_raw_prediction_to_decision\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mraw_predictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1361\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mencoded_labels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_gb.py\u001b[0m in \u001b[0;36mdecision_function\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m   1310\u001b[0m             \u001b[0marray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mshape\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mn_samples\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1311\u001b[0m         \"\"\"\n\u001b[0;32m-> 1312\u001b[0;31m         X = self._validate_data(\n\u001b[0m\u001b[1;32m   1313\u001b[0m             \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mDTYPE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"C\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maccept_sparse\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"csr\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1314\u001b[0m         )\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m    583\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    584\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mno_val_X\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mcheck_params\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ensure_2d\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 585\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_n_features\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    586\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    587\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_check_n_features\u001b[0;34m(self, X, reset)\u001b[0m\n\u001b[1;32m    398\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    399\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mn_features\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_features_in_\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 400\u001b[0;31m             raise ValueError(\n\u001b[0m\u001b[1;32m    401\u001b[0m                 \u001b[0;34mf\"X has {n_features} features, but {self.__class__.__name__} \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    402\u001b[0m                 \u001b[0;34mf\"is expecting {self.n_features_in_} features as input.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: X has 8 features, but GradientBoostingClassifier is expecting 2877 features as input."
          ]
        }
      ],
      "id": "S4zxDMJ4YGGd"
    },
    {
      "cell_type": "code",
      "source": [
        "# Best is trial 0 with value: 0.8026750700280111.\n",
        "params= {'n_estimators': 4700, 'learning_rate': 0.007080906403563565, 'max_depth': 4, 'subsample': 0.8, 'max_features': 'sqrt'}\n",
        "\n",
        "GBC =  GradientBoostingClassifier(random_state=37,\n",
        "                                  **params,                              \n",
        "                                  ).fit(train_x, train_y)\n",
        "preds = GBC.predict(test_x)\n",
        "sns.countplot(x=preds);\n",
        "preds"
      ],
      "metadata": {
        "id": "DbxqiKTwSsO2"
      },
      "execution_count": null,
      "outputs": [],
      "id": "DbxqiKTwSsO2"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HLeS0rZUO_q_"
      },
      "outputs": [],
      "source": [
        "submit = pd.read_csv('/content/drive/MyDrive/sample_submission.csv')\n",
        "submit['Y_Class'] = preds\n",
        "\n",
        "submit.to_csv('GBCoptuna-smartFactorySubmission.csv', index=False)"
      ],
      "id": "HLeS0rZUO_q_"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.2 CatBoost"
      ],
      "metadata": {
        "id": "-V0IZDs6_S3f"
      },
      "id": "-V0IZDs6_S3f"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e7f4ff7b"
      },
      "outputs": [],
      "source": [
        "def objective(trial):\n",
        "    model = CatBoostClassifier(\n",
        "        iterations=trial.suggest_int(\"iterations\", 100, 1000),\n",
        "        learning_rate=trial.suggest_float(\"learning_rate\", 1e-3, 1e-1, log=True),\n",
        "        depth=trial.suggest_int(\"depth\", 4, 10),\n",
        "        l2_leaf_reg=trial.suggest_float(\"l2_leaf_reg\", 1e-8, 100.0, log=True),\n",
        "        bootstrap_type=trial.suggest_categorical(\"bootstrap_type\", [\"Bayesian\"]),\n",
        "        random_strength=trial.suggest_float(\"random_strength\", 1e-8, 10.0, log=True),\n",
        "        bagging_temperature=trial.suggest_float(\"bagging_temperature\", 0.0, 10.0),\n",
        "        od_type=trial.suggest_categorical(\"od_type\", [\"IncToDec\", \"Iter\"]),\n",
        "        od_wait=trial.suggest_int(\"od_wait\", 10, 50),\n",
        "        verbose=False\n",
        "    )\n",
        "    model.fit(X_train, y_train)\n",
        "    y_pred = model.predict(X_test)\n",
        "    return f1_score(y_test, y_pred, average='macro')\n",
        "     \n",
        "# hyper-parameter tuning with OPTUNA  \n",
        "optuna.logging.set_verbosity(optuna.logging.WARNING)\n",
        "\n",
        "sampler = TPESampler(seed=37)\n",
        "study = optuna.create_study(study_name=\"catboost\", direction=\"maximize\", sampler=sampler)\n",
        "study.optimize(objective, n_trials=10)  "
      ],
      "id": "e7f4ff7b"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4ee90ada"
      },
      "outputs": [],
      "source": [
        "print(\"Number of trials: \", len(study.trials))\n",
        "print(\"Best trial:\")\n",
        "trial = study.best_trial\n",
        "print(\"  Value: \", trial.value)\n",
        "print(\"  Params: \",trial.params)\n",
        "\n",
        "model = CatBoostClassifier(**trial.params, verbose=False, random_state = 37)\n",
        "model.fit(X_train, y_train)\n",
        "y_pred = model.predict(X_test)\n"
      ],
      "id": "4ee90ada"
    },
    {
      "cell_type": "code",
      "source": [
        "params=  {'iterations': 857, 'learning_rate': 0.07097207730593516, 'depth': 8, 'l2_leaf_reg': 0.00012090525126196811, 'bootstrap_type': 'Bayesian', 'random_strength': 5.359110894800412, 'bagging_temperature': 0.7137022569955509, 'od_type': 'IncToDec', 'od_wait': 42}\n",
        "a = CatBoostClassifier(**params, verbose=False, random_state=37)\n",
        "a.fit(X_train, y_train)\n"
      ],
      "metadata": {
        "id": "OYWFMNT9ycd7"
      },
      "execution_count": null,
      "outputs": [],
      "id": "OYWFMNT9ycd7"
    },
    {
      "cell_type": "code",
      "source": [
        "from optuna.visualization import plot_optimization_history\n",
        "from optuna.visualization import plot_param_importances\n",
        "from optuna.visualization import plot_parallel_coordinate\n",
        "from optuna.visualization import plot_contour\n",
        "\n",
        "plot_optimization_history(study)"
      ],
      "metadata": {
        "id": "eACiKQAXwMSW"
      },
      "execution_count": null,
      "outputs": [],
      "id": "eACiKQAXwMSW"
    },
    {
      "cell_type": "code",
      "source": [
        "plot_param_importances(study)"
      ],
      "metadata": {
        "id": "zumvj87hzLVy"
      },
      "execution_count": null,
      "outputs": [],
      "id": "zumvj87hzLVy"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "91bbd3b7"
      },
      "outputs": [],
      "source": [
        "import pickle\n",
        "pickle.dump(model, open(\"catboost_model.pkl\", \"wb\"))\n",
        "     \n",
        "\n",
        "optuna.visualization.plot_optimization_history(study)\n",
        "     \n",
        "\n",
        "optuna.visualization.plot_parallel_coordinate(study)\n",
        "     \n",
        "\n",
        "# 각 파라미터들의 상관관계\n",
        "optuna.visualization.plot_contour(\n",
        "    study,\n",
        "    params=[\n",
        "        \"iterations\",\n",
        "        \"learning_rate\",\n",
        "        \"depth\",\n",
        "        \"l2_leaf_reg\",\n",
        "        \"bootstrap_type\",\n",
        "        \"random_strength\",\n",
        "        \"bagging_temperature\",\n",
        "        \"od_type\",\n",
        "        \"od_wait\"\n",
        "        ],\n",
        ")"
      ],
      "id": "91bbd3b7"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fab2a838"
      },
      "outputs": [],
      "source": [
        "# 하이퍼파라미터 중요도\n",
        "optuna.visualization.plot_param_importances(study)"
      ],
      "id": "fab2a838"
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "\n",
        "GBC_model = GradientBoostingClassifier(n_estimators= 200, \n",
        "                                       learning_rate=0.21851112508358236, \n",
        "\t\t\t\t\t\t\t\t\tmax_depth= 6,\n",
        "\t\t\t\t\t\t\t\t\tsubsample= 0.7, \n",
        "\t\t\t\t\t\t\t\t\tmax_features= 'auto').fit(X_train, y_train) "
      ],
      "metadata": {
        "id": "wi_Ll5YCzLbr"
      },
      "execution_count": null,
      "outputs": [],
      "id": "wi_Ll5YCzLbr"
    },
    {
      "cell_type": "code",
      "source": [
        "preds = GBC_model.predict(test_x)\n",
        "print('Done.')\n",
        "sns.countplot(x=preds); "
      ],
      "metadata": {
        "id": "kvIWDIg5UiQ_"
      },
      "execution_count": null,
      "outputs": [],
      "id": "kvIWDIg5UiQ_"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.3 MLP"
      ],
      "metadata": {
        "id": "gNzAotw2Jlr-"
      },
      "id": "gNzAotw2Jlr-"
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "class Dataset(torch.utils.data.Dataset):\n",
        "\n",
        "    def __init__(self, df):\n",
        "        self.labels = [0 if label == 0 else 1 for label in df['HeartDisease']]\n",
        "        self.features = df.drop(columns=['HeartDisease'], axis=1).values.tolist()\n",
        "\n",
        "    def classes(self):\n",
        "        return self.labels\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.labels)\n",
        "\n",
        "    def get_batch_labels(self, idx):\n",
        "        return np.array(self.labels[idx])\n",
        "\n",
        "    def get_batch_features(self, idx):\n",
        "        return np.array(self.features[idx])\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        batch_features = self.get_batch_features(idx)\n",
        "        batch_y = self.get_batch_labels(idx)\n",
        "\n",
        "        return batch_features, batch_y"
      ],
      "metadata": {
        "id": "pHd-qrBQ3REB"
      },
      "execution_count": null,
      "outputs": [],
      "id": "pHd-qrBQ3REB"
    },
    {
      "cell_type": "code",
      "source": [
        "def objective(trial):\n",
        "\n",
        "    params = {\n",
        "              'learning_rate': trial.suggest_loguniform('learning_rate', 1e-5, 1e-1),\n",
        "              'optimizer': trial.suggest_categorical(\"optimizer\", [\"Adam\", \"RMSprop\", \"SGD\"]),\n",
        "              'n_unit': trial.suggest_int(\"n_unit\", 4, 18)\n",
        "              }\n",
        "    \n",
        "    model = build_model(params)\n",
        "    \n",
        "    accuracy = train_and_evaluate(params, model)\n",
        "\n",
        "    return accuracy"
      ],
      "metadata": {
        "id": "ieivpz673RO-"
      },
      "execution_count": null,
      "outputs": [],
      "id": "ieivpz673RO-"
    },
    {
      "cell_type": "code",
      "source": [
        "study = optuna.create_study(direction=\"maximize\", sampler=optuna.samplers.TPESampler())\n",
        "study.optimize(objective, n_trials=30)"
      ],
      "metadata": {
        "id": "tsZzHRcx3RKB"
      },
      "execution_count": null,
      "outputs": [],
      "id": "tsZzHRcx3RKB"
    },
    {
      "cell_type": "code",
      "source": [
        "def build_model(params):\n",
        "    \n",
        "    in_features = train_x.shape[-1]\n",
        "    \n",
        "    return nn.Sequential(\n",
        "    \n",
        "        nn.Linear(in_features, params['n_unit']),\n",
        "        nn.LeakyReLU(),\n",
        "\n",
        "        nn.Linear(params['n_unit'], 2),\n",
        "        nn.LeakyReLU()\n",
        "        \n",
        "    )\n",
        " "
      ],
      "metadata": {
        "id": "ybk-xTzF3nT_"
      },
      "execution_count": null,
      "outputs": [],
      "id": "ybk-xTzF3nT_"
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Train and evaluate the accuarcy of neural network model\n",
        "def train_and_evaluate(param, model):\n",
        "    \n",
        "    df = pd.read_csv('heart.csv')\n",
        "    df = pd.get_dummies(df)\n",
        "    \n",
        "    train_data, val_data = train_test_split(df, test_size = 0.2, random_state = 42)\n",
        "    train, val = Dataset(train_data), Dataset(val_data)\n",
        "\n",
        "    train_dataloader = torch.utils.data.DataLoader(train, batch_size=2, shuffle=True)\n",
        "    val_dataloader = torch.utils.data.DataLoader(val, batch_size=2)\n",
        "\n",
        "    use_cuda = torch.cuda.is_available()\n",
        "    device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
        "\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = getattr(optim, param['optimizer'])(model.parameters(), lr= param['learning_rate'])\n",
        "\n",
        "    if use_cuda:\n",
        "\n",
        "            model = model.cuda()\n",
        "            criterion = criterion.cuda()\n",
        "\n",
        "    for epoch_num in range(EPOCHS):\n",
        "\n",
        "            total_acc_train = 0\n",
        "            total_loss_train = 0\n",
        "\n",
        "            for train_input, train_label in train_dataloader:\n",
        "\n",
        "                train_label = train_label.to(device)\n",
        "                train_input = train_input.to(device)\n",
        "\n",
        "                output = model(train_input.float())\n",
        "                \n",
        "                batch_loss = criterion(output, train_label.long())\n",
        "                total_loss_train += batch_loss.item()\n",
        "                \n",
        "                acc = (output.argmax(dim=1) == train_label).sum().item()\n",
        "                total_acc_train += acc\n",
        "\n",
        "                model.zero_grad()\n",
        "                batch_loss.backward()\n",
        "                optimizer.step()\n",
        "            \n",
        "            total_acc_val = 0\n",
        "            total_loss_val = 0\n",
        "\n",
        "            with torch.no_grad():\n",
        "\n",
        "                for val_input, val_label in val_dataloader:\n",
        "\n",
        "                    val_label = val_label.to(device)\n",
        "                    val_input = val_input.to(device)\n",
        "\n",
        "                    output = model(val_input.float())\n",
        "\n",
        "                    batch_loss = criterion(output, val_label.long())\n",
        "                    total_loss_val += batch_loss.item()\n",
        "                    \n",
        "                    acc = (output.argmax(dim=1) == val_label).sum().item()\n",
        "                    total_acc_val += acc\n",
        "            \n",
        "            accuracy = total_acc_val/len(val_data)\n",
        "\n",
        "    return accuracy\n",
        "  \n",
        " # Define a set of hyperparameter values, build the model, train the model, and evaluate the accuracy \n",
        "def objective(trial):\n",
        "\n",
        "     params = {\n",
        "              'learning_rate': trial.suggest_loguniform('learning_rate', 1e-5, 1e-1),\n",
        "              'optimizer': trial.suggest_categorical(\"optimizer\", [\"Adam\", \"RMSprop\", \"SGD\"]),\n",
        "              'n_unit': trial.suggest_int(\"n_unit\", 4, 18)\n",
        "              }\n",
        "    \n",
        "     model = build_model(params)\n",
        "    \n",
        "     accuracy = train_and_evaluate(params, model)\n",
        "\n",
        "     return accuracy"
      ],
      "metadata": {
        "id": "ITsy_mGB3RUf"
      },
      "execution_count": null,
      "outputs": [],
      "id": "ITsy_mGB3RUf"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4.Ensemble"
      ],
      "metadata": {
        "id": "o8N-QHuIvNN3"
      },
      "id": "o8N-QHuIvNN3"
    },
    {
      "cell_type": "markdown",
      "id": "2fe15f1a",
      "metadata": {
        "id": "2fe15f1a"
      },
      "source": [
        "## 4.1 VotingClassifier\n",
        "1. Cross-Validation 구축 후 성능 비교"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "models = [\n",
        "    # test set accuracy 1위(0.8166) \n",
        "    CatBoostClassifier(verbose=False, random_seed=seed_num),\n",
        "    # test set accuracy 5위(0.7722)\n",
        "    XGBClassifier(random_state=seed_num),\n",
        "    # test set accuracy 2위(0.8111) \n",
        "    GradientBoostingClassifier(random_state=seed_num)]\n",
        "\n",
        "fit = [x.fit(train_x, train_y) for x in models]    "
      ],
      "metadata": {
        "id": "Vm8q0p4Hyzg2"
      },
      "id": "Vm8q0p4Hyzg2",
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "id": "0bcafdb3",
      "metadata": {
        "id": "0bcafdb3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "046b71ae-0d1b-40c5-d860-e005cb986422"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def prediction(models, test, mode=None, weights=None):\n",
        "    if mode == \"hard\":\n",
        "        preds = np.asarray([x.predict(test).reshape(-1) for x in models]).T\n",
        "        res = np.apply_along_axis(\n",
        "            lambda x: np.argmax(np.bincount(x, weights=weights)),\n",
        "            axis=1,\n",
        "            arr=preds\n",
        "        )\n",
        "    elif mode == \"soft\":  \n",
        "        preds = np.asarray([x.predict_proba(test) for x in models])\n",
        "        res = np.zeros(preds[0].shape)\n",
        "        for pred, weight in zip(preds, weights):\n",
        "            res = res + pred*weight\n",
        "        res = np.argmax(preds, axis=0) \n",
        "    else:\n",
        "        res = models[0].predict(test)\n",
        "    return res\n",
        "\n",
        "preds = prediction(models, test_x, 'hard', [2,1,2] )\n",
        "\n",
        "sns.countplot(x=preds);   "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.2 Score"
      ],
      "metadata": {
        "id": "KUOHpt3z847x"
      },
      "id": "KUOHpt3z847x"
    },
    {
      "cell_type": "code",
      "source": [
        "cbc = CatBoostClassifier(verbose=False, random_seed=seed_num)  \n",
        "xgb = XGBClassifier(random_state=seed_num) \n",
        "gbc = GradientBoostingClassifier(random_state=seed_num) \n",
        "voting_model = VotingClassifier(estimators=[\n",
        "                ('CatBoostClassifier', cbc),\n",
        "                ('XGBClassifier', xgb),\n",
        "                ('GradientBoostingClassifier', gbc)], \n",
        "                voting='hard', weights=[2,1,2])\n",
        "# fitted = np.asarray(voting_model.fit(X_train, y_train).reshape(-1))\n",
        "np.asarray(fitted)   "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z3UesEBQ1r8z",
        "outputId": "3670348a-887b-4854-ff18-d825090c0132"
      },
      "id": "Z3UesEBQ1r8z",
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(VotingClassifier(estimators=[('CatBoostClassifier',\n",
              "                              <catboost.core.CatBoostClassifier object at 0x7f3f517db0d0>),\n",
              "                             ('XGBClassifier',\n",
              "                              XGBClassifier(base_score=None, booster=None,\n",
              "                                            callbacks=None,\n",
              "                                            colsample_bylevel=None,\n",
              "                                            colsample_bynode=None,\n",
              "                                            colsample_bytree=None,\n",
              "                                            early_stopping_rounds=None,\n",
              "                                            enable_categorical=False,\n",
              "                                            eval_metric=None,\n",
              "                                            feature_types=None, gamma=None,...\n",
              "                                            learning_rate=None, max_bin=None,\n",
              "                                            max_cat_threshold=None,\n",
              "                                            max_cat_to_onehot=None,\n",
              "                                            max_delta_step=None, max_depth=None,\n",
              "                                            max_leaves=None,\n",
              "                                            min_child_weight=None, missing=nan,\n",
              "                                            monotone_constraints=None,\n",
              "                                            n_estimators=100, n_jobs=None,\n",
              "                                            num_parallel_tree=None,\n",
              "                                            predictor=None, random_state=37, ...)),\n",
              "                             ('GradientBoostingClassifier',\n",
              "                              GradientBoostingClassifier(random_state=37))],\n",
              "                 weights=[2, 1, 2]), dtype=object)"
            ]
          },
          "metadata": {},
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# val_preds = prediction(models, X_test, 'hard', [2,1,2])\n",
        "# val_score= sklearn.metrics.accuracy_score(y_test, val_preds)\n",
        "# val_score  \n",
        "kf = KFold(n_splits=5, shuffle=True, random_state=seed_num)\n",
        "from sklearn.ensemble import VotingClassifier\n",
        "ens = VotingClassifier(estimators=models)\n",
        "scores = cross_validate(fitted, train_x, train_y, \n",
        "                        cv = kf, scoring = \"accuracy\", \n",
        "                        # return_train_score = True, n_jobs = -1\n",
        "                        ) \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TgLWsUI2A25b",
        "outputId": "2f84e426-fd37-4026-b502-e32b193122c9"
      },
      "id": "TgLWsUI2A25b",
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py:68: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py:778: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\", line 767, in _score\n",
            "    scores = scorer(estimator, X_test, y_test)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 234, in __call__\n",
            "    return self._score(\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 276, in _score\n",
            "    y_pred = method_caller(estimator, \"predict\", X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 73, in _cached_call\n",
            "    return getattr(estimator, method)(*args, **kwargs)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 366, in predict\n",
            "    predictions = self._predict(X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 68, in _predict\n",
            "    return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "ValueError: could not broadcast input array from shape (120,1) into shape (120,)\n",
            "\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py:68: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py:778: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\", line 767, in _score\n",
            "    scores = scorer(estimator, X_test, y_test)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 234, in __call__\n",
            "    return self._score(\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 276, in _score\n",
            "    y_pred = method_caller(estimator, \"predict\", X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 73, in _cached_call\n",
            "    return getattr(estimator, method)(*args, **kwargs)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 366, in predict\n",
            "    predictions = self._predict(X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 68, in _predict\n",
            "    return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "ValueError: could not broadcast input array from shape (120,1) into shape (120,)\n",
            "\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py:68: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py:778: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\", line 767, in _score\n",
            "    scores = scorer(estimator, X_test, y_test)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 234, in __call__\n",
            "    return self._score(\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 276, in _score\n",
            "    y_pred = method_caller(estimator, \"predict\", X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 73, in _cached_call\n",
            "    return getattr(estimator, method)(*args, **kwargs)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 366, in predict\n",
            "    predictions = self._predict(X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 68, in _predict\n",
            "    return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "ValueError: could not broadcast input array from shape (120,1) into shape (120,)\n",
            "\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py:68: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py:778: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\", line 767, in _score\n",
            "    scores = scorer(estimator, X_test, y_test)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 234, in __call__\n",
            "    return self._score(\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 276, in _score\n",
            "    y_pred = method_caller(estimator, \"predict\", X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 73, in _cached_call\n",
            "    return getattr(estimator, method)(*args, **kwargs)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 366, in predict\n",
            "    predictions = self._predict(X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 68, in _predict\n",
            "    return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "ValueError: could not broadcast input array from shape (119,1) into shape (119,)\n",
            "\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py:68: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py:778: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_validation.py\", line 767, in _score\n",
            "    scores = scorer(estimator, X_test, y_test)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 234, in __call__\n",
            "    return self._score(\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 276, in _score\n",
            "    y_pred = method_caller(estimator, \"predict\", X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_scorer.py\", line 73, in _cached_call\n",
            "    return getattr(estimator, method)(*args, **kwargs)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 366, in predict\n",
            "    predictions = self._predict(X)\n",
            "  File \"/usr/local/lib/python3.8/dist-packages/sklearn/ensemble/_voting.py\", line 68, in _predict\n",
            "    return np.asarray([est.predict(X) for est in self.estimators_]).T\n",
            "ValueError: could not broadcast input array from shape (119,1) into shape (119,)\n",
            "\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5.Submit"
      ],
      "metadata": {
        "id": "zbNtWowN78mX"
      },
      "id": "zbNtWowN78mX"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zfIcqXBqymkN"
      },
      "outputs": [],
      "source": [
        "submit = pd.read_csv('/content/drive/MyDrive/sample_submission.csv')\n",
        "\n",
        "submit['Y_Class'] = preds\n",
        "submit.to_csv('CXG212(1)-smartFactorySubmission.csv', index=False)  \n",
        "sns.countplot(x=preds);\n",
        "submit.Y_Class.value_counts()"
      ],
      "id": "zfIcqXBqymkN"
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gvXsoboM5RL6"
      },
      "id": "gvXsoboM5RL6",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "machine_shape": "hm"
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}