Task 1.4 Loan overdue - GridSearchCV.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "网格搜索调参.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "metadata": {
        "id": "RJ5uxNVQV2hD",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **授权**"
      ]
    },
    {
      "metadata": {
        "id": "mSPU_KhWFNEu",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!apt-get install -y -qq software-properties-common python-software-properties module-init-tools\n",
        "!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null\n",
        "!apt-get update -qq 2>&1 > /dev/null\n",
        "!apt-get -y install -qq google-drive-ocamlfuse fuse\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "from oauth2client.client import GoogleCredentials\n",
        "creds = GoogleCredentials.get_application_default()\n",
        "import getpass\n",
        "!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL\n",
        "vcode = getpass.getpass()\n",
        "!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "tJ9trV2bV5jz",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **指定文件目录**"
      ]
    },
    {
      "metadata": {
        "id": "UjCxoGpu-FAG",
        "colab_type": "code",
        "outputId": "a3a5bf7c-758d-4bac-b21b-456f6fcb88be",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "cell_type": "code",
      "source": [
        "!mkdir -p drive\n",
        "!google-drive-ocamlfuse drive\n",
        "import os\n",
        "\n",
        "os.chdir(\"drive/Colab Notebooks\") \n",
        "!ls"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " “com2018.ipynb”的副本\t'“one week.ipynb”的副本'\n",
            " data_all.csv\t\t 网格搜索调参.ipynb\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "GqNPfmCuV8kX",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **安装必要的包和库**"
      ]
    },
    {
      "metadata": {
        "id": "MSQFdjvJF3gN",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!pip install joblib\n",
        "!pip install pandas\n",
        "!pip install gbdt\n",
        "!pip install xgboost\n",
        "!pip install lightgbm\n",
        "!pip install imbalanced-learn\n",
        "!pip install -U git+https://github.com/scikit-learn-contrib/imbalanced-learn.git\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "bA2OolkjWAt3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **导入相关库**"
      ]
    },
    {
      "metadata": {
        "id": "BKfp5ZKCFtEP",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from sklearn.model_selection import GridSearchCV, KFold, train_test_split\n",
        "from sklearn import metrics\n",
        "from sklearn.ensemble.forest import RandomForestClassifier\n",
        "from lightgbm import LGBMClassifier\n",
        "import xgboost as xgb\n",
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn import tree\n",
        "from sklearn import svm\n",
        "from sklearn.metrics import roc_curve, auc\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "bVnooc-dGgXT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **读取数据并拆分数据集**"
      ]
    },
    {
      "metadata": {
        "id": "kcSti7FZGfyN",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data_all = pd.read_csv('./data_all.csv')\n",
        "Y = data_all['status']\n",
        "X = data_all.drop('status', axis=1)\n",
        "\n",
        "# 按7:3拆分成training和testing集，随机种子为2018。随机种子的目的是使每次拆分的结果一致\n",
        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3,random_state=2018)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "P3veUqhtGZt6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **数据初探**"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "lTIN2KHqjY9c",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "X_train.info() # 查看数据信息以及是否有缺失值\n",
        "\n",
        "# 查看label的分布，存在数据不平衡问题的。直接初步建模也验证了这一现象。\n",
        "plt.hist(Y_train, bins=3)\n",
        "plt.show()\n",
        "plt.hist(Y_test, bins=3)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "AyFjQDoKGW0M",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **数据不平衡处理**"
      ]
    },
    {
      "metadata": {
        "id": "LlqIcZCRGTpg",
        "colab_type": "code",
        "outputId": "8a37b4c6-7049-49ba-f00d-c39b5f5cca76",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        }
      },
      "cell_type": "code",
      "source": [
        "over_samples = SMOTE(random_state=2018) \n",
        "over_samples_X,over_samples_y = over_samples.fit_sample(X_train, Y_train)\n",
        "\n",
        "# 重抽样前的类别比例\n",
        "print(Y_train.value_counts()/len(Y_train))\n",
        "# 重抽样后的类别比例\n",
        "print(pd.Series(over_samples_y).value_counts()/len(over_samples_y))"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0    0.749324\n",
            "1    0.250676\n",
            "Name: status, dtype: float64\n",
            "1    0.5\n",
            "0    0.5\n",
            "dtype: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "WlynxG_F-e4x",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **建模：Logistic回归**"
      ]
    },
    {
      "metadata": {
        "id": "heRQVLO5Ji2G",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "1.这里选择使用pipeline函数将模型种类和标准化操作封装在一起。  \n",
        "2.Logis调参选择的参数是：C, penalty, solver, max_iter这四个。参数选项封装在param_grid里。  \n",
        "3.网格搜索评分选择了accuracy，后续尝试使用roc_auc  "
      ]
    },
    {
      "metadata": {
        "id": "kz_vCcL_-y1S",
        "colab_type": "code",
        "outputId": "3d868f0e-80a4-4c9b-cf06-48c16bbfc60e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 124
        }
      },
      "cell_type": "code",
      "source": [
        "pipe_lr = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',LogisticRegression(random_state =2018))])\n",
        "\n",
        "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__C': param_range,\n",
        "    'clf__penalty':['l1','l2'],\n",
        "    'clf__solver':['liblinear'],\n",
        "    'clf__max_iter':[10,50,100,150,200,300]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_lr,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.predict_proba(X_test)[:, 1]))\n",
        "\n",
        "# 运行时间: 228秒"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.8459936463961129\n",
            "{'clf__C': 1.0, 'clf__max_iter': 50, 'clf__penalty': 'l1', 'clf__solver': 'liblinear'}\n",
            "测试集AUC: 0.7673338341001327\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/pipeline.py:381: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by StandardScaler.\n",
            "  Xt = transform.transform(Xt)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "nOYXHmYN-od-",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **建模: Decision Tree**"
      ]
    },
    {
      "metadata": {
        "id": "IhA-rb5JNuLT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Decision Tree选择调参的参数为:  **  \n",
        "\n",
        "\n",
        "\n",
        "参数名称 | 解释\n",
        "------ | ------\n",
        "criterion                    | 特征选择标准   \n",
        "splitter                     | 特征划分点选择标准   \n",
        "max_features          |划分时考虑的最大特征数   \n",
        "max_depth               |决策树最大深   "
      ]
    },
    {
      "metadata": {
        "id": "NJzQMG-yDNvn",
        "colab_type": "code",
        "outputId": "819fa058-099d-46e4-b914-8414d668bb9b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 124
        }
      },
      "cell_type": "code",
      "source": [
        "pipe_dt = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',tree.DecisionTreeClassifier(random_state =2018))])\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__criterion': ['gini','entropy'],\n",
        "    'clf__splitter':['best','random'],\n",
        "    'clf__max_features':['auto','sqrt','log2'],\n",
        "    'clf__max_depth':[1,2,3,4,5,10,20,30,40,50,60,70,80,90,100]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_dt,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.predict_proba(X_test)[:, 1]))\n",
        "\n",
        "# 运行时间: 22秒"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.7864487498864556\n",
            "{'clf__criterion': 'gini', 'clf__max_depth': 5, 'clf__max_features': 'auto', 'clf__splitter': 'best'}\n",
            "测试集AUC: 0.6884174204250258\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/pipeline.py:381: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by StandardScaler.\n",
            "  Xt = transform.transform(Xt)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "6DOV8col-tim",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# 建模：SVM支持向量机"
      ]
    },
    {
      "metadata": {
        "id": "opdFDjB3VMag",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**SVM选择以下参数进行调参**:  \n",
        "  \n",
        "  参数名称 | 解释\n",
        "------ | ------\n",
        " C                 |惩罚系数  \n",
        " kernel         |选择核类型  \n",
        " gamma     |选择RBF函数作为kernel后，该函数自带的一个参数  \n",
        " max_iter   |最大迭代次数"
      ]
    },
    {
      "metadata": {
        "id": "xfSsW8NcEFbv",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pipe_dt = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',svm.SVC(random_state =2018))])\n",
        "\n",
        "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__C': param_range,\n",
        "    'clf__kernel':['linear','poly','rbf','sigmoid'],\n",
        "    'clf__gamma': [1, 0.01, 0.001, 0.0001],\n",
        "    'clf__max_iter':[10,50,100,150,200,300]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_dt,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.decision_function(X_test)))\n",
        "\n",
        "# 运行时间：640秒\n",
        "\n",
        "# 0.8124838738897966\n",
        "# {'clf__C': 0.1, 'clf__gamma': 1, 'clf__kernel': 'rbf', 'clf__max_iter': 300}\n",
        "# 测试集AUC: 0.5653435468895079\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "F5eEwiTrHy8N",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **建模: Random forest**"
      ]
    },
    {
      "metadata": {
        "id": "Sdaf1jhkXmZL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Random forest和决策树的参数类似，不再说明"
      ]
    },
    {
      "metadata": {
        "id": "74c1yEpDHxFZ",
        "colab_type": "code",
        "outputId": "13661bc4-3b78-4bfa-ff73-cfab07d9cc14",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 124
        }
      },
      "cell_type": "code",
      "source": [
        "pipe_rf = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',RandomForestClassifier(random_state =2018))])\n",
        "\n",
        "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__criterion': ['gini','entropy'],\n",
        "    'clf__n_estimators':[5,10,15,20],\n",
        "    'clf__max_features':['auto','sqrt','log2'],\n",
        "    'clf__max_depth':[1,2,3,4,5,10,20,30,40,50,60,70,80,90,100]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_rf,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.predict_proba(X_test)[:, 1]))\n",
        "\n",
        "# 运行时间：313秒"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.9329562158838433\n",
            "{'clf__criterion': 'entropy', 'clf__max_depth': 30, 'clf__max_features': 'auto', 'clf__n_estimators': 20}\n",
            "测试集AUC: 0.7577684057880296\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/pipeline.py:381: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by StandardScaler.\n",
            "  Xt = transform.transform(Xt)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "acDPb_G2P4iu",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **建模: GBDT**"
      ]
    },
    {
      "metadata": {
        "id": "tnDnhlU9bH_s",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**GBDT选择调参的参数为:  **  \n",
        "\n",
        "\n",
        "\n",
        "参数名称 | 解释\n",
        "------ | ------\n",
        "n_estimators                    | 子树的数量   \n",
        "loss                     | 损失函数\n",
        "learning_rate | 即每个弱学习器的权重缩减系数,也称作步长。取值范围(0,1]\n",
        "max_features          |划分时考虑的最大特征数   \n",
        "max_depth               |决策树最大深   "
      ]
    },
    {
      "metadata": {
        "id": "SRMxB1NwQCKn",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pipe_gbdt = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',GradientBoostingClassifier(random_state =2018))])\n",
        "\n",
        "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__n_estimators':[5,10,15,20,30,40,50,100,200],\n",
        "    'clf__max_features':['auto','sqrt','log2'],\n",
        "    'clf__max_depth':[1,2,3,4,5,10,20,30,40,50,60,70,80,90,100],\n",
        "    'clf__loss':['deviance','exponential'],\n",
        "    'clf__learning_rate':[0.001,0.01,0.1,0.2,0.3,0.4,0.5]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_gbdt,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.predict_proba(X_test)[:, 1]))\n",
        "\n",
        "# 运行时间：\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "jQ9-vNKlVzF5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **建模: XGBoost**"
      ]
    },
    {
      "metadata": {
        "id": "HOgJf6VEigsY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "XGBoost参数和树的类似。详见：  \n",
        "https://blog.csdn.net/han_xiaoyang/article/details/52665396"
      ]
    },
    {
      "metadata": {
        "id": "8jNDZVIFb8-o",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pipe_xgb = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',xgb.XGBClassifier(random_state =2018))])\n",
        "\n",
        "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__n_estimators':[5,10,15,20,30,40,50,100,200],\n",
        "    'clf__max_depth':[1,2,3,4,5,10,20,30,40,50,60,70,80,90,100],\n",
        "    'clf__gamma':[1, 0.01, 0.001, 0.0001],\n",
        "    'clf__learning_rate':[0.01,0.1,0.2,0.3,0.4,0.5]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_xgb,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.predict_proba(X_test)[:, 1]))\n",
        "\n",
        "# 运行时间：\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zSEw0ujfWMQY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **建模: LightGBM**"
      ]
    },
    {
      "metadata": {
        "id": "dp_im4lpjx53",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "详见：https://www.cnblogs.com/bjwu/p/9307344.html"
      ]
    },
    {
      "metadata": {
        "id": "mubwPJhSZs9R",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pipe_lgbm = Pipeline([('scl',StandardScaler()),\n",
        "                 ('clf',LGBMClassifier(random_state =2018))])\n",
        "\n",
        "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]\n",
        "\n",
        "param_grid = [{\n",
        "    'clf__n_estimators':[5,10,15,20,30,40,50,100,200],\n",
        "    'clf__feature_fraction': [0.5, 0.6, 0.7, 0.8, 0.9],\n",
        "    'clf__bagging_fraction': [0.6, 0.7, 0.8, 0.9, 1.0],\n",
        "    'clf__max_depth':[1,2,3,4,5,10,20,30,40,50,60,70,80,90,100],\n",
        "    'clf__reg_alpha': [0, 0.001, 0.01, 0.03, 0.08, 0.3, 0.5],\n",
        "    'clf__reg_lambda': [0, 0.001, 0.01, 0.03, 0.08, 0.3, 0.5],\n",
        "    'clf__learning_rate':[0.01,0.1,0.2,0.3,0.4,0.5]}]\n",
        "\n",
        "gs = GridSearchCV(estimator = pipe_lgbm,\n",
        "                 param_grid = param_grid,\n",
        "                 scoring = 'roc_auc',\n",
        "                 cv = 5,\n",
        "                 n_jobs = -1)\n",
        "gs = gs.fit(over_samples_X, over_samples_y)\n",
        "\n",
        "print(gs.best_score_)\n",
        "print(gs.best_params_)\n",
        "\n",
        "# 测试在testing上的效果\n",
        "clf = gs.best_estimator_\n",
        "clf.fit(over_samples_X,over_samples_y)\n",
        "\n",
        "print('测试集AUC:',metrics.roc_auc_score(Y_test,clf.predict_proba(X_test)[:, 1]))\n",
        "\n",
        "# 运行时间：\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "k1qgtkHgh_fp",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **总结及问题**"
      ]
    },
    {
      "metadata": {
        "id": "jeKKzKxZiHkY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**总结：**  \n",
        "1. 之前只是直接建模，参数都是默认值。本次调参任务开始接触每个模型的具体参数。参数略多，需要好好消化吸收。  \n",
        "2. 调参工作有两个重点：①必须了解模型涉及到哪些参数以及每个参数的含义；②还需要实践经验。每个模型的参数在不同的应用场合需要怎么调，就要靠经验积累了。\n",
        "\n",
        "\n",
        "**问题： ** \n",
        "  \n",
        "1. 代码重复量依旧存在，后面的查找最佳参数和测试集结果都可以封装成一个函数。待后续解决。\n",
        "2. GridSearchCV中的scoring参数，目前调用的是roc_auc。本来是想用准确度和auc一起看的，但是代码报错？\n",
        "3. 运行code的结果老是会有一些类似地址链接的东西跳出来。。。。。有点讨厌的。。。。\n"
      ]
    }
  ]
}