A-Label.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## xgboost \n",
    "> 丢弃B，之间用A预测类别"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入包\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first_round_testing_data.csv\n",
      "first_round_training_data.csv\n"
     ]
    }
   ],
   "source": [
    "# 读取数据\n",
    "!ls data/\n",
    "\n",
    "df_train = pd.read_csv(\"data\\\\first_round_training_data.csv\")\n",
    "\n",
    "# 去掉多余的特征\n",
    "df_train = df_train.drop(df_train.columns[[10,11,12,13,14,15,16,17,18,19,]], axis=1, )\n",
    "#df_train = df_train.drop(df_train.columns[[0,1,2,3,4,5,6,7,8,9,10,11,12,]], axis=1, )\n",
    "\n",
    "\n",
    "# 特征10 换位到最后一列\n",
    "df_test = pd.read_csv(\"data\\\\first_round_testing_data.csv\")\n",
    "tmp = df_test[\"Parameter10\"].copy()\n",
    "df_test.drop(\"Parameter10\",axis=1, inplace=True)\n",
    "df_test[\"Parameter10\"] = tmp\n",
    "\n",
    "\n",
    "df_train[\"Quality_label\"] = df_train[\"Quality_label\"].map({\"Excellent\":3,\"Good\":2,\"Pass\":1,\"Fail\":0}) \n",
    "df_train.head()\n",
    "\n",
    "\n",
    "\n",
    "# 划分数据集\n",
    "df_target = df_train[\"Quality_label\"]\n",
    "train = df_train.drop([\"Quality_label\"], axis=1)\n",
    "\n",
    "\n",
    "X_train,X_test, y_train, y_test = train_test_split(train,df_target,test_size=0.3, random_state=0)\n",
    "### model-4 xgboost\n",
    "import xgboost as xgb\n",
    "import random\n",
    "\n",
    "\n",
    "df_train[\"Parameter1\"] = np.log10(df_train[\"Parameter1\"])\n",
    "df_train[\"Parameter2\"] = np.log10(df_train[\"Parameter2\"])\n",
    "df_train[\"Parameter3\"] = np.log10(df_train[\"Parameter3\"])\n",
    "df_train[\"Parameter4\"] = np.log10(df_train[\"Parameter4\"])\n",
    "df_train[\"Parameter5\"] = np.log10(df_train[\"Parameter5\"])\n",
    "df_train[\"Parameter6\"] = np.log10(df_train[\"Parameter6\"])\n",
    "df_train[\"Parameter7\"] = np.log10(df_train[\"Parameter7\"])\n",
    "\n",
    "df_train[\"Parameter8\"] = np.log10(df_train[\"Parameter8\"])\n",
    "df_train[\"Parameter9\"] = np.log10(df_train[\"Parameter9\"])\n",
    "df_train[\"Parameter10\"] = np.log10(df_train[\"Parameter10\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    9.2s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    2.0s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    1.9s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    1.7s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    1.9s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9648333333333333\n",
      "3.45\n",
      "[3.45, 3.48, 3.5, 3.51, 3.53]\n"
     ]
    }
   ],
   "source": [
    "# #  test\n",
    "        \n",
    "# score_list = []\n",
    "# ff_list = [3.45,3.48,3.5, 3.51,3.53] #range(1,8,1)\n",
    "# for fff in ff_list:\n",
    "#     df_train = pd.read_csv(\"data\\\\first_round_training_data.csv\")\n",
    "\n",
    "#     # 去掉多余的特征\n",
    "#     #df_train = df_train.drop(df_train.columns[[10,11,12,13,14,15,16,17,18,19,]], axis=1, )\n",
    "#     df_train = df_train.drop(df_train.columns[[0,1,2,3,4,5,6,7,8,9,10,11,12,]], axis=1, )\n",
    "\n",
    "\n",
    "#     # 特征10 换位到最后一列\n",
    "#     df_test = pd.read_csv(\"data\\\\first_round_testing_data.csv\")\n",
    "#     tmp = df_test[\"Parameter10\"].copy()\n",
    "#     df_test.drop(\"Parameter10\",axis=1, inplace=True)\n",
    "#     df_test[\"Parameter10\"] = tmp\n",
    "\n",
    "\n",
    "\n",
    "#     df_train[\"Quality_label\"] = df_train[\"Quality_label\"].map({\"Excellent\":3,\"Good\":2,\"Pass\":1,\"Fail\":0}) \n",
    "#     df_train.head()\n",
    "\n",
    "\n",
    "\n",
    "#     # 划分数据集\n",
    "#     df_target = df_train[\"Quality_label\"]\n",
    "#     train = df_train.drop([\"Quality_label\"], axis=1)\n",
    "\n",
    "\n",
    "#     X_train,X_test, y_train, y_test = train_test_split(train,df_target,test_size=0.3, random_state=0)\n",
    "#     ### model-4 xgboost\n",
    "#     import xgboost as xgb\n",
    "#     import random\n",
    "\n",
    "\n",
    "#     df_train[\"Attribute4\"] = np.log10(df_train[\"Attribute4\"])\n",
    "#     df_train[\"Attribute5\"] = np.log10(df_train[\"Attribute5\"])\n",
    "#     df_train[\"Attribute6\"] = np.log10(df_train[\"Attribute6\"])\n",
    "#     df_train[\"Attribute7\"] = np.log10(df_train[\"Attribute7\"])\n",
    "#     df_train[\"Attribute8\"] = np.log10(df_train[\"Attribute8\"])\n",
    "#     df_train[\"Attribute9\"] = np.log10(df_train[\"Attribute9\"])\n",
    "#     df_train[\"Attribute10\"] = np.log10(df_train[\"Attribute10\"])\n",
    "\n",
    "#     def find(row):\n",
    "#         if row < -0.784:\n",
    "#             return 1\n",
    "#         elif row < 2.01:\n",
    "#             return 2\n",
    "#         else:\n",
    "#             return 3\n",
    "#     df_train[\"Attribute5\"] = df_train[\"Attribute5\"].apply(find)\n",
    "\n",
    "#     def find(row):\n",
    "#         if row < 0.47:\n",
    "#             return 1\n",
    "#         elif row < 1.75:\n",
    "#             return 2\n",
    "#         else:\n",
    "#             return 3\n",
    "#     df_train[\"Attribute4\"] = df_train[\"Attribute4\"].apply(find)\n",
    "    \n",
    "#     def find(row):\n",
    "#         if row <-2.195:\n",
    "#             return 1\n",
    "#         elif row < 2:\n",
    "#             return 2\n",
    "#         else:\n",
    "#             return 3\n",
    "#     df_train[\"Attribute6\"] = df_train[\"Attribute6\"].apply(find)\n",
    "    \n",
    "#     def find(row):\n",
    "#         if row < 1.2:\n",
    "#             return 1\n",
    "#         elif row < 2.15:\n",
    "#             return 2\n",
    "#         else:\n",
    "#             return 3\n",
    "#     df_train[\"Attribute7\"] = df_train[\"Attribute7\"].apply(find)\n",
    "    \n",
    "#     def find(row):\n",
    "#         if row < -1.43:\n",
    "#             return 1\n",
    "#         elif row < 0.2:\n",
    "#             return 2\n",
    "#         else:\n",
    "#             return 3\n",
    "#     df_train[\"Attribute8\"] = df_train[\"Attribute8\"].apply(find)\n",
    "    \n",
    "    \n",
    "#     def find(row):\n",
    "#         if row < 1.31:\n",
    "#             return 1\n",
    "#         elif row < 2.39:\n",
    "#             return 2\n",
    "#         elif row < 3.45:\n",
    "#             return 3\n",
    "#         else:\n",
    "#             return 4\n",
    "#     df_train[\"Attribute9\"] = df_train[\"Attribute9\"].apply(find)\n",
    "    \n",
    "#     def find(row):\n",
    "#         if row < -1.40:\n",
    "#             return 1\n",
    "#         elif row < 2.28:\n",
    "#             return 2\n",
    "#         elif row < 4.3:\n",
    "#             return 3\n",
    "#         else:\n",
    "#             return 4\n",
    "#     df_train[\"Attribute10\"] = df_train[\"Attribute10\"].apply(find)\n",
    "\n",
    "\n",
    "#     # 划分数据集\n",
    "\n",
    "#     df_target = df_train[\"Quality_label\"]\n",
    "#     train = df_train.drop([\"Quality_label\"], axis=1)\n",
    "\n",
    "#     X_train,X_test, y_train, y_test = train_test_split(train,df_target,test_size=0.3, random_state=0)\n",
    "\n",
    "#     # #对数据的训练集进行标准化\n",
    "\n",
    "#     # ### model-3  随机森林  # 最好成绩 0.44\n",
    "#     # from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "#     # score_list = []\n",
    "#     # c_list =[i for i in range(1,10,1)]\n",
    "#     # for c in c_list:\n",
    "#     #     rfc = RandomForestClassifier(\n",
    "#     #                               n_estimators=120    # 默认10，决策树的数量, 越多越好，从100开始。\n",
    "\n",
    "#     #                             , bootstrap=True   # 有放回采样\n",
    "#     #                             , oob_score=False  # out-of-bag 使用没有抽到的数据做验证\n",
    "#     #                             , n_jobs=None      #并行计算\n",
    "#     #                             , verbose=0        # 打印训练日志\n",
    "#     #                             , warm_start=False  # 热启动\n",
    "\n",
    "#     #                             #与决策树相关的参数\n",
    "#     #                             , criterion='gini'  # 或 \"entropy\" \n",
    "#     #                             , random_state=None\n",
    "#     #                             , class_weight=None\n",
    "#     #                             , max_depth=8\n",
    "#     #                             , min_samples_split=2\n",
    "#     #                             , min_samples_leaf=1\n",
    "#     #                             , min_weight_fraction_leaf=0.0\n",
    "#     #                             , max_features=None# auto=特征数的开根号，log2=log2(n_features)， None = n_features\n",
    "#     #                             , max_leaf_nodes=None\n",
    "#     #                             , min_impurity_decrease=0.0\n",
    "#     #                             , min_impurity_split=None\n",
    "#     #                             )\n",
    "\n",
    "#     #     rfc = rfc.fit(X_train, y_train)\n",
    "#     #     score = rfc.score(X_test,y_test)\n",
    "#     #     score_list.append(score)\n",
    "#     # print(max(score_list))\n",
    "#     # print(c_list[list(score_list).index(max(list(score_list)))])\n",
    "\n",
    "\n",
    "#     ### model-4 xgboost\n",
    "#     import xgboost as xgb\n",
    "#     from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "\n",
    "#     cv_params = {'n_estimators':[100] }# [i for i in range(30,300,10)], }\n",
    "#     other_params = {    \n",
    "#                        # step1: 24\n",
    "#                         \"n_estimators\":100\n",
    "#                       # step2: 4, 3\n",
    "#                         , \"max_depth\":4\n",
    "#                         , \"min_child_weight\" : 3\n",
    "\n",
    "#                       # step3:\n",
    "#                         , \"subsample\" : 0.9\n",
    "#                         , \"colsample_bytree\" : 0.4\n",
    "\n",
    "\n",
    "#                         , \"learning_rate\":0.1\n",
    "\n",
    "#                         , \"verbosity\":1\n",
    "#                         , \"silent\":None\n",
    "#                         , \"objective\":'binary:logistic'\n",
    "#                         , \"booster\": \"gbtree\"\n",
    "#                         , \"n_jobs\" : 1\n",
    "#                         , \"nthread\" : None\n",
    "#                         , \"gamma\" : 0.3\n",
    "\n",
    "#                         , \"max_delta_step\" : 0\n",
    "\n",
    "#                         , \"colsample_bylevel\" : 1\n",
    "#                         , \"colsample_bynode\" : 1\n",
    "#                         , \"reg_alpha\" : 0\n",
    "#                         , \"reg_lambda\" : 1\n",
    "#                         , \"scale_pos_weight\" : 1\n",
    "#                         , \"base_score\" : 0.5\n",
    "#                         , \"random_state\" : 42\n",
    "#                         , \"seed\"  : None\n",
    "#                         , \"missing\" : None\n",
    "#                         , \"importance_type\" :'gain'\n",
    "#     }\n",
    "\n",
    "#     model = xgb.XGBClassifier(**other_params)\n",
    "#     optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)\n",
    "#     optimized_GBM.fit(train, df_target)\n",
    "\n",
    "#     score_list.append(optimized_GBM.best_score_)\n",
    "    \n",
    "# print(max(score_list))\n",
    "# print(ff_list[score_list.index(max(score_list))])\n",
    "# print(ff_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    6.5s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "每轮迭代运行结果:[0.501]\n",
      "参数的最佳取值：{'n_estimators': 100}\n",
      "最佳模型得分:0.501\n"
     ]
    }
   ],
   "source": [
    "# 划分数据集\n",
    "\n",
    "df_target = df_train[\"Quality_label\"]\n",
    "train = df_train.drop([\"Quality_label\"], axis=1)\n",
    "\n",
    "X_train,X_test, y_train, y_test = train_test_split(train,df_target,test_size=0.3, random_state=0)\n",
    "\n",
    "### model-4 xgboost\n",
    "import xgboost as xgb\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "\n",
    "cv_params = {'n_estimators':[100] }# [i for i in range(30,300,10)], }\n",
    "other_params = {    \n",
    "                   # step1: 24\n",
    "                    \"n_estimators\":100\n",
    "                  # step2: 4, 3\n",
    "                    , \"max_depth\":4\n",
    "                    , \"min_child_weight\" : 3\n",
    "    \n",
    "                  # step3:\n",
    "                    , \"subsample\" : 0.9\n",
    "                    , \"colsample_bytree\" : 0.4\n",
    "    \n",
    "                \n",
    "                    , \"learning_rate\":0.1\n",
    "                \n",
    "                    , \"verbosity\":1\n",
    "                    , \"silent\":None\n",
    "                    , \"objective\":'binary:logistic'\n",
    "                    , \"booster\": \"gbtree\"\n",
    "                    , \"n_jobs\" : 1\n",
    "                    , \"nthread\" : None\n",
    "                    , \"gamma\" : 0.3\n",
    "                  \n",
    "                    , \"max_delta_step\" : 0\n",
    "\n",
    "                    , \"colsample_bylevel\" : 1\n",
    "                    , \"colsample_bynode\" : 1\n",
    "                    , \"reg_alpha\" : 0\n",
    "                    , \"reg_lambda\" : 1\n",
    "                    , \"scale_pos_weight\" : 1\n",
    "                    , \"base_score\" : 0.5\n",
    "                    , \"random_state\" : 42\n",
    "                    , \"seed\"  : None\n",
    "                    , \"missing\" : None\n",
    "                    , \"importance_type\" :'gain'\n",
    "}\n",
    "\n",
    "model = xgb.XGBClassifier(**other_params)\n",
    "optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)\n",
    "optimized_GBM.fit(train, df_target)\n",
    "\n",
    "evalute_result = optimized_GBM.cv_results_['mean_test_score']\n",
    "print('每轮迭代运行结果:{0}'.format(evalute_result))\n",
    "print('参数的最佳取值：{0}'.format(optimized_GBM.best_params_))\n",
    "print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 带入最佳参数\n",
    "\n",
    "model = xgb.XGBClassifier(\n",
    "                              learning_rate=0.1\n",
    "                            , n_estimators=100\n",
    "                            , max_depth=4\n",
    "                            , min_child_weight=3\n",
    "                            , seed=0\n",
    "                            , subsample=0.9\n",
    "                            , colsample_bytree=0.4\n",
    "                            \n",
    "                            , reg_alpha=0\n",
    "                            , reg_lambda=1\n",
    "                            , objective = \"binary:logistic\"\n",
    "                            , gamma = 0.3\n",
    "                            , random_state  = 42\n",
    "                           )\n",
    "model = model.fit(train, df_target)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x236c9c06c88>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xgb.plot_importance(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 测试集\n",
    "testRes = model.predict(df_test.iloc[:,1:])\n",
    "\n",
    "testpredict = model.predict_proba(df_test.iloc[:,1:])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>Excellent ratio</th>\n",
       "      <th>Good ratio</th>\n",
       "      <th>Pass ratio</th>\n",
       "      <th>Fail ratio</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Group</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.147778</td>\n",
       "      <td>0.418331</td>\n",
       "      <td>0.262199</td>\n",
       "      <td>0.171693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.137078</td>\n",
       "      <td>0.398040</td>\n",
       "      <td>0.308658</td>\n",
       "      <td>0.156224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.114048</td>\n",
       "      <td>0.434092</td>\n",
       "      <td>0.288658</td>\n",
       "      <td>0.163201</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.131699</td>\n",
       "      <td>0.438444</td>\n",
       "      <td>0.272119</td>\n",
       "      <td>0.157738</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.140649</td>\n",
       "      <td>0.422317</td>\n",
       "      <td>0.266880</td>\n",
       "      <td>0.170155</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Excellent ratio  Good ratio  Pass ratio  Fail ratio\n",
       "Group                                                     \n",
       "0             0.147778    0.418331    0.262199    0.171693\n",
       "1             0.137078    0.398040    0.308658    0.156224\n",
       "2             0.114048    0.434092    0.288658    0.163201\n",
       "3             0.131699    0.438444    0.272119    0.157738\n",
       "4             0.140649    0.422317    0.266880    0.170155"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = pd.DataFrame(\n",
    "    testpredict, columns=[\"Excellent ratio\", \"Good ratio\", \"Pass ratio\", \"Fail ratio\"]\n",
    ")\n",
    "y_pred[\"Group\"] = df_test[\"Group\"]\n",
    "\n",
    "group_pred = y_pred.groupby(\"Group\").mean()\n",
    "for c in [\"Excellent ratio\", \"Good ratio\", \"Pass ratio\", \"Fail ratio\"]:\n",
    "    group_pred[c] /= group_pred.sum(axis=1)\n",
    "    \n",
    "\n",
    "group_pred.to_csv('./result1.csv', index=True, header=True)\n",
    "group_pred.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 类别结果加到原始的测试集\n",
    "df_test = pd.concat([df_test, pd.DataFrame(data=testRes)], axis=1,)\n",
    "submit_csv = pd.read_csv(\"submit_example.csv\")\n",
    "submit_csv.head()\n",
    "# 分组计算 概率\n",
    "g = df_test.groupby(\"Group\")\n",
    "group_list = df_test.Group.unique()\n",
    "\n",
    "for i in group_list:\n",
    "    tmp = g.get_group(i)\n",
    "    Excellent = len(tmp[tmp[0]==3])/50.0\n",
    "    Good = len(tmp[tmp[0]==2])/50.0\n",
    "    Pass = len(tmp[tmp[0]==1])/50.0\n",
    "    Fail = len(tmp[tmp[0]==0])/50.0\n",
    "    submit_csv[submit_csv[\"Group\"]==i] = [i, Excellent, Good, Pass, Fail]\n",
    "\n",
    "submit_csv.to_csv('./result.csv', index=False, header=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}