From 4d3a4232e52efe4518c2aa8623ee8d0c2e1acd6d Mon Sep 17 00:00:00 2001 From: benjas <909336740@qq.com> Date: Wed, 20 Jan 2021 17:17:18 +0800 Subject: [PATCH] Add. The effect of different thresholds on the results --- ...归-信用卡欺诈检测-checkpoint.ipynb | 423 +++++++++++++++++- .../逻辑回归-信用卡欺诈检测.ipynb | 96 +++- 2 files changed, 513 insertions(+), 6 deletions(-) diff --git a/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/.ipynb_checkpoints/逻辑回归-信用卡欺诈检测-checkpoint.ipynb b/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/.ipynb_checkpoints/逻辑回归-信用卡欺诈检测-checkpoint.ipynb index ba5ed51..969498f 100644 --- a/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/.ipynb_checkpoints/逻辑回归-信用卡欺诈检测-checkpoint.ipynb +++ b/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/.ipynb_checkpoints/逻辑回归-信用卡欺诈检测-checkpoint.ipynb @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +57,10 @@ "import numpy as np\n", "\n", "# 把图轻松的镶嵌到这个notebook中\n", - "%matplotlib inline" + "%matplotlib inline\n", + "\n", + "import warnings # 忽略普通警告,不打印太多东西\n", + "warnings.filterwarnings('ignore')" ] }, { @@ -659,6 +662,422 @@ "print(\"下采样样本总数: \", len(X_train_undersample)+len(X_test_undersample))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 模型的评估方法——召回率\n", + "由于目前正负样本极度不平衡,如果用准确率,那么和上面说的一样,模型把全部评定为正常样本,准确率就达到99.99%。这里用召回率,即异常样本找到多少个。\n", + "\n", + "Recall = TP/(TP+FN)\n", + "\n", + "* TP,即 True Positive =正确地判断成正例\n", + "* TN,即 True negative=正确地判断成负例\n", + "* FP,即False Positive =错误地判断成正例\n", + "* FN ,即False negative =错误地判断成负例" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# 在sklearn库的线性模块中,调取“逻辑回归”\n", + "from sklearn.linear_model import LogisticRegression \n", + "\n", + "#交叉验证模块中,选用“K折交叉验证”\n", + "#cross_val_score函数返回的是一个使用交叉验证以后的评分标准。\n", + "from sklearn.model_selection import KFold, cross_val_score \n", + "\n", + "# 混淆矩阵、召回率\n", + "# sklearn中的classification_report函数用于显示主要分类指标的文本报告,在报告中显示每个类的精确度,召回率,F1值等信息。\n", + "from sklearn.metrics import confusion_matrix,recall_score,classification_report \n", + "\n", + "# cross_val_predict 和 cross_val_score的使用方法是一样的,但是它返回的是一个使用交叉验证以后的输出值,而不是评分标准。\n", + "from sklearn.model_selection import cross_val_predict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 正则化惩罚——提高模型泛化能力\n", + "模型过拟合通常出现在,数据量少的同时特征又多,也就是当下的情况,异常样本非常少,特征维度有28个。" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# 编写Kflod函数——printing_Kfold_scores,实际中我们可以直接调用\n", + "def printing_Kfold_scores(x_train_data,y_train_data):\n", + " fold = KFold(5,shuffle=False) #shuffle=False是指数据集不用洗牌\n", + " \n", + " # 定义不同力度的正则化惩罚力度,值越大惩罚力度越小\n", + " c_param_range = [0.01,0.1,1,10,100]\n", + " # 展示结果用的表格\n", + " results_table = pd.DataFrame(index = range(len(c_param_range),2), columns = ['C_parameter','Mean recall score'])\n", + " results_table['C_parameter'] = c_param_range\n", + " \n", + " # k-fold 表示K折的交叉验证,这里会得到两个索引集合: 训练集 = indices[0], 验证集 = indices[1]\n", + " j = 0\n", + " # 循环遍历不同的参数(这里的c_param_rang是5个——5折交叉验证)\n", + " for c_param in c_param_range:\n", + " print('-------------------------------------------')\n", + " print('正则化惩罚力度: ', c_param)\n", + " print('-------------------------------------------')\n", + " \n", + " # 计算每一次迭代后的召回率,一次5次\n", + " recall_accs = []\n", + " \n", + " # 一步步分解来执行交叉验证\n", + " for iteration, indices in enumerate(fold.split(x_train_data)):\n", + " \n", + " # 选择算法模型+给定参数\n", + " lr = LogisticRegression(C = c_param, penalty = 'l1') #L1正则化防止过拟合,通过k折交叉验证寻找最佳的参数C。 \n", + "\n", + " # 训练模型。注意索引不要给错了,训练的时候一定传入的是训练集,所以X和Y的索引都是0\n", + " lr.fit(x_train_data.iloc[indices[0],:],y_train_data.iloc[indices[0],:].values.ravel())\n", + "\n", + " # 使用验证集预测模型结果,这里用的就是验证集,索引为1\n", + " y_pred_undersample = lr.predict(x_train_data.iloc[indices[1],:].values)\n", + "\n", + " # 评估模型。有了预测结果之后就可以来进行评估了,这里recall_score需要传入预测值和真实值。\n", + " recall_acc = recall_score(y_train_data.iloc[indices[1],:].values,y_pred_undersample)\n", + " # 保存每一步的结果,以便后续计算平均值。\n", + " recall_accs.append(recall_acc)\n", + " print('Iteration ', iteration,': 召回率 = ', recall_acc)\n", + "\n", + " # 当执行完所有的交叉验证后,计算平均结果\n", + " results_table.loc[j,'Mean recall score'] = np.mean(recall_accs)\n", + " j += 1 # 在这儿的意思是 num = num + 1\n", + " print('')\n", + " print('平均召回率 ', np.mean(recall_accs))\n", + " print('')\n", + "\n", + " # 找到最好的参数,哪一个Recall高,自然就是最好的了。\n", + " best_c = results_table.loc[results_table['Mean recall score'].astype('float32').idxmax()]['C_parameter']\n", + "\n", + " # 打印最好的结果\n", + " print('***********************************')\n", + " print('效果最好的模型所选参数 = ', best_c)\n", + " print('***********************************')\n", + "\n", + " return best_c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "交叉验证与不同参数的结果" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------\n", + "正则化惩罚力度: 0.01\n", + "-------------------------------------------\n", + "Iteration 0 : 召回率 = 0.9315068493150684\n", + "Iteration 1 : 召回率 = 0.9178082191780822\n", + "Iteration 2 : 召回率 = 1.0\n", + "Iteration 3 : 召回率 = 0.972972972972973\n", + "Iteration 4 : 召回率 = 0.9545454545454546\n", + "\n", + "平均召回率 0.9553666992023157\n", + "\n", + "-------------------------------------------\n", + "正则化惩罚力度: 0.1\n", + "-------------------------------------------\n", + "Iteration 0 : 召回率 = 0.8493150684931506\n", + "Iteration 1 : 召回率 = 0.863013698630137\n", + "Iteration 2 : 召回率 = 0.9491525423728814\n", + "Iteration 3 : 召回率 = 0.9324324324324325\n", + "Iteration 4 : 召回率 = 0.9090909090909091\n", + "\n", + "平均召回率 0.900600930203902\n", + "\n", + "-------------------------------------------\n", + "正则化惩罚力度: 1\n", + "-------------------------------------------\n", + "Iteration 0 : 召回率 = 0.8493150684931506\n", + "Iteration 1 : 召回率 = 0.8904109589041096\n", + "Iteration 2 : 召回率 = 0.9830508474576272\n", + "Iteration 3 : 召回率 = 0.9459459459459459\n", + "Iteration 4 : 召回率 = 0.9090909090909091\n", + "\n", + "平均召回率 0.9155627459783485\n", + "\n", + "-------------------------------------------\n", + "正则化惩罚力度: 10\n", + "-------------------------------------------\n", + "Iteration 0 : 召回率 = 0.863013698630137\n", + "Iteration 1 : 召回率 = 0.8904109589041096\n", + "Iteration 2 : 召回率 = 0.9830508474576272\n", + "Iteration 3 : 召回率 = 0.9324324324324325\n", + "Iteration 4 : 召回率 = 0.9090909090909091\n", + "\n", + "平均召回率 0.9155997693030431\n", + "\n", + "-------------------------------------------\n", + "正则化惩罚力度: 100\n", + "-------------------------------------------\n", + "Iteration 0 : 召回率 = 0.8767123287671232\n", + "Iteration 1 : 召回率 = 0.8904109589041096\n", + "Iteration 2 : 召回率 = 0.9830508474576272\n", + "Iteration 3 : 召回率 = 0.9459459459459459\n", + "Iteration 4 : 召回率 = 0.9090909090909091\n", + "\n", + "平均召回率 0.921042198033143\n", + "\n", + "***********************************\n", + "效果最好的模型所选参数 = 0.01\n", + "***********************************\n" + ] + } + ], + "source": [ + "best_c = printing_Kfold_scores(X_train_undersample,y_train_undersample)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# 混淆矩阵\n", + "def plot_confusion_matrix(cm, classes,\n", + " title='Confusion matrix',\n", + " cmap=plt.cm.Blues):\n", + " \"\"\"\n", + " 绘制混淆矩阵\n", + " \"\"\"\n", + " plt.imshow(cm, interpolation='nearest', cmap=cmap)\n", + " plt.title(title)\n", + " plt.colorbar()\n", + " tick_marks = np.arange(len(classes))\n", + " plt.xticks(tick_marks, classes, rotation=0)\n", + " plt.yticks(tick_marks, classes)\n", + "\n", + " thresh = cm.max() / 2.\n", + " for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n", + " plt.text(j, i, cm[i, j],\n", + " horizontalalignment=\"center\",\n", + " color=\"white\" if cm[i, j] > thresh else \"black\")\n", + "\n", + " plt.tight_layout()\n", + " plt.ylabel('True label')\n", + " plt.xlabel('Predicted label')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "召回率: 0.9319727891156463\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import itertools\n", + "# 选择最优正则化参数\n", + "lr = LogisticRegression(C = best_c, penalty = 'l1')\n", + "# 训练模型\n", + "lr.fit(X_train_undersample,y_train_undersample.values.ravel())\n", + "# 测试模型\n", + "y_pred_undersample = lr.predict(X_test_undersample.values)\n", + "# 计算所需值\n", + "cnf_matrix = confusion_matrix(y_test_undersample,y_pred_undersample)\n", + "np.set_printoptions(precision=2)\n", + " \n", + "print(\"召回率: \", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))\n", + "# 绘制\n", + "class_names = [0,1]\n", + "plt.figure()\n", + "plot_confusion_matrix(cnf_matrix\n", + " , classes=class_names\n", + " , title='Confusion matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "右上角19表示原本正常的,被判定为异常。右下角表示原本异常的,被判定为异常的。看似结果不错。\n", + "\n", + "但这里还不是我们的原始需求,我们的原始需求是在28万多个中,找到492个异常的。而目前是1:1的比例。" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "召回率: 0.9183673469387755\n", + "精确率: 0.014091858037578288\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVkAAAEmCAYAAADIhuPPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3de7xd07n/8c93J0LSuIRUkMSlFUFziIRQSrWIRFXUKaJKitOUovcLpU3dira/VlPKoUKCI1TrSAkRWnU5EUmISxAJii0hiYQiFSTP7485diyx9tprJ3tm7r329+01X2vNZ4455ljZ8mTsscYcUxGBmZnlo67oBpiZ1TInWTOzHDnJmpnlyEnWzCxHTrJmZjlykjUzy5GTbDsjqbOkv0p6Q9Kf1qCeoyXd2ZJtK4qkvSXNLrodVpvkebKtk6SvAN8DtgfeBGYC50XE/WtY7zHAqcCeEfH+Gje0lZMUQJ+ImFt0W6x9ck+2FZL0PeAi4BdAD2BL4A/AsBaofivgmfaQYKshqWPRbbAaFxHeWtEGbAi8BRxeocy6ZEl4XtouAtZNx/YF6oHvAwuA+cBx6dhZwLvAe+kaJwA/B64tqXtrIICOaf9rwHNkvenngaNL4veXnLcnMA14I73uWXLsHuAc4IFUz51A90Y+W0P7f1TS/kOBg4BngMXAT0rKDwKmAK+nshcDndKxe9NneTt93iNL6v8x8ApwTUMsnfPJdI0BaX8LYBGwb9H/b3hrm5t7sq3Pp4H1gJsrlDkD2APoD+xMlmjOLDm+GVmy7kmWSC+R1C0iRpH1jm+IiK4RcWWlhkj6GDAaGBoR65Ml0pllym0M3JbKbgL8BrhN0iYlxb4CHAdsCnQCflDh0puR/Rn0BH4GXAF8FRgI7A38TNInUtnlwHeB7mR/dvsB3wSIiH1SmZ3T572hpP6NyXr1I0svHBHPkiXg6yR1Aa4Cro6Ieyq016xRTrKtzybAoqj86/zRwNkRsSAiFpL1UI8pOf5eOv5eREwk68X1Xc32rAD6SeocEfMjYlaZMl8A5kTENRHxfkRcDzwNfLGkzFUR8UxE/Bu4kewfiMa8Rzb+/B4wniyB/i4i3kzXnwXsBBARMyLiwXTdfwL/DXy2is80KiKWpfZ8SERcAcwBpgKbk/2jZrZanGRbn9eA7k2MFW4BvFCy/0KKraxjlSS9FOja3IZExNtkv2KfCMyXdJuk7atoT0Obepbsv9KM9rwWEcvT+4Yk+GrJ8X83nC9pO0m3SnpF0r/IeurdK9QNsDAi3mmizBVAP+D3EbGsibJmjXKSbX2mAO+QjUM2Zh7Zr7oNtkyx1fE20KVkf7PSgxExKSIOIOvRPU2WfJpqT0ObXl7NNjXHpWTt6hMRGwA/AdTEORWn1EjqSjbOfSXw8zQcYrZanGRbmYh4g2wc8hJJh0rqImkdSUMl/TIVux44U9LHJXVP5a9dzUvOBPaRtKWkDYHTGw5I6iHpkDQ2u4xs2GF5mTomAttJ+oqkjpKOBHYEbl3NNjXH+sC/gLdSL/ukVY6/CnziI2dV9jtgRkT8F9lY82Vr3Eprt5xkW6GI+A3ZHNkzgYXAS8ApwP+mIucC04HHgMeBh1Nsda41Gbgh1TWDDyfGOrJZCvPIvnH/LOlLpVXqeA04OJV9jWxmwMERsWh12tRMPyD7Uu1Nsl72Dasc/zkwVtLrko5oqjJJw4AhZEMkkP0cBkg6usVabO2Kb0YwM8uRe7JmZjlykjUzy5GTrJlZjpxkzcxy1KoWx1DHzqFO6xfdDGtBn9qud9FNsBb08ksvsPi1RU3NQ65ahw22inj/IzfdNSr+vXBSRAxpqeuvDa0ryXZan3X7NjnLxtqQCZN/XXQTrAUdsv9eLVpfvP/vZv2df2fmJU3dzdfqtKoka2btjUC1PWrpJGtmxRGgFht9aJWcZM2sWO7JmpnlRVDXoehG5MpJ1syK5eECM7OcCA8XmJnlR+7Jmpnlyj1ZM7McuSdrZpYX34xgZpYf34xgZpYz92TNzPJS+8MFtf3pzKx1E9ChQ/VbU9VJfSXNLNn+Jek7kjaWNFnSnPTaLZWXpNGS5kp6TNKAkrpGpPJzJI0oiQ+U9Hg6Z7RUebzDSdbMiiVVvzUhImZHRP+I6A8MBJYCNwOnAXdHRB/g7rQPMBTok7aRwKVZk7QxMArYHRgEjGpIzKnMyJLzKq5v6yRrZgVKwwXVbs2zH/BsRLwADAPGpvhY4ND0fhgwLjIPAhtJ2hw4EJgcEYsjYgkwGRiSjm0QEVMie9T3uJK6yvKYrJkVq3mzC7pLml6yf3lEXN5I2eHA9el9j4iYDxAR8yVtmuI9gZdKzqlPsUrx+jLxRjnJmlmxmtdDXRQRuzZZpdQJOAQ4vamiZWKxGvFGebjAzIrTnPHY5vV4hwIPR8Sraf/V9Ks+6XVBitcDpQ+i6wXMayLeq0y8UU6yZlasfMZkj+KDoQKACUDDDIERwC0l8WPTLIM9gDfSsMIkYLCkbukLr8HApHTsTUl7pFkFx5bUVZaHC8ysWC18x5ekLsABwDdKwhcAN0o6AXgRODzFJwIHAXPJZiIcBxARiyWdA0xL5c6OiMXp/UnA1UBn4Pa0NcpJ1swK1PI3I0TEUmCTVWKvkc02WLVsACc3Us8YYEyZ+HSgX7XtcZI1s2J57QIzs5z4yQhmZnnygxTNzPLlnqyZWY48JmtmlhPV/lKHTrJmViz3ZM3M8tPEcqxtnpOsmRUme8SXk6yZWT5E+XWtaoiTrJkVSO7JmpnlyUnWzCxHdXWewmVmlg+PyZqZ5UcekzUzy5eTrJlZjpxkzcxy5CRrZpYXf/FlZpYv92TNzHLi2QVmZjmr9SRb27damFnrJlCdqt6qqlLaSNJNkp6W9JSkT0vaWNJkSXPSa7dUVpJGS5or6TFJA0rqGZHKz5E0oiQ+UNLj6ZzRauJfCSdZMyuUpKq3Kv0OuCMitgd2Bp4CTgPujog+wN1pH2Ao0CdtI4FLU5s2BkYBuwODgFENiTmVGVly3pBKjXGSNbNCtWSSlbQBsA9wJUBEvBsRrwPDgLGp2Fjg0PR+GDAuMg8CG0naHDgQmBwRiyNiCTAZGJKObRARUyIigHEldZXlJGtmhWn44qsZSba7pOkl28hVqvwEsBC4StIjkv4o6WNAj4iYD5BeN03lewIvlZxfn2KV4vVl4o3yF19mVqzmfe+1KCJ2rXC8IzAAODUipkr6HR8MDVR79ViNeKPckzWz4qjFx2TrgfqImJr2byJLuq+mX/VJrwtKyvcuOb8XMK+JeK8y8Ua5J7ua+my1KddcePzK/W16bsI5l97Ghut34fjD9mThkrcAGHXxBCbd/yQdO9Zx6c+Opv/2venYoY7rbnuIX4+5E4CnbzuLN99exvIVK3h/+Qo+c/QvAThs/10448SD2H6bHux9zK95+MkX1/4Hbceu+u+LueHaq4gIjvzqcRx/4qkrj11xyW85/+c/YfrTL7HxJt1Xxh99ZDr/OeSzjL7iGg465DAAtu3xMfru0A+ALXr15oprb1q7H6SVa8kpXBHxiqSXJPWNiNnAfsCTaRsBXJBeb0mnTABOkTSe7EuuNyJivqRJwC9KvuwaDJweEYslvSlpD2AqcCzw+0ptcpJdTXNeWMAewy8AoK5OPDvpPCb8/VGOOeTT/P7av3PRNXd/qPx/7j+AdTt1ZLcjfkHn9dbhkT+fyY23T+fF+YsBGDLyd7z2+tsfOmfWs/MY/v0ruPjMo9bOh7KVZj81ixuuvYqbJ93HOp068bUjD+FzBwxlm09uy7yXX+L+e/7GFr16f+ic5cuX88uzz2Tvzx3wofh663XmtnumYuXlME/2VOA6SZ2A54DjyH5rv1HSCcCLwOGp7ETgIGAusDSVJSXTc4BpqdzZEbE4vT8JuBroDNyetkY5ybaAzw3qy/P1C3lx/pJGywRBl/U60aFDHZ3X7cS77y3nzbffqVjv7OdfbemmWpWefeZp+g8cROcuXQDYfc+9uXPiLXzj1O9z7pk/4rRR5zHy2MM/dM7YK/7AgQcfyuOPzCiiyW1XC+fYiJgJlBu33a9M2QBObqSeMcCYMvHpQL9q2+Mx2RZw+IEDufGOD/5inTh8Hx664XQuG3U0G63fGYC/3PUIS995l+cnn8czt5/NRePuZsm/lgIQEfz1D6fwwHU/4vjD9irkM9iHbbfDp3hoyv0sWfwa/166lHvuuoP5L9dz1x23stnmW7BDv50+VP6V+S9z58QJHP21r3+krmXL3uGQ/ffisCH7cOfECWvrI7QZOcyTbVVy7clKGkI2MbgD8MeIuCDP6xVhnY4d+MJn/4Of/T77y3PFn+7j/CtuJwJGffNgLvjeYZx41nXs9qmtWb58BZ8YfAbd1u/CXWO+y9+mPs0/X36Nzx/3W+YvfIOPd+vKrZedwux/vsIDDz9b8Cdr37bdbnu+cer3OfbLB9PlYx9j+0/tRIeOHbnktxcy9k+3fqT8OWf8kB//7Fw6dOjwkWP3z3yGHpttwYv/fJ6jDxtC3x36sdU2n1gbH6PVa8vJs1q59WQldQAuIbujYkfgKEk75nW9ohz4mR2Z+fRLLFj8JgALFr/JihVBRDDmLw+wa7+tADhi6K7c+X9P8v77K1i45C2mzHyOgTtuCcD8hW8AsHDJW0z422Ps9qmtC/ks9mFHfvVr/PVvU7jhr3ex0Ubd6NV7K+pffIEv7DuIvQf05ZV5L/PF/T7Nwldf4fFHH+ZbI49l7wF9uf2vNzPqx99Z2WvtsdkWAGy59Tbssec+zHp8ZpEfq9Wpq6uremuL8mz1IGBuRDwXEe8C48nurqgpRwzZ9UNDBZt132Dl+2Gf35knn50PQP0ri9l3t74AdFmvE4N22prZ/3yVLut1omuXdVfG9//09sx6tuKMEFtLFi3MZvm8XP8ik267hcOOPJppT73IfQ/P5r6HZ7PZFj35691T+HiPzbh3xtMr40O/+CXOuvAiBh90CG+8voRly5YBsPi1RUx/aAp9+u5Q5MdqfdSMrQ3Kc7ig3B0Tu69aKN2xkd21sU7XHJvT8jqvtw6f3317Tjn3+pWx8759KDv17UVE8ML8xZyajl12w71cftZXmXHTGUhwzS0P8sSceWzdcxNu+E02jtexQwduuH06k//vKQAO+dxO/ObHh9O9W1f+MvpEHpv9MoecfMna/6Dt1DePO4rXlyym4zrrcNaFF7HhRt2aPmkVc595mjN+cCp1dXWsWLGCE7/1AyfZVdT6cIGyL9dyqFg6HDgwIv4r7R8DDIqIUxs7p67LprFu3yNyaY8V48nJvy66CdaCDtl/Lx6fOaPFsuK6m/WJXkePrrr8c785aEYTd3y1Onn2ZBu7Y8LMDEijALXdkc11THYa0EfSNmlS8HCyuyvMzJJmLxDT5uTWk42I9yWdAkwim8I1JiJm5XU9M2ub2mjurFqu82QjYiLZbWtmZmW11R5qtXxbrZkVR+7JmpnlRmQLLNUyJ1kzK5STrJlZXjxcYGaWn2yebG1nWSdZMytQ253/Wi0nWTMrVI3nWCdZMyuWe7JmZnnxF19mZvnxF19mZjmr8RzrJGtmxar1nmzbfGiOmdUGZXd8VbtVVaX0T0mPS5opaXqKbSxpsqQ56bVbikvSaElzJT0maUBJPSNS+TmSRpTEB6b656ZzKzbMSdbMCtOwaHe1WzN8LiL6lzxF4TTg7ojoA9yd9iF70GuftI0ELoUsKQOjyB6ZNQgY1ZCYU5mRJecNqdQQJ1kzK9BaW7R7GDA2vR8LHFoSHxeZB4GNJG0OHAhMjojFEbEEmAwMScc2iIgpkT27a1xJXWU5yZpZoZrZk+0uaXrJNrJMlQHcKWlGyfEeETEfIL1umuLlHvjas4l4fZl4o/zFl5kVqpk91EVVPEhxr4iYJ2lTYLKkpytdvkwsViPeKPdkzaw4zejFVpuLI2Jeel0A3Ew2pvpq+lWf9LogFW/sga+V4r3KxBvlJGtmhWm4GaGlxmQlfUzS+g3vgcHAE2QPcW2YITACuCW9nwAcm2YZ7AG8kYYTJgGDJXVLX3gNBialY29K2iPNKji2pK6yPFxgZoVq4XmyPYCbU50dgf+JiDskTQNulHQC8CJweCo/ETgImAssBY4DiIjFks4he+o2wNkRsTi9Pwm4GugM3J62RjnJmlmhWjLHRsRzwM5l4q8B+5WJB3ByI3WNAcaUiU8H+lXbJidZMytUrd/x5SRrZsXxKlxmZvkR1d8u21Y5yZpZoepqvCvrJGtmharxHOska2bFyW4yqO0s6yRrZoWq8SFZJ1kzK1a77clK2qDSiRHxr5Zvjpm1NzWeYyv2ZGfx0VVnGvYD2DLHdplZOyCyaVy1rNEkGxG9GztmZtZSan1MtqpVuCQNl/ST9L6XpIH5NsvM2oVmrMDVVsdum0yyki4GPgcck0JLgcvybJSZtQ8COtSp6q0tqmZ2wZ4RMUDSI7ByCbBOObfLzNqJNtpBrVo1SfY9SXWkRyxI2gRYkWurzKzdaKvDANWqZkz2EuDPwMclnQXcD1yYa6vMrF1ozqNn2moubrInGxHjJM0A9k+hwyPiiXybZWbthReIyXQA3iMbMvBzwcysxdR2iq1udsEZwPXAFmRPZvwfSafn3TAzax9qfQpXNT3ZrwIDI2IpgKTzgBnA+Xk2zMxqn6j9mxGqSbIvrFKuI/BcPs0xs3alDfdQq1VpgZjfko3BLgVmSZqU9geTzTAwM1tjNZ5jK/ZkG2YQzAJuK4k/mF9zzKw9abjjq8XrlToA04GXI+JgSdsA44GNgYeBYyLiXUnrAuOAgcBrwJER8c9Ux+nACcBy4FsRMSnFhwC/I5sQ8MeIuKBSWyotEHPlGn1KM7Mq5DRc8G3gKaBhydYLgd9GxHhJl5Elz0vT65KI2FbS8FTuSEk7AsOBT5F96X+XpO1SXZcABwD1wDRJEyLiycYaUs3sgk9KGi/pMUnPNGyr86nNzFalZmxV1Sf1Ar4A/DHtC/g8cFMqMhY4NL0flvZJx/dL5YcB4yNiWUQ8D8wFBqVtbkQ8FxHvkvWOh1VqTzVzXq8GriL7jEOBG1PFZmZrRMpuRqh2A7pLml6yjSxT7UXAj/jg9v9NgNcj4v20Xw/0TO97Ai8BpONvpPIr46uc01i8UdXMLugSEZMk/ToingXOlHRfFeeZmTWpmaMFiyJi18br0sHAgoiYIWnfhnCZotHEscbi5TqmUSa2UjVJdlnqPj8r6UTgZWDTKs4zM2tSC4/J7gUcIukgYD2yMdmLgI0kdUy91V7AvFS+HugN1EvqCGwILC6JNyg9p7F4WdUMF3wX6Ap8K32ArwPHV3GemVmTWnKBmIg4PSJ6RcTWZF9c/S0ijgb+Dnw5FRsB3JLeT0j7pON/i4hI8eGS1k0zE/oADwHTgD6StklLvg5PZRtVzQIxU9PbN/lg4W4zszUmtLYWiPkxMF7SucAjQMPsqSuBayTNJevBDgeIiFmSbgSeBN4HTo6I5QCSTgEmkU3hGhMRsypduNLNCDdTYawhIg6r7rOZmTUixyUMI+Ie4J70/jmymQGrlnkHOLyR888DzisTnwhMrLYdlXqyF1dbSUvZZYcteWDqWr+smVWpU4dcbhxo8Tpbk0o3I9y9NhtiZu1Tra+dWu16smZmLS6v22pbEydZMytUjefY6pOspHUjYlmejTGz9iWbmlXbWbaatQsGSXocmJP2d5b0+9xbZmbtQp2q39qiasacRwMHky0DRkQ8Cnwuz0aZWfvR7p9WC9RFxAurdOmX59QeM2tHssfPtNHsWaVqkuxLkgYBkRbCPRXwUodm1iI8hQtOIhsy2BJ4FbgrxczM1liNd2SrWrtgAel+XjOzliSttbULCtNkkpV0BWXWMIiIcovlmpk1S43n2KqGC+4qeb8e8CU+vDK4mdlqEdCxrc7NqlI1wwU3lO5LugaYnFuLzKxdcU/2o7YBtmrphphZO9SGbzKoVjVjskv4YEy2jmxh29PybJSZtR+q+jm0bVPFJJue7bUz2XO9AFakRzOYma2x7GaEoluRr4rzgFNCvTkilqfNCdbMWpTXLoCHJA3IvSVm1i5Jqnpriyo946vh8bmfAb4u6VngbbIefkSEE6+ZrZH2MFxQaUz2IWAAcOhaaouZtTdteHWtalUaLhBARDxbbltL7TOzGleXbq2tZmuKpPUkPSTpUUmzJJ2V4ttImippjqQbJHVK8XXT/tx0fOuSuk5P8dmSDiyJD0mxuZKanGlVqSf7cUnfa+xgRPymyU9sZlZB9oyvFq1yGfD5iHhL0jrA/ZJuB74H/DYixku6DDgBuDS9LomIbSUNBy4EjpS0I9maLZ8CtgDukrRdusYlwAFAPTBN0oSIeLKxBlX6eB2ArsD6jWxmZmtI1DVja0pk3kq766QtgM8DN6X4WD4YBh2W9knH90tTV4cB4yNiWUQ8D8wFBqVtbkQ8FxHvAuNT2UZV6snOj4izm/xUZmarSbT8mGxa93oGsC1Zr/NZ4PX0RT5kPdCe6X1P0losEfG+pDeATVL8wZJqS895aZX47pXaUynJ1vhwtJkVrvnzX7tLml6yf3lEXF5aICKWA/0lbQTcDOxQpp6GOf/lrh4V4uV++694/0ClJLtfpRPNzFpCM9eTXRQRu1ZTMCJel3QPsAewUcm01F7AvFSsHugN1EvqCGxItnRAQ7xB6TmNxctqdEw2IhZX80HMzFZXw3BBSz1IUdLHUw8WSZ2B/YGngL8DX07FRgC3pPcT0j7p+N/Sna0TgOFp9sE2QB+yaa3TgD5ptkInsi/HJlRq0+qswmVm1mJa+MkImwNj07hsHXBjRNwq6UlgvKRzgUeAK1P5K4FrJM0l68EOB4iIWZJuBJ4E3gdOTsMQSDoFmEQ2OWBMRMyq1CAnWTMrVEvm2Ih4DNilTPw5spkBq8bfAQ5vpK7zgPPKxCcCE6ttk5OsmRVG+Gm1Zmb5EW124ZdqOcmaWaFqO8U6yZpZgQR0cE/WzCw/NZ5jnWTNrEhtdzHuajnJmllhPLvAzCxn7smameWotlOsk6yZFcnzZM3M8uMxWTOznLkna2aWo9pOsU6yZlYg3/FlZpazGs+xTrJmViShGh8wcJI1s0K5J2tmlpNsCldtZ1knWTMrTpUPSGzLnGTNrFBOsmZmOar1L75q/Y62wn3jv45nyy02ZWD/fitjp//4h+zcb3t222Unjvjyl3j99dcLbKE1pdzP8KxRP2W3XXZi94H9OXjoYObNmwfAvf+4hx6bbMjuA/uz+8D+/OLcs4tqdpsgoE7Vb22Rk2zOjhnxNW659Y4Pxfbb/wBmzHyCaY88Rp8+2/GrC88vqHVWjXI/w+9+/4dMe+Qxps6YydCDDub8kmS612f2ZuqMmUydMZOfnPmztd3cNkfN+K/JuqTekv4u6SlJsyR9O8U3ljRZ0pz02i3FJWm0pLmSHpM0oKSuEan8HEkjSuIDJT2ezhmtJu4LdpLN2Wf23oeNN974Q7H9DxhMx47ZSM2g3ffg5fr6IppmVSr3M9xggw1Wvl+69O2av/8+T3VS1VsV3ge+HxE7AHsAJ0vaETgNuDsi+gB3p32AoUCftI0ELoUsKQOjgN2BQcCohsScyowsOW9Ixc9X5Z+D5WTc1WM4cMjQopthq2HUT89g2216M/766/jpzz/oyU59cAqDBuzMsIOH8uSsWQW2sPVr6eGCiJgfEQ+n928CTwE9gWHA2FRsLHBoej8MGBeZB4GNJG0OHAhMjojFEbEEmAwMScc2iIgpERHAuJK6ysotyUoaI2mBpCfyukZbd+H559GhY0eGf+Xooptiq+Gsc85j7vMvMfyoo7nsDxcD0H+XAcx+9gUeevhRTjr5VI74csW/f9aswQIBdJc0vWQb2WjN0tbALsBUoEdEzIcsEQObpmI9gZdKTqtPsUrx+jLxRuXZk72aJrrR7dm148Yy8bZbuXrcdf5Vs407YvhX+N+b/wxkwwhdu3YFYMjQg3jvvfdYtGhRkc1r3dI82Wo3YFFE7FqyXV62Wqkr8GfgOxHxr8ot+IhYjXijckuyEXEvsDiv+tuyOyfdwf/79YXcdPMEunTpUnRzbDXMnTNn5fvb/jqB7fpuD8Arr7xC9lskTHvoIVasWMEmm2xSSBvbCjVjq6o+aR2yBHtdRPwlhV9Nv+qTXhekeD3Qu+T0XsC8JuK9ysQbVfg82dTdHwnQe8stC25Nyzv2q0dx3z/uYdGiRXxy61789Gdn8atfns+yZcs4eMgBQPbl1+//cFnBLbXGlPsZ3nHHROY8M5s61bHlVlsx+pLs53fzn2/iissvpWOHjqzXuTPjrh3v31QqyMZkW+7PJ33TfyXwVET8puTQBGAEcEF6vaUkfoqk8WRfcr0REfMlTQJ+UfJl12Dg9IhYLOlNSXuQDUMcC/y+Ypsa/tXNQxoTuTUi+jVRFICBA3eNB6ZOz609ZrZm9tp9V2bMmN5iWXGH/9glrrr571WX/3SfbjMiYtfGjkv6DHAf8DiwIoV/QpYQbwS2BF4EDk8JU8DFZEObS4HjImJ6quv4dC7AeRFxVYrvSjYc2hm4HTg1KiTSwnuyZtbOtWBHPyLur1DjfmXKB3ByI3WNAcaUiU8Hquo4gpOsmRXMt9WuJknXA1OAvpLqJZ2Q17XMrO1q5uyCNie3nmxEHJVX3WZWO9po7qyahwvMrDDCjwQ3M8tPGx4GqJaTrJkVqsZzrJOsmRWsxrOsk6yZFciPBDczy5XHZM3MctKchV/aKidZMytWjWdZJ1kzK5THZM3McuQxWTOzvPhmBDOzfHm4wMwsJ9naBUW3Il9OsmZWqBrPsU6yZlawGs+yTrJmViiPyZqZ5chjsmZmOarxHOska2YFq/Esm9uDFM3MmpItEFP9f03WJ42RtEDSEyWxjSVNljQnvXZLcUkaLWmupMckDSg5Z0QqP0fSiJL4QEmPp3NGq4pn5zjJmllxBHXN2KpwNTBkldhpwN0R0Qe4O+0DDAX6pG0kcClkSRkYBewODAJGNSTmVGZkyXmrXusjnGTNrFhqxtaEiLgXWLxKeBgwNr0fCxxaEh8XmQeBjSRtDhwITI6IxRGxBJgMDEnHNsJRaGkAAAYkSURBVIiIKRERwLiSuhrlMVkzK1Czn4zQXdL0kv3LI+LyJs7pERHzASJivqRNU7wn8FJJufoUqxSvLxOvyEnWzArVzClciyJi15a6dJlYrEa8Ig8XmFlhmjNSsAaTEF5Nv+qTXhekeD3Qu6RcL2BeE/FeZeIVOcmaWbHyz7ITgIYZAiOAW0rix6ZZBnsAb6RhhUnAYEnd0hdeg4FJ6dibkvZIswqOLamrUR4uMLNCteRttZKuB/YlG7utJ5slcAFwo6QTgBeBw1PxicBBwFxgKXAcQEQslnQOMC2VOzsiGr5MO4lsBkNn4Pa0VeQka2aFasnbaiPiqEYO7VembAAnN1LPGGBMmfh0oF9z2uQka2aFqvEbvpxkzaxAfvyMmVneajvLOsmaWWFE1bfLtllOsmZWKA8XmJnlyE9GMDPLU23nWCdZMytWjedYJ1kzK448hcvMLF8ekzUzy1Nt51gnWTMrVo3nWCdZMyuWx2TNzHIiRF2NZ1kv2m1mliP3ZM2sUDXekXWSNbNieQqXmVlefDOCmVl+1vAptG2Ck6yZFavGs6yTrJkVymOyZmY58pismVmOajzHOsmaWbFU411ZJ1kzK4yo/eECRUTRbVhJ0kLghaLbsRZ0BxYV3QhrUe3lZ7pVRHy8pSqTdAfZn121FkXEkJa6/trQqpJseyFpekTsWnQ7rOX4Z2qN8QIxZmY5cpI1M8uRk2wxLi+6Adbi/DO1sjwma2aWI/dkzcxy5CRrZpYjJ9m1SNIQSbMlzZV0WtHtsTUnaYykBZKeKLot1jo5ya4lkjoAlwBDgR2BoyTtWGyrrAVcDbSpyfG2djnJrj2DgLkR8VxEvAuMB4YV3CZbQxFxL7C46HZY6+Uku/b0BF4q2a9PMTOrYU6ya0+5ZTA8f86sxjnJrj31QO+S/V7AvILaYmZriZPs2jMN6CNpG0mdgOHAhILbZGY5c5JdSyLifeAUYBLwFHBjRMwqtlW2piRdD0wB+kqql3RC0W2y1sW31ZqZ5cg9WTOzHDnJmpnlyEnWzCxHTrJmZjlykjUzy5GTbA2RtFzSTElPSPqTpC5rUNe+km5N7w+ptGqYpI0kfXM1rvFzST+oNr5KmaslfbkZ19raK2VZEZxka8u/I6J/RPQD3gVOLD2oTLN/5hExISIuqFBkI6DZSdasPXCSrV33AdumHtxTkv4APAz0ljRY0hRJD6ceb1dYud7t05LuBw5rqEjS1yRdnN73kHSzpEfTtidwAfDJ1Iv+VSr3Q0nTJD0m6aySus5Ia+reBfRt6kNI+nqq51FJf16ld76/pPskPSPp4FS+g6RflVz7G2v6B2m2Jpxka5CkjmTr1j6eQn2BcRGxC/A2cCawf0QMAKYD35O0HnAF8EVgb2CzRqofDfwjInYGBgCzgNOAZ1Mv+oeSBgN9yJZ37A8MlLSPpIFktxPvQpbEd6vi4/wlInZL13sKKL2jamvgs8AXgMvSZzgBeCMidkv1f13SNlVcxywXHYtugLWozpJmpvf3AVcCWwAvRMSDKb4H2aLhD0gC6ER2W+j2wPMRMQdA0rXAyDLX+DxwLEBELAfekNRtlTKD0/ZI2u9KlnTXB26OiKXpGtWs3dBP0rlkQxJdyW5LbnBjRKwA5kh6Ln2GwcBOJeO1G6ZrP1PFtcxanJNsbfl3RPQvDaRE+nZpCJgcEUetUq4/Lbf0ooDzI+K/V7nGd1bjGlcDh0bEo5K+BuxbcmzVuiJd+9SIKE3GSNq6mdc1axEeLmh/HgT2krQtgKQukrYDnga2kfTJVO6oRs6/GzgpndtB0gbAm2S91AaTgONLxnp7StoUuBf4kqTOktYnG5poyvrAfEnrAEevcuxwSXWpzZ8AZqdrn5TKI2k7SR+r4jpmuXBPtp2JiIWpR3i9pHVT+MyIeEbSSOA2SYuA+4F+Zar4NnB5Wm1qOXBSREyR9ECaInV7GpfdAZiSetJvAV+NiIcl3QDMBF4gG9Joyk+Bqan843w4mc8G/gH0AE6MiHck/ZFsrPZhZRdfCBxa3Z+OWcvzKlxmZjnycIGZWY6cZM3McuQka2aWIydZM7McOcmameXISdbMLEdOsmZmOfr/88dKKCIZ4YYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lr = LogisticRegression(C = best_c, penalty = 'l1')\n", + "lr.fit(X_train_undersample,y_train_undersample.values.ravel())\n", + "# 代码和上面大致相同,唯一不同的,是这里我们使用的是真实比例\n", + "y_pred = lr.predict(X_test.values)\n", + " \n", + "cnf_matrix = confusion_matrix(y_test,y_pred)\n", + "np.set_printoptions(precision=2)\n", + " \n", + "print(\"召回率: \", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))\n", + "print(\"精确率: \", cnf_matrix[1,1]/(cnf_matrix[0,1]+cnf_matrix[1,1]))\n", + " \n", + "class_names = [0,1]\n", + "plt.figure()\n", + "plot_confusion_matrix(cnf_matrix\n", + " , classes=class_names\n", + " , title='Confusion matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "第一眼看到召回率92.8%貌似不错,但是右上角9433,表示有这么多正常的人被预测为异常,误判了这么多人。也就是精确率低的可怕" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 阈值对结果的影响\n", + "模型会给出对每个样本的预测概率,默认是将0.5以上认为是被预测为异常的,那么如果我们将0.6以上才认定为异常呢?\n", + "\n", + "模型给的概率越高表示越肯定该样本是异常,那么我们可以算下不同阈值的概率,召回率和精确率分别是多少" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "指定的阈值为: 0.1 时,测试集的召回率: 1.00 精确率: 0.497\n", + "指定的阈值为: 0.2 时,测试集的召回率: 1.00 精确率: 0.498\n", + "指定的阈值为: 0.3 时,测试集的召回率: 1.00 精确率: 0.500\n", + "指定的阈值为: 0.4 时,测试集的召回率: 0.98 精确率: 0.634\n", + "指定的阈值为: 0.5 时,测试集的召回率: 0.93 精确率: 0.878\n", + "指定的阈值为: 0.6 时,测试集的召回率: 0.88 精确率: 0.963\n", + "指定的阈值为: 0.7 时,测试集的召回率: 0.84 精确率: 0.992\n", + "指定的阈值为: 0.8 时,测试集的召回率: 0.77 精确率: 1.000\n", + "指定的阈值为: 0.9 时,测试集的召回率: 0.58 精确率: 1.000\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 还是那个模型和正则参数\n", + "lr = LogisticRegression(C = best_c, penalty='l1')\n", + "\n", + "# 训练模型依然是下采样的数据集\n", + "lr.fit(X_train_undersample, y_train_undersample.values.ravel())\n", + "\n", + "# 得到预测的概率\n", + "y_pred_undersample_proba = np.array(lr.predict_proba(X_test_undersample.values))\n", + "\n", + "# 指定不同的阈值\n", + "thresholds = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "\n", + "plt.figure(figsize=(8,8))\n", + "\n", + "j = 1\n", + "\n", + "# 用混淆矩阵来展示图形化结果\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall = y_pred_undersample_proba[:, 1] > i\n", + " \n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + " \n", + " cnf_matrix = confusion_matrix(y_test_undersample,y_test_predictions_high_recall)\n", + " np.set_printoptions(precision=2)\n", + "\n", + " print(\"指定的阈值为: \",i,\"时,测试集的召回率:\", '{0:.2f}'.format(cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))\n", + " ,\"精确率:\", '{0:.3f}'.format(cnf_matrix[1,1]/(cnf_matrix[0,1]+cnf_matrix[1,1])))\n", + " \n", + " class_names = [0,1]\n", + " plot_confusion_matrix(cnf_matrix\n", + " , classes=class_names\n", + " , title='Confusion matrix')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "随着阈值的上升,召回率越来越低,但精确率越来越高,在不可改变的情况下,我们会选择合适的阈值进行业务使用。" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/逻辑回归-信用卡欺诈检测.ipynb b/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/逻辑回归-信用卡欺诈检测.ipynb index 2a506a2..969498f 100644 --- a/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/逻辑回归-信用卡欺诈检测.ipynb +++ b/机器学习竞赛实战_优胜解决方案/信用卡欺诈检测/逻辑回归-信用卡欺诈检测.ipynb @@ -941,19 +941,20 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "召回率: 0.9183673469387755\n" + "召回率: 0.9183673469387755\n", + "精确率: 0.014091858037578288\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVkAAAEmCAYAAADIhuPPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3de7xd07n/8c93J0LSuIRUkMSlFUFziIRQSrWIRFXUKaJKitOUovcLpU3dira/VlPKoUKCI1TrSAkRWnU5EUmISxAJii0hiYQiFSTP7485diyx9tprJ3tm7r329+01X2vNZ4455ljZ8mTsscYcUxGBmZnlo67oBpiZ1TInWTOzHDnJmpnlyEnWzCxHTrJmZjlykjUzy5GTbDsjqbOkv0p6Q9Kf1qCeoyXd2ZJtK4qkvSXNLrodVpvkebKtk6SvAN8DtgfeBGYC50XE/WtY7zHAqcCeEfH+Gje0lZMUQJ+ImFt0W6x9ck+2FZL0PeAi4BdAD2BL4A/AsBaofivgmfaQYKshqWPRbbAaFxHeWtEGbAi8BRxeocy6ZEl4XtouAtZNx/YF6oHvAwuA+cBx6dhZwLvAe+kaJwA/B64tqXtrIICOaf9rwHNkvenngaNL4veXnLcnMA14I73uWXLsHuAc4IFUz51A90Y+W0P7f1TS/kOBg4BngMXAT0rKDwKmAK+nshcDndKxe9NneTt93iNL6v8x8ApwTUMsnfPJdI0BaX8LYBGwb9H/b3hrm5t7sq3Pp4H1gJsrlDkD2APoD+xMlmjOLDm+GVmy7kmWSC+R1C0iRpH1jm+IiK4RcWWlhkj6GDAaGBoR65Ml0pllym0M3JbKbgL8BrhN0iYlxb4CHAdsCnQCflDh0puR/Rn0BH4GXAF8FRgI7A38TNInUtnlwHeB7mR/dvsB3wSIiH1SmZ3T572hpP6NyXr1I0svHBHPkiXg6yR1Aa4Cro6Ieyq016xRTrKtzybAoqj86/zRwNkRsSAiFpL1UI8pOf5eOv5eREwk68X1Xc32rAD6SeocEfMjYlaZMl8A5kTENRHxfkRcDzwNfLGkzFUR8UxE/Bu4kewfiMa8Rzb+/B4wniyB/i4i3kzXnwXsBBARMyLiwXTdfwL/DXy2is80KiKWpfZ8SERcAcwBpgKbk/2jZrZanGRbn9eA7k2MFW4BvFCy/0KKraxjlSS9FOja3IZExNtkv2KfCMyXdJuk7atoT0Obepbsv9KM9rwWEcvT+4Yk+GrJ8X83nC9pO0m3SnpF0r/IeurdK9QNsDAi3mmizBVAP+D3EbGsibJmjXKSbX2mAO+QjUM2Zh7Zr7oNtkyx1fE20KVkf7PSgxExKSIOIOvRPU2WfJpqT0ObXl7NNjXHpWTt6hMRGwA/AdTEORWn1EjqSjbOfSXw8zQcYrZanGRbmYh4g2wc8hJJh0rqImkdSUMl/TIVux44U9LHJXVP5a9dzUvOBPaRtKWkDYHTGw5I6iHpkDQ2u4xs2GF5mTomAttJ+oqkjpKOBHYEbl3NNjXH+sC/gLdSL/ukVY6/CnziI2dV9jtgRkT8F9lY82Vr3Eprt5xkW6GI+A3ZHNkzgYXAS8ApwP+mIucC04HHgMeBh1Nsda41Gbgh1TWDDyfGOrJZCvPIvnH/LOlLpVXqeA04OJV9jWxmwMERsWh12tRMPyD7Uu1Nsl72Dasc/zkwVtLrko5oqjJJw4AhZEMkkP0cBkg6usVabO2Kb0YwM8uRe7JmZjlykjUzy5GTrJlZjpxkzcxy1KoWx1DHzqFO6xfdDGtBn9qud9FNsBb08ksvsPi1RU3NQ65ahw22inj/IzfdNSr+vXBSRAxpqeuvDa0ryXZan3X7NjnLxtqQCZN/XXQTrAUdsv9eLVpfvP/vZv2df2fmJU3dzdfqtKoka2btjUC1PWrpJGtmxRGgFht9aJWcZM2sWO7JmpnlRVDXoehG5MpJ1syK5eECM7OcCA8XmJnlR+7Jmpnlyj1ZM7McuSdrZpYX34xgZpYf34xgZpYz92TNzPJS+8MFtf3pzKx1E9ChQ/VbU9VJfSXNLNn+Jek7kjaWNFnSnPTaLZWXpNGS5kp6TNKAkrpGpPJzJI0oiQ+U9Hg6Z7RUebzDSdbMiiVVvzUhImZHRP+I6A8MBJYCNwOnAXdHRB/g7rQPMBTok7aRwKVZk7QxMArYHRgEjGpIzKnMyJLzKq5v6yRrZgVKwwXVbs2zH/BsRLwADAPGpvhY4ND0fhgwLjIPAhtJ2hw4EJgcEYsjYgkwGRiSjm0QEVMie9T3uJK6yvKYrJkVq3mzC7pLml6yf3lEXN5I2eHA9el9j4iYDxAR8yVtmuI9gZdKzqlPsUrx+jLxRjnJmlmxmtdDXRQRuzZZpdQJOAQ4vamiZWKxGvFGebjAzIrTnPHY5vV4hwIPR8Sraf/V9Ks+6XVBitcDpQ+i6wXMayLeq0y8UU6yZlasfMZkj+KDoQKACUDDDIERwC0l8WPTLIM9gDfSsMIkYLCkbukLr8HApHTsTUl7pFkFx5bUVZaHC8ysWC18x5ekLsABwDdKwhcAN0o6AXgRODzFJwIHAXPJZiIcBxARiyWdA0xL5c6OiMXp/UnA1UBn4Pa0NcpJ1swK1PI3I0TEUmCTVWKvkc02WLVsACc3Us8YYEyZ+HSgX7XtcZI1s2J57QIzs5z4yQhmZnnygxTNzPLlnqyZWY48JmtmlhPV/lKHTrJmViz3ZM3M8tPEcqxtnpOsmRUme8SXk6yZWT5E+XWtaoiTrJkVSO7JmpnlyUnWzCxHdXWewmVmlg+PyZqZ5UcekzUzy5eTrJlZjpxkzcxy5CRrZpYXf/FlZpYv92TNzHLi2QVmZjmr9SRb27damFnrJlCdqt6qqlLaSNJNkp6W9JSkT0vaWNJkSXPSa7dUVpJGS5or6TFJA0rqGZHKz5E0oiQ+UNLj6ZzRauJfCSdZMyuUpKq3Kv0OuCMitgd2Bp4CTgPujog+wN1pH2Ao0CdtI4FLU5s2BkYBuwODgFENiTmVGVly3pBKjXGSNbNCtWSSlbQBsA9wJUBEvBsRrwPDgLGp2Fjg0PR+GDAuMg8CG0naHDgQmBwRiyNiCTAZGJKObRARUyIigHEldZXlJGtmhWn44qsZSba7pOkl28hVqvwEsBC4StIjkv4o6WNAj4iYD5BeN03lewIvlZxfn2KV4vVl4o3yF19mVqzmfe+1KCJ2rXC8IzAAODUipkr6HR8MDVR79ViNeKPckzWz4qjFx2TrgfqImJr2byJLuq+mX/VJrwtKyvcuOb8XMK+JeK8y8Ua5J7ua+my1KddcePzK/W16bsI5l97Ghut34fjD9mThkrcAGHXxBCbd/yQdO9Zx6c+Opv/2venYoY7rbnuIX4+5E4CnbzuLN99exvIVK3h/+Qo+c/QvAThs/10448SD2H6bHux9zK95+MkX1/4Hbceu+u+LueHaq4gIjvzqcRx/4qkrj11xyW85/+c/YfrTL7HxJt1Xxh99ZDr/OeSzjL7iGg465DAAtu3xMfru0A+ALXr15oprb1q7H6SVa8kpXBHxiqSXJPWNiNnAfsCTaRsBXJBeb0mnTABOkTSe7EuuNyJivqRJwC9KvuwaDJweEYslvSlpD2AqcCzw+0ptcpJdTXNeWMAewy8AoK5OPDvpPCb8/VGOOeTT/P7av3PRNXd/qPx/7j+AdTt1ZLcjfkHn9dbhkT+fyY23T+fF+YsBGDLyd7z2+tsfOmfWs/MY/v0ruPjMo9bOh7KVZj81ixuuvYqbJ93HOp068bUjD+FzBwxlm09uy7yXX+L+e/7GFr16f+ic5cuX88uzz2Tvzx3wofh663XmtnumYuXlME/2VOA6SZ2A54DjyH5rv1HSCcCLwOGp7ETgIGAusDSVJSXTc4BpqdzZEbE4vT8JuBroDNyetkY5ybaAzw3qy/P1C3lx/pJGywRBl/U60aFDHZ3X7cS77y3nzbffqVjv7OdfbemmWpWefeZp+g8cROcuXQDYfc+9uXPiLXzj1O9z7pk/4rRR5zHy2MM/dM7YK/7AgQcfyuOPzCiiyW1XC+fYiJgJlBu33a9M2QBObqSeMcCYMvHpQL9q2+Mx2RZw+IEDufGOD/5inTh8Hx664XQuG3U0G63fGYC/3PUIS995l+cnn8czt5/NRePuZsm/lgIQEfz1D6fwwHU/4vjD9irkM9iHbbfDp3hoyv0sWfwa/166lHvuuoP5L9dz1x23stnmW7BDv50+VP6V+S9z58QJHP21r3+krmXL3uGQ/ffisCH7cOfECWvrI7QZOcyTbVVy7clKGkI2MbgD8MeIuCDP6xVhnY4d+MJn/4Of/T77y3PFn+7j/CtuJwJGffNgLvjeYZx41nXs9qmtWb58BZ8YfAbd1u/CXWO+y9+mPs0/X36Nzx/3W+YvfIOPd+vKrZedwux/vsIDDz9b8Cdr37bdbnu+cer3OfbLB9PlYx9j+0/tRIeOHbnktxcy9k+3fqT8OWf8kB//7Fw6dOjwkWP3z3yGHpttwYv/fJ6jDxtC3x36sdU2n1gbH6PVa8vJs1q59WQldQAuIbujYkfgKEk75nW9ohz4mR2Z+fRLLFj8JgALFr/JihVBRDDmLw+wa7+tADhi6K7c+X9P8v77K1i45C2mzHyOgTtuCcD8hW8AsHDJW0z422Ps9qmtC/ks9mFHfvVr/PVvU7jhr3ex0Ubd6NV7K+pffIEv7DuIvQf05ZV5L/PF/T7Nwldf4fFHH+ZbI49l7wF9uf2vNzPqx99Z2WvtsdkWAGy59Tbssec+zHp8ZpEfq9Wpq6uremuL8mz1IGBuRDwXEe8C48nurqgpRwzZ9UNDBZt132Dl+2Gf35knn50PQP0ri9l3t74AdFmvE4N22prZ/3yVLut1omuXdVfG9//09sx6tuKMEFtLFi3MZvm8XP8ik267hcOOPJppT73IfQ/P5r6HZ7PZFj35691T+HiPzbh3xtMr40O/+CXOuvAiBh90CG+8voRly5YBsPi1RUx/aAp9+u5Q5MdqfdSMrQ3Kc7ig3B0Tu69aKN2xkd21sU7XHJvT8jqvtw6f3317Tjn3+pWx8759KDv17UVE8ML8xZyajl12w71cftZXmXHTGUhwzS0P8sSceWzdcxNu+E02jtexQwduuH06k//vKQAO+dxO/ObHh9O9W1f+MvpEHpv9MoecfMna/6Dt1DePO4rXlyym4zrrcNaFF7HhRt2aPmkVc595mjN+cCp1dXWsWLGCE7/1AyfZVdT6cIGyL9dyqFg6HDgwIv4r7R8DDIqIUxs7p67LprFu3yNyaY8V48nJvy66CdaCDtl/Lx6fOaPFsuK6m/WJXkePrrr8c785aEYTd3y1Onn2ZBu7Y8LMDEijALXdkc11THYa0EfSNmlS8HCyuyvMzJJmLxDT5uTWk42I9yWdAkwim8I1JiJm5XU9M2ub2mjurFqu82QjYiLZbWtmZmW11R5qtXxbrZkVR+7JmpnlRmQLLNUyJ1kzK5STrJlZXjxcYGaWn2yebG1nWSdZMytQ253/Wi0nWTMrVI3nWCdZMyuWe7JmZnnxF19mZvnxF19mZjmr8RzrJGtmxar1nmzbfGiOmdUGZXd8VbtVVaX0T0mPS5opaXqKbSxpsqQ56bVbikvSaElzJT0maUBJPSNS+TmSRpTEB6b656ZzKzbMSdbMCtOwaHe1WzN8LiL6lzxF4TTg7ojoA9yd9iF70GuftI0ELoUsKQOjyB6ZNQgY1ZCYU5mRJecNqdQQJ1kzK9BaW7R7GDA2vR8LHFoSHxeZB4GNJG0OHAhMjojFEbEEmAwMScc2iIgpkT27a1xJXWU5yZpZoZrZk+0uaXrJNrJMlQHcKWlGyfEeETEfIL1umuLlHvjas4l4fZl4o/zFl5kVqpk91EVVPEhxr4iYJ2lTYLKkpytdvkwsViPeKPdkzaw4zejFVpuLI2Jeel0A3Ew2pvpq+lWf9LogFW/sga+V4r3KxBvlJGtmhWm4GaGlxmQlfUzS+g3vgcHAE2QPcW2YITACuCW9nwAcm2YZ7AG8kYYTJgGDJXVLX3gNBialY29K2iPNKji2pK6yPFxgZoVq4XmyPYCbU50dgf+JiDskTQNulHQC8CJweCo/ETgImAssBY4DiIjFks4he+o2wNkRsTi9Pwm4GugM3J62RjnJmlmhWjLHRsRzwM5l4q8B+5WJB3ByI3WNAcaUiU8H+lXbJidZMytUrd/x5SRrZsXxKlxmZvkR1d8u21Y5yZpZoepqvCvrJGtmharxHOska2bFyW4yqO0s6yRrZoWq8SFZJ1kzK1a77clK2qDSiRHxr5Zvjpm1NzWeYyv2ZGfx0VVnGvYD2DLHdplZOyCyaVy1rNEkGxG9GztmZtZSan1MtqpVuCQNl/ST9L6XpIH5NsvM2oVmrMDVVsdum0yyki4GPgcck0JLgcvybJSZtQ8COtSp6q0tqmZ2wZ4RMUDSI7ByCbBOObfLzNqJNtpBrVo1SfY9SXWkRyxI2gRYkWurzKzdaKvDANWqZkz2EuDPwMclnQXcD1yYa6vMrF1ozqNn2moubrInGxHjJM0A9k+hwyPiiXybZWbthReIyXQA3iMbMvBzwcysxdR2iq1udsEZwPXAFmRPZvwfSafn3TAzax9qfQpXNT3ZrwIDI2IpgKTzgBnA+Xk2zMxqn6j9mxGqSbIvrFKuI/BcPs0xs3alDfdQq1VpgZjfko3BLgVmSZqU9geTzTAwM1tjNZ5jK/ZkG2YQzAJuK4k/mF9zzKw9abjjq8XrlToA04GXI+JgSdsA44GNgYeBYyLiXUnrAuOAgcBrwJER8c9Ux+nACcBy4FsRMSnFhwC/I5sQ8MeIuKBSWyotEHPlGn1KM7Mq5DRc8G3gKaBhydYLgd9GxHhJl5Elz0vT65KI2FbS8FTuSEk7AsOBT5F96X+XpO1SXZcABwD1wDRJEyLiycYaUs3sgk9KGi/pMUnPNGyr86nNzFalZmxV1Sf1Ar4A/DHtC/g8cFMqMhY4NL0flvZJx/dL5YcB4yNiWUQ8D8wFBqVtbkQ8FxHvkvWOh1VqTzVzXq8GriL7jEOBG1PFZmZrRMpuRqh2A7pLml6yjSxT7UXAj/jg9v9NgNcj4v20Xw/0TO97Ai8BpONvpPIr46uc01i8UdXMLugSEZMk/ToingXOlHRfFeeZmTWpmaMFiyJi18br0sHAgoiYIWnfhnCZotHEscbi5TqmUSa2UjVJdlnqPj8r6UTgZWDTKs4zM2tSC4/J7gUcIukgYD2yMdmLgI0kdUy91V7AvFS+HugN1EvqCGwILC6JNyg9p7F4WdUMF3wX6Ap8K32ArwPHV3GemVmTWnKBmIg4PSJ6RcTWZF9c/S0ijgb+Dnw5FRsB3JLeT0j7pON/i4hI8eGS1k0zE/oADwHTgD6StklLvg5PZRtVzQIxU9PbN/lg4W4zszUmtLYWiPkxMF7SucAjQMPsqSuBayTNJevBDgeIiFmSbgSeBN4HTo6I5QCSTgEmkU3hGhMRsypduNLNCDdTYawhIg6r7rOZmTUixyUMI+Ie4J70/jmymQGrlnkHOLyR888DzisTnwhMrLYdlXqyF1dbSUvZZYcteWDqWr+smVWpU4dcbhxo8Tpbk0o3I9y9NhtiZu1Tra+dWu16smZmLS6v22pbEydZMytUjefY6pOspHUjYlmejTGz9iWbmlXbWbaatQsGSXocmJP2d5b0+9xbZmbtQp2q39qiasacRwMHky0DRkQ8Cnwuz0aZWfvR7p9WC9RFxAurdOmX59QeM2tHssfPtNHsWaVqkuxLkgYBkRbCPRXwUodm1iI8hQtOIhsy2BJ4FbgrxczM1liNd2SrWrtgAel+XjOzliSttbULCtNkkpV0BWXWMIiIcovlmpk1S43n2KqGC+4qeb8e8CU+vDK4mdlqEdCxrc7NqlI1wwU3lO5LugaYnFuLzKxdcU/2o7YBtmrphphZO9SGbzKoVjVjskv4YEy2jmxh29PybJSZtR+q+jm0bVPFJJue7bUz2XO9AFakRzOYma2x7GaEoluRr4rzgFNCvTkilqfNCdbMWpTXLoCHJA3IvSVm1i5Jqnpriyo946vh8bmfAb4u6VngbbIefkSEE6+ZrZH2MFxQaUz2IWAAcOhaaouZtTdteHWtalUaLhBARDxbbltL7TOzGleXbq2tZmuKpPUkPSTpUUmzJJ2V4ttImippjqQbJHVK8XXT/tx0fOuSuk5P8dmSDiyJD0mxuZKanGlVqSf7cUnfa+xgRPymyU9sZlZB9oyvFq1yGfD5iHhL0jrA/ZJuB74H/DYixku6DDgBuDS9LomIbSUNBy4EjpS0I9maLZ8CtgDukrRdusYlwAFAPTBN0oSIeLKxBlX6eB2ArsD6jWxmZmtI1DVja0pk3kq766QtgM8DN6X4WD4YBh2W9knH90tTV4cB4yNiWUQ8D8wFBqVtbkQ8FxHvAuNT2UZV6snOj4izm/xUZmarSbT8mGxa93oGsC1Zr/NZ4PX0RT5kPdCe6X1P0losEfG+pDeATVL8wZJqS895aZX47pXaUynJ1vhwtJkVrvnzX7tLml6yf3lEXF5aICKWA/0lbQTcDOxQpp6GOf/lrh4V4uV++694/0ClJLtfpRPNzFpCM9eTXRQRu1ZTMCJel3QPsAewUcm01F7AvFSsHugN1EvqCGxItnRAQ7xB6TmNxctqdEw2IhZX80HMzFZXw3BBSz1IUdLHUw8WSZ2B/YGngL8DX07FRgC3pPcT0j7p+N/Sna0TgOFp9sE2QB+yaa3TgD5ptkInsi/HJlRq0+qswmVm1mJa+MkImwNj07hsHXBjRNwq6UlgvKRzgUeAK1P5K4FrJM0l68EOB4iIWZJuBJ4E3gdOTsMQSDoFmEQ2OWBMRMyq1CAnWTMrVEvm2Ih4DNilTPw5spkBq8bfAQ5vpK7zgPPKxCcCE6ttk5OsmRVG+Gm1Zmb5EW124ZdqOcmaWaFqO8U6yZpZgQR0cE/WzCw/NZ5jnWTNrEhtdzHuajnJmllhPLvAzCxn7smameWotlOsk6yZFcnzZM3M8uMxWTOznLkna2aWo9pOsU6yZlYg3/FlZpazGs+xTrJmViShGh8wcJI1s0K5J2tmlpNsCldtZ1knWTMrTpUPSGzLnGTNrFBOsmZmOar1L75q/Y62wn3jv45nyy02ZWD/fitjp//4h+zcb3t222Unjvjyl3j99dcLbKE1pdzP8KxRP2W3XXZi94H9OXjoYObNmwfAvf+4hx6bbMjuA/uz+8D+/OLcs4tqdpsgoE7Vb22Rk2zOjhnxNW659Y4Pxfbb/wBmzHyCaY88Rp8+2/GrC88vqHVWjXI/w+9+/4dMe+Qxps6YydCDDub8kmS612f2ZuqMmUydMZOfnPmztd3cNkfN+K/JuqTekv4u6SlJsyR9O8U3ljRZ0pz02i3FJWm0pLmSHpM0oKSuEan8HEkjSuIDJT2ezhmtJu4LdpLN2Wf23oeNN974Q7H9DxhMx47ZSM2g3ffg5fr6IppmVSr3M9xggw1Wvl+69O2av/8+T3VS1VsV3ge+HxE7AHsAJ0vaETgNuDsi+gB3p32AoUCftI0ELoUsKQOjgN2BQcCohsScyowsOW9Ixc9X5Z+D5WTc1WM4cMjQopthq2HUT89g2216M/766/jpzz/oyU59cAqDBuzMsIOH8uSsWQW2sPVr6eGCiJgfEQ+n928CTwE9gWHA2FRsLHBoej8MGBeZB4GNJG0OHAhMjojFEbEEmAwMScc2iIgpERHAuJK6ysotyUoaI2mBpCfyukZbd+H559GhY0eGf+Xooptiq+Gsc85j7vMvMfyoo7nsDxcD0H+XAcx+9gUeevhRTjr5VI74csW/f9aswQIBdJc0vWQb2WjN0tbALsBUoEdEzIcsEQObpmI9gZdKTqtPsUrx+jLxRuXZk72aJrrR7dm148Yy8bZbuXrcdf5Vs407YvhX+N+b/wxkwwhdu3YFYMjQg3jvvfdYtGhRkc1r3dI82Wo3YFFE7FqyXV62Wqkr8GfgOxHxr8ot+IhYjXijckuyEXEvsDiv+tuyOyfdwf/79YXcdPMEunTpUnRzbDXMnTNn5fvb/jqB7fpuD8Arr7xC9lskTHvoIVasWMEmm2xSSBvbCjVjq6o+aR2yBHtdRPwlhV9Nv+qTXhekeD3Qu+T0XsC8JuK9ysQbVfg82dTdHwnQe8stC25Nyzv2q0dx3z/uYdGiRXxy61789Gdn8atfns+yZcs4eMgBQPbl1+//cFnBLbXGlPsZ3nHHROY8M5s61bHlVlsx+pLs53fzn2/iissvpWOHjqzXuTPjrh3v31QqyMZkW+7PJ33TfyXwVET8puTQBGAEcEF6vaUkfoqk8WRfcr0REfMlTQJ+UfJl12Dg9IhYLOlNSXuQDUMcC/y+Ypsa/tXNQxoTuTUi+jVRFICBA3eNB6ZOz609ZrZm9tp9V2bMmN5iWXGH/9glrrr571WX/3SfbjMiYtfGjkv6DHAf8DiwIoV/QpYQbwS2BF4EDk8JU8DFZEObS4HjImJ6quv4dC7AeRFxVYrvSjYc2hm4HTg1KiTSwnuyZtbOtWBHPyLur1DjfmXKB3ByI3WNAcaUiU8Hquo4gpOsmRXMt9WuJknXA1OAvpLqJZ2Q17XMrO1q5uyCNie3nmxEHJVX3WZWO9po7qyahwvMrDDCjwQ3M8tPGx4GqJaTrJkVqsZzrJOsmRWsxrOsk6yZFciPBDczy5XHZM3MctKchV/aKidZMytWjWdZJ1kzK5THZM3McuQxWTOzvPhmBDOzfHm4wMwsJ9naBUW3Il9OsmZWqBrPsU6yZlawGs+yTrJmViiPyZqZ5chjsmZmOarxHOska2YFq/Esm9uDFM3MmpItEFP9f03WJ42RtEDSEyWxjSVNljQnvXZLcUkaLWmupMckDSg5Z0QqP0fSiJL4QEmPp3NGq4pn5zjJmllxBHXN2KpwNTBkldhpwN0R0Qe4O+0DDAX6pG0kcClkSRkYBewODAJGNSTmVGZkyXmrXusjnGTNrFhqxtaEiLgXWLxKeBgwNr0fCxxaEh8XmQeBjSRtDhwITI6IxRGxBJgMDEnHNsJRaGkAAAYkSURBVIiIKRERwLiSuhrlMVkzK1Czn4zQXdL0kv3LI+LyJs7pERHzASJivqRNU7wn8FJJufoUqxSvLxOvyEnWzArVzClciyJi15a6dJlYrEa8Ig8XmFlhmjNSsAaTEF5Nv+qTXhekeD3Qu6RcL2BeE/FeZeIVOcmaWbHyz7ITgIYZAiOAW0rix6ZZBnsAb6RhhUnAYEnd0hdeg4FJ6dibkvZIswqOLamrUR4uMLNCteRttZKuB/YlG7utJ5slcAFwo6QTgBeBw1PxicBBwFxgKXAcQEQslnQOMC2VOzsiGr5MO4lsBkNn4Pa0VeQka2aFasnbaiPiqEYO7VembAAnN1LPGGBMmfh0oF9z2uQka2aFqvEbvpxkzaxAfvyMmVneajvLOsmaWWFE1bfLtllOsmZWKA8XmJnlyE9GMDPLU23nWCdZMytWjedYJ1kzK448hcvMLF8ekzUzy1Nt51gnWTMrVo3nWCdZMyuWx2TNzHIiRF2NZ1kv2m1mliP3ZM2sUDXekXWSNbNieQqXmVlefDOCmVl+1vAptG2Ck6yZFavGs6yTrJkVymOyZmY58pismVmOajzHOsmaWbFU411ZJ1kzK4yo/eECRUTRbVhJ0kLghaLbsRZ0BxYV3QhrUe3lZ7pVRHy8pSqTdAfZn121FkXEkJa6/trQqpJseyFpekTsWnQ7rOX4Z2qN8QIxZmY5cpI1M8uRk2wxLi+6Adbi/DO1sjwma2aWI/dkzcxy5CRrZpYjJ9m1SNIQSbMlzZV0WtHtsTUnaYykBZKeKLot1jo5ya4lkjoAlwBDgR2BoyTtWGyrrAVcDbSpyfG2djnJrj2DgLkR8VxEvAuMB4YV3CZbQxFxL7C46HZY6+Uku/b0BF4q2a9PMTOrYU6ya0+5ZTA8f86sxjnJrj31QO+S/V7AvILaYmZriZPs2jMN6CNpG0mdgOHAhILbZGY5c5JdSyLifeAUYBLwFHBjRMwqtlW2piRdD0wB+kqql3RC0W2y1sW31ZqZ5cg9WTOzHDnJmpnlyEnWzCxHTrJmZjlykjUzy5GTbA2RtFzSTElPSPqTpC5rUNe+km5N7w+ptGqYpI0kfXM1rvFzST+oNr5KmaslfbkZ19raK2VZEZxka8u/I6J/RPQD3gVOLD2oTLN/5hExISIuqFBkI6DZSdasPXCSrV33AdumHtxTkv4APAz0ljRY0hRJD6ceb1dYud7t05LuBw5rqEjS1yRdnN73kHSzpEfTtidwAfDJ1Iv+VSr3Q0nTJD0m6aySus5Ia+reBfRt6kNI+nqq51FJf16ld76/pPskPSPp4FS+g6RflVz7G2v6B2m2Jpxka5CkjmTr1j6eQn2BcRGxC/A2cCawf0QMAKYD35O0HnAF8EVgb2CzRqofDfwjInYGBgCzgNOAZ1Mv+oeSBgN9yJZ37A8MlLSPpIFktxPvQpbEd6vi4/wlInZL13sKKL2jamvgs8AXgMvSZzgBeCMidkv1f13SNlVcxywXHYtugLWozpJmpvf3AVcCWwAvRMSDKb4H2aLhD0gC6ER2W+j2wPMRMQdA0rXAyDLX+DxwLEBELAfekNRtlTKD0/ZI2u9KlnTXB26OiKXpGtWs3dBP0rlkQxJdyW5LbnBjRKwA5kh6Ln2GwcBOJeO1G6ZrP1PFtcxanJNsbfl3RPQvDaRE+nZpCJgcEUetUq4/Lbf0ooDzI+K/V7nGd1bjGlcDh0bEo5K+BuxbcmzVuiJd+9SIKE3GSNq6mdc1axEeLmh/HgT2krQtgKQukrYDnga2kfTJVO6oRs6/GzgpndtB0gbAm2S91AaTgONLxnp7StoUuBf4kqTOktYnG5poyvrAfEnrAEevcuxwSXWpzZ8AZqdrn5TKI2k7SR+r4jpmuXBPtp2JiIWpR3i9pHVT+MyIeEbSSOA2SYuA+4F+Zar4NnB5Wm1qOXBSREyR9ECaInV7GpfdAZiSetJvAV+NiIcl3QDMBF4gG9Joyk+Bqan843w4mc8G/gH0AE6MiHck/ZFsrPZhZRdfCBxa3Z+OWcvzKlxmZjnycIGZWY6cZM3McuQka2aWIydZM7McOcmameXISdbMLEdOsmZmOfr/88dKKCIZ4YYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -974,6 +975,7 @@ "np.set_printoptions(precision=2)\n", " \n", "print(\"召回率: \", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))\n", + "print(\"精确率: \", cnf_matrix[1,1]/(cnf_matrix[0,1]+cnf_matrix[1,1]))\n", " \n", "class_names = [0,1]\n", "plt.figure()\n", @@ -987,7 +989,93 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "第一眼看到召回率92.8%貌似不错,但是右上角9433,表示有这么多正常的人被预测为异常,误判了这么多人。" + "第一眼看到召回率92.8%貌似不错,但是右上角9433,表示有这么多正常的人被预测为异常,误判了这么多人。也就是精确率低的可怕" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 阈值对结果的影响\n", + "模型会给出对每个样本的预测概率,默认是将0.5以上认为是被预测为异常的,那么如果我们将0.6以上才认定为异常呢?\n", + "\n", + "模型给的概率越高表示越肯定该样本是异常,那么我们可以算下不同阈值的概率,召回率和精确率分别是多少" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "指定的阈值为: 0.1 时,测试集的召回率: 1.00 精确率: 0.497\n", + "指定的阈值为: 0.2 时,测试集的召回率: 1.00 精确率: 0.498\n", + "指定的阈值为: 0.3 时,测试集的召回率: 1.00 精确率: 0.500\n", + "指定的阈值为: 0.4 时,测试集的召回率: 0.98 精确率: 0.634\n", + "指定的阈值为: 0.5 时,测试集的召回率: 0.93 精确率: 0.878\n", + "指定的阈值为: 0.6 时,测试集的召回率: 0.88 精确率: 0.963\n", + "指定的阈值为: 0.7 时,测试集的召回率: 0.84 精确率: 0.992\n", + "指定的阈值为: 0.8 时,测试集的召回率: 0.77 精确率: 1.000\n", + "指定的阈值为: 0.9 时,测试集的召回率: 0.58 精确率: 1.000\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 还是那个模型和正则参数\n", + "lr = LogisticRegression(C = best_c, penalty='l1')\n", + "\n", + "# 训练模型依然是下采样的数据集\n", + "lr.fit(X_train_undersample, y_train_undersample.values.ravel())\n", + "\n", + "# 得到预测的概率\n", + "y_pred_undersample_proba = np.array(lr.predict_proba(X_test_undersample.values))\n", + "\n", + "# 指定不同的阈值\n", + "thresholds = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "\n", + "plt.figure(figsize=(8,8))\n", + "\n", + "j = 1\n", + "\n", + "# 用混淆矩阵来展示图形化结果\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall = y_pred_undersample_proba[:, 1] > i\n", + " \n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + " \n", + " cnf_matrix = confusion_matrix(y_test_undersample,y_test_predictions_high_recall)\n", + " np.set_printoptions(precision=2)\n", + "\n", + " print(\"指定的阈值为: \",i,\"时,测试集的召回率:\", '{0:.2f}'.format(cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))\n", + " ,\"精确率:\", '{0:.3f}'.format(cnf_matrix[1,1]/(cnf_matrix[0,1]+cnf_matrix[1,1])))\n", + " \n", + " class_names = [0,1]\n", + " plot_confusion_matrix(cnf_matrix\n", + " , classes=class_names\n", + " , title='Confusion matrix')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "随着阈值的上升,召回率越来越低,但精确率越来越高,在不可改变的情况下,我们会选择合适的阈值进行业务使用。" ] }, {