diff --git a/大众点评数据集分析/第七组/第七组实践代码/垃圾邮件在线识别.zip b/大众点评数据集分析/第七组/第七组实践代码/垃圾邮件在线识别.zip new file mode 100644 index 0000000..2597fe4 Binary files /dev/null and b/大众点评数据集分析/第七组/第七组实践代码/垃圾邮件在线识别.zip differ diff --git a/大众点评数据集分析/第七组/第七组实践代码/泰坦尼克号.ipynb b/大众点评数据集分析/第七组/第七组实践代码/泰坦尼克号.ipynb new file mode 100644 index 0000000..94d4609 --- /dev/null +++ b/大众点评数据集分析/第七组/第七组实践代码/泰坦尼克号.ipynb @@ -0,0 +1,2788 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import itertools\n", + "from scipy import stats,integrate\n", + "plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签\n", + "plt.rcParams['axes.unicode_minus']=False #用来正常显示负号" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 1 数据预处理" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PassengerIdSurvivedPclassNameSexAgeSibSpParchTicketFareCabinEmbarked
0103Braund, Mr. Owen Harrismale22.010A/5 211717.2500NaNS
1211Cumings, Mrs. John Bradley (Florence Briggs Th...female38.010PC 1759971.2833C85C
2313Heikkinen, Miss. Lainafemale26.000STON/O2. 31012827.9250NaNS
3411Futrelle, Mrs. Jacques Heath (Lily May Peel)female35.01011380353.1000C123S
4503Allen, Mr. William Henrymale35.0003734508.0500NaNS
\n", + "
" + ], + "text/plain": [ + " PassengerId Survived Pclass \\\n", + "0 1 0 3 \n", + "1 2 1 1 \n", + "2 3 1 3 \n", + "3 4 1 1 \n", + "4 5 0 3 \n", + "\n", + " Name Sex Age SibSp \\\n", + "0 Braund, Mr. Owen Harris male 22.0 1 \n", + "1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 \n", + "2 Heikkinen, Miss. Laina female 26.0 0 \n", + "3 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 \n", + "4 Allen, Mr. William Henry male 35.0 0 \n", + "\n", + " Parch Ticket Fare Cabin Embarked \n", + "0 0 A/5 21171 7.2500 NaN S \n", + "1 0 PC 17599 71.2833 C85 C \n", + "2 0 STON/O2. 3101282 7.9250 NaN S \n", + "3 0 113803 53.1000 C123 S \n", + "4 0 373450 8.0500 NaN S " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 导入,读取数据\n", + "titanic_df = pd.read_csv(r'C:\\Users\\tyvw\\Desktop\\train.csv')\n", + "titanic_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "数据集的属性列表:\n", + "- PassengerId – 乘客编号,每个ID对应与唯一的乘客\n", + "- Pclass – 船舱等级,1 一等舱,2 二等舱,3 三等舱\n", + "- Sex – 乘客性别,0 男性,1 女性\n", + "- Age – 乘客年龄\n", + "- SibSp - 同辈亲属数量(比如兄弟姐妹或者配偶)\n", + "- Parch – 非同辈亲属数量(比如父母和子女)\n", + "- Fare – 船票价格\n", + "- Embarked – 上船的港口,0S (South Ampton), 1C (Cherbourg), 2Q (Queenstown)\n", + "\n", + "数据集的标签:\n", + "- Survived – 该乘客是否幸存, 0 遇难,1幸存" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 891 entries, 0 to 890\n", + "Data columns (total 12 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 PassengerId 891 non-null int64 \n", + " 1 Survived 891 non-null int64 \n", + " 2 Pclass 891 non-null int64 \n", + " 3 Name 891 non-null object \n", + " 4 Sex 891 non-null object \n", + " 5 Age 714 non-null float64\n", + " 6 SibSp 891 non-null int64 \n", + " 7 Parch 891 non-null int64 \n", + " 8 Ticket 891 non-null object \n", + " 9 Fare 891 non-null float64\n", + " 10 Cabin 204 non-null object \n", + " 11 Embarked 889 non-null object \n", + "dtypes: float64(2), int64(5), object(5)\n", + "memory usage: 83.7+ KB\n" + ] + } + ], + "source": [ + "# 观察数据完整性\n", + "titanic_df.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "有三个属性存在数据缺失:**Age,Cabin 和 Embarked\n", + "**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PassengerIdSurvivedPclassAgeSibSpParchFare
count891.000000891.000000891.000000714.000000891.000000891.000000891.000000
mean446.0000000.3838382.30864229.6991180.5230080.38159432.204208
std257.3538420.4865920.83607114.5264971.1027430.80605749.693429
min1.0000000.0000001.0000000.4200000.0000000.0000000.000000
25%223.5000000.0000002.00000020.1250000.0000000.0000007.910400
50%446.0000000.0000003.00000028.0000000.0000000.00000014.454200
75%668.5000001.0000003.00000038.0000001.0000000.00000031.000000
max891.0000001.0000003.00000080.0000008.0000006.000000512.329200
\n", + "
" + ], + "text/plain": [ + " PassengerId Survived Pclass Age SibSp \\\n", + "count 891.000000 891.000000 891.000000 714.000000 891.000000 \n", + "mean 446.000000 0.383838 2.308642 29.699118 0.523008 \n", + "std 257.353842 0.486592 0.836071 14.526497 1.102743 \n", + "min 1.000000 0.000000 1.000000 0.420000 0.000000 \n", + "25% 223.500000 0.000000 2.000000 20.125000 0.000000 \n", + "50% 446.000000 0.000000 3.000000 28.000000 0.000000 \n", + "75% 668.500000 1.000000 3.000000 38.000000 1.000000 \n", + "max 891.000000 1.000000 3.000000 80.000000 8.000000 \n", + "\n", + " Parch Fare \n", + "count 891.000000 891.000000 \n", + "mean 0.381594 32.204208 \n", + "std 0.806057 49.693429 \n", + "min 0.000000 0.000000 \n", + "25% 0.000000 7.910400 \n", + "50% 0.000000 14.454200 \n", + "75% 0.000000 31.000000 \n", + "max 6.000000 512.329200 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 观察数据基本统计信息\n", + "titanic_df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "
\n", + "\n", + "## 1.1 属性分析\n", + "\n", + "- PassengerId – 随机赋予的乘客编号;理论上与该乘客是否存活不存在任何关联关系,所以**删除PassengerId属性**\n", + "- Name - 乘客姓名,同上,无关属性\n", + "- Pclass – 船舱等级;与是否存活下来有关\n", + "- Sex – 乘客性别;与是否存活下来有关\n", + "- Age – 乘客年龄;与是否存活下来有关\n", + "- SibSp - 同辈亲属数量;与是否存活下来有关\n", + "- Parch – 非同辈亲属数量;与是否存活下来有关\n", + "- Fare – 船票价格;与是否存活下来有关\n", + "- Embarked – 上船的港口,0S (South Ampton), 1C (Cherbourg), 2Q (Queenstown)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SurvivedPclassSexAgeSibSpParchTicketFareCabinEmbarked
003male22.010A/5 211717.2500NaNS
111female38.010PC 1759971.2833C85C
213female26.000STON/O2. 31012827.9250NaNS
311female35.01011380353.1000C123S
403male35.0003734508.0500NaNS
\n", + "
" + ], + "text/plain": [ + " Survived Pclass Sex Age SibSp Parch Ticket Fare \\\n", + "0 0 3 male 22.0 1 0 A/5 21171 7.2500 \n", + "1 1 1 female 38.0 1 0 PC 17599 71.2833 \n", + "2 1 3 female 26.0 0 0 STON/O2. 3101282 7.9250 \n", + "3 1 1 female 35.0 1 0 113803 53.1000 \n", + "4 0 3 male 35.0 0 0 373450 8.0500 \n", + "\n", + " Cabin Embarked \n", + "0 NaN S \n", + "1 C85 C \n", + "2 NaN S \n", + "3 C123 S \n", + "4 NaN S " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 从数据集中删除PassengerId,Name变量\n", + "titanic_df.drop(['PassengerId','Name'], axis=1, inplace=True)\n", + "# 观察更新后的数据\n", + "titanic_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\tyvw\\AppData\\Local\\Temp\\ipykernel_4636\\1366697872.py:1: FutureWarning: In a future version of pandas all arguments of Series.dropna will be keyword-only.\n", + " titanic_df[\"Embarked\"] = titanic_df[\"Embarked\"].dropna(0)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "titanic_df[\"Embarked\"] = titanic_df[\"Embarked\"].dropna(0)\n", + "\n", + "f, ax = plt.subplots(figsize = (8, 6))\n", + "sns.countplot(x=\"Embarked\", data=titanic_df,hue=\"Survived\") # hue=\"Survived\"\n", + "ax.set_xticklabels([\"South Ampton\",\"Cherbourg\",\"Queenstown\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EmbarkedSurvived
0C0.553571
1Q0.389610
2S0.336957
\n", + "
" + ], + "text/plain": [ + " Embarked Survived\n", + "0 C 0.553571\n", + "1 Q 0.389610\n", + "2 S 0.336957" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 分析不同码头上船的乘客们的生存几率\n", + "titanic_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False).mean().sort_values(by='Embarked', ascending=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### Age | 存在多项缺失值,由于年龄是数值型数据,运用随机森林进行预测填充" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestRegressor" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\Anaconda\\lib\\site-packages\\sklearn\\base.py:439: UserWarning: X does not have valid feature names, but RandomForestRegressor was fitted with feature names\n", + " warnings.warn(\n", + "C:\\Users\\tyvw\\AppData\\Local\\Temp\\ipykernel_4636\\1365361757.py:17: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(titanic_df[\"Age\"].dropna(), kde=True, bins=50, fit=stats.gamma)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "age_df = titanic_df[[\"Age\", \"Fare\", \"Parch\", \"SibSp\", \"Pclass\"]].copy() # .copy()用于复制原始数据 挑选数值型字段\n", + "\n", + "# 分割有缺失值的数据集\n", + "age_df_notnull = age_df.loc[age_df.Age.notnull()]\n", + "age_df_isnull = age_df.loc[age_df.Age.isnull()]\n", + "\n", + "# 利用非缺失数据建模\n", + "x = age_df_notnull.iloc[:, 1:]\n", + "y = age_df_notnull.values[:, 0]\n", + "x_test = age_df_isnull.values[:, 1:]\n", + "\n", + "rfr = RandomForestRegressor(n_estimators=1000, n_jobs=-1)\n", + "rfr.fit(x, y)\n", + "y_pred = rfr.predict(x_test)\n", + "\n", + "titanic_df.loc[titanic_df[\"Age\"].isnull(), \"Age\"] = y_pred\n", + "sns.distplot(titanic_df[\"Age\"].dropna(), kde=True, bins=50, fit=stats.gamma)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### 对Age属性的进一步处理尝试:划分为多个年龄段" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AgeLevelSurvived
0(0.34, 20.315]0.428571
1(20.315, 40.21]0.369732
2(40.21, 60.105]0.395833
3(60.105, 80.0]0.227273
\n", + "
" + ], + "text/plain": [ + " AgeLevel Survived\n", + "0 (0.34, 20.315] 0.428571\n", + "1 (20.315, 40.21] 0.369732\n", + "2 (40.21, 60.105] 0.395833\n", + "3 (60.105, 80.0] 0.227273" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "titanic_df['AgeLevel'] = pd.cut(titanic_df['Age'], 4)\n", + "titanic_df[['AgeLevel', 'Survived']].groupby(['AgeLevel'], as_index=False).mean().sort_values(by='AgeLevel', ascending=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SurvivedPclassSexAgeSibSpParchTicketFareCabinEmbarked
003male110A/5 211717.2500NaNS
111female110PC 1759971.2833C85C
213female100STON/O2. 31012827.9250NaNS
311female11011380353.1000C123S
403male1003734508.0500NaNS
\n", + "
" + ], + "text/plain": [ + " Survived Pclass Sex Age SibSp Parch Ticket Fare \\\n", + "0 0 3 male 1 1 0 A/5 21171 7.2500 \n", + "1 1 1 female 1 1 0 PC 17599 71.2833 \n", + "2 1 3 female 1 0 0 STON/O2. 3101282 7.9250 \n", + "3 1 1 female 1 1 0 113803 53.1000 \n", + "4 0 3 male 1 0 0 373450 8.0500 \n", + "\n", + " Cabin Embarked \n", + "0 NaN S \n", + "1 C85 C \n", + "2 NaN S \n", + "3 C123 S \n", + "4 NaN S " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "titanic_df.loc[titanic_df['Age'] <= 20.315, 'Age'] = 0\n", + "titanic_df.loc[(titanic_df['Age'] > 20.315) & (titanic_df['Age'] <= 40.21), 'Age'] = 1\n", + "titanic_df.loc[(titanic_df['Age'] > 40.21) & (titanic_df['Age'] <= 60.105), 'Age'] = 2\n", + "titanic_df.loc[titanic_df['Age'] > 60.105, 'Age'] = 3\n", + "titanic_df['Age'] = titanic_df['Age'].astype(int)\n", + "titanic_df.drop(['AgeLevel'], axis=1, inplace=True)\n", + "titanic_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Pclass | 船舱等级,可以看出等级越高,存活率越高,成正相关" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "titanic_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False).mean()\n", + "\n", + "f, ax = plt.subplots(figsize = (8, 6))\n", + "sns.countplot(x=\"Pclass\", hue=\"Survived\", data=titanic_df)\n", + "ax.set_xticklabels([\"一等舱\",\"二等舱\",\"三等舱\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Sex | 性别,可以看出女性存活率比男性高" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "titanic_df[[\"Sex\", \"Survived\"]].groupby(['Sex'], as_index=False).mean()\n", + "\n", + "f, ax = plt.subplots(figsize = (8, 6))\n", + "sns.countplot(x=\"Sex\", hue=\"Survived\", data=titanic_df)\n", + "ax.set_xticklabels([\"男性\",\"女性\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### SibSp + Parch | 家属们" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SurvivedPclassSexAgeTicketFareCabinEmbarkedIsAlone
003male1A/5 211717.2500NaNS1
111female1PC 1759971.2833C85C1
213female1STON/O2. 31012827.9250NaNS0
311female111380353.1000C123S1
403male13734508.0500NaNS0
\n", + "
" + ], + "text/plain": [ + " Survived Pclass Sex Age Ticket Fare Cabin Embarked \\\n", + "0 0 3 male 1 A/5 21171 7.2500 NaN S \n", + "1 1 1 female 1 PC 17599 71.2833 C85 C \n", + "2 1 3 female 1 STON/O2. 3101282 7.9250 NaN S \n", + "3 1 1 female 1 113803 53.1000 C123 S \n", + "4 0 3 male 1 373450 8.0500 NaN S \n", + "\n", + " IsAlone \n", + "0 1 \n", + "1 1 \n", + "2 0 \n", + "3 1 \n", + "4 0 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Family = SibSp + Parch\n", + "titanic_df['FamilySize'] = titanic_df['SibSp'] + titanic_df['Parch']\n", + "titanic_df['IsAlone'] = 0\n", + "titanic_df.loc[titanic_df['FamilySize'] == 1, 'IsAlone'] = 1\n", + "\n", + "# 删除原有的列 Parch & SibSp\n", + "titanic_df.drop(['SibSp'], axis=1, inplace=True)\n", + "titanic_df.drop(['Parch'], axis=1, inplace=True)\n", + "titanic_df.drop(['FamilySize'], axis=1, inplace=True)\n", + "titanic_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Fare | 使用分位数对数据进行划分,可以得到大小基本相等的bin,转换为数值型数据" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FareLevelSurvived
0(-0.001, 7.91]0.197309
1(7.91, 14.454]0.303571
2(14.454, 31.0]0.454955
3(31.0, 512.329]0.581081
\n", + "
" + ], + "text/plain": [ + " FareLevel Survived\n", + "0 (-0.001, 7.91] 0.197309\n", + "1 (7.91, 14.454] 0.303571\n", + "2 (14.454, 31.0] 0.454955\n", + "3 (31.0, 512.329] 0.581081" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "titanic_df['FareLevel'] = pd.qcut(titanic_df['Fare'], 4)\n", + "titanic_df[['FareLevel', 'Survived']].groupby(['FareLevel'], as_index=False).mean().sort_values(by='FareLevel', ascending=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SurvivedPclassSexAgeTicketFareCabinEmbarkedIsAlone
003male1A/5 211710NaNS1
111female1PC 175993C85C1
213female1STON/O2. 31012821NaNS0
311female11138033C123S1
403male13734501NaNS0
\n", + "
" + ], + "text/plain": [ + " Survived Pclass Sex Age Ticket Fare Cabin Embarked \\\n", + "0 0 3 male 1 A/5 21171 0 NaN S \n", + "1 1 1 female 1 PC 17599 3 C85 C \n", + "2 1 3 female 1 STON/O2. 3101282 1 NaN S \n", + "3 1 1 female 1 113803 3 C123 S \n", + "4 0 3 male 1 373450 1 NaN S \n", + "\n", + " IsAlone \n", + "0 1 \n", + "1 1 \n", + "2 0 \n", + "3 1 \n", + "4 0 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "titanic_df.loc[titanic_df['Fare'] <= 7.91, 'Fare'] = 0\n", + "titanic_df.loc[(titanic_df['Fare'] > 7.91) & (titanic_df['Fare'] <= 14.454), 'Fare'] = 1\n", + "titanic_df.loc[(titanic_df['Fare'] > 14.454) & (titanic_df['Fare'] <= 31.0), 'Fare'] = 2\n", + "titanic_df.loc[titanic_df['Fare'] > 31.0, 'Fare'] = 3\n", + "titanic_df['Fare'] = titanic_df['Fare'].astype(int)\n", + "titanic_df.drop(['FareLevel'], axis=1, inplace=True)\n", + "titanic_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### OneHotEncoder | 将类别型变量全部onehot" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# one-hot编码\n", + "sex_dummies_titanic = pd.get_dummies(titanic_df['Sex'])\n", + "sex_dummies_titanic.columns = ['男性', '女性']\n", + "titanic_df = titanic_df.join(sex_dummies_titanic)\n", + "\n", + "embark_dummies_titanic = pd.get_dummies(titanic_df['Embarked'])\n", + "embark_dummies_titanic.columns = ['港口S', '港口C','港口Q']\n", + "titanic_df = titanic_df.join(embark_dummies_titanic)\n", + "\n", + "class_dummies_titanic = pd.get_dummies(titanic_df['Pclass'])\n", + "class_dummies_titanic.columns = ['一等舱', '二等舱', '三等舱']\n", + "titanic_df = titanic_df.join(class_dummies_titanic)\n", + "\n", + "age_dummies_titanic = pd.get_dummies(titanic_df['Age'])\n", + "age_dummies_titanic.columns = ['孩子', '少年', '中年','老人']\n", + "titanic_df = titanic_df.join(age_dummies_titanic)\n", + "\n", + "fare_dummies_titanic = pd.get_dummies(titanic_df['Fare'])\n", + "fare_dummies_titanic.columns = ['便宜票价', '普通票价', '高级票价','豪华票价']\n", + "titanic_df = titanic_df.join(fare_dummies_titanic)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "del titanic_df['Sex']\n", + "del titanic_df['Embarked']\n", + "del titanic_df['IsAlone']\n", + "del titanic_df['Pclass']\n", + "del titanic_df['Age']\n", + "del titanic_df['Fare']\n", + "del titanic_df['Cabin']\n", + "del titanic_df['Ticket']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 2 使用清理后的数据" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import precision_recall_curve, roc_auc_score, roc_curve\n", + "from sklearn.metrics import accuracy_score, mean_squared_error, r2_score, confusion_matrix\n", + "from sklearn.model_selection import GridSearchCV # 参数调优" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Survived男性女性港口S港口C港口Q一等舱二等舱三等舱孩子少年中年老人便宜票价普通票价高级票价豪华票价
000100100101001000
111010010001000001
211000100101000100
311000110001000001
400100100101000100
\n", + "
" + ], + "text/plain": [ + " Survived 男性 女性 港口S 港口C 港口Q 一等舱 二等舱 三等舱 孩子 少年 中年 老人 便宜票价 普通票价 \\\n", + "0 0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 \n", + "1 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 \n", + "2 1 1 0 0 0 1 0 0 1 0 1 0 0 0 1 \n", + "3 1 1 0 0 0 1 1 0 0 0 1 0 0 0 0 \n", + "4 0 0 1 0 0 1 0 0 1 0 1 0 0 0 1 \n", + "\n", + " 高级票价 豪华票价 \n", + "0 0 0 \n", + "1 0 1 \n", + "2 0 0 \n", + "3 0 1 \n", + "4 0 0 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset = titanic_df\n", + "# 观察数据\n", + "dataset.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Survived男性女性港口S港口C港口Q一等舱二等舱三等舱孩子少年中年老人便宜票价普通票价高级票价豪华票价
count891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000891.000000
mean0.3838380.3524130.6475870.1885520.0864200.7227830.2424240.2065100.5510660.2278340.5858590.1616160.0246910.2502810.2435470.2570150.249158
std0.4865920.4779900.4779900.3913720.2811410.4478760.4287900.4050280.4976650.4196700.4928500.3683050.1552700.4334180.4294630.4372330.432769
min0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
25%0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
50%0.0000000.0000001.0000000.0000000.0000001.0000000.0000000.0000001.0000000.0000001.0000000.0000000.0000000.0000000.0000000.0000000.000000
75%1.0000001.0000001.0000000.0000000.0000001.0000000.0000000.0000001.0000000.0000001.0000000.0000000.0000000.5000000.0000001.0000000.000000
max1.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.0000001.000000
\n", + "
" + ], + "text/plain": [ + " Survived 男性 女性 港口S 港口C 港口Q \\\n", + "count 891.000000 891.000000 891.000000 891.000000 891.000000 891.000000 \n", + "mean 0.383838 0.352413 0.647587 0.188552 0.086420 0.722783 \n", + "std 0.486592 0.477990 0.477990 0.391372 0.281141 0.447876 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 1.000000 0.000000 0.000000 1.000000 \n", + "75% 1.000000 1.000000 1.000000 0.000000 0.000000 1.000000 \n", + "max 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 \n", + "\n", + " 一等舱 二等舱 三等舱 孩子 少年 中年 \\\n", + "count 891.000000 891.000000 891.000000 891.000000 891.000000 891.000000 \n", + "mean 0.242424 0.206510 0.551066 0.227834 0.585859 0.161616 \n", + "std 0.428790 0.405028 0.497665 0.419670 0.492850 0.368305 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 1.000000 0.000000 1.000000 0.000000 \n", + "75% 0.000000 0.000000 1.000000 0.000000 1.000000 0.000000 \n", + "max 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 \n", + "\n", + " 老人 便宜票价 普通票价 高级票价 豪华票价 \n", + "count 891.000000 891.000000 891.000000 891.000000 891.000000 \n", + "mean 0.024691 0.250281 0.243547 0.257015 0.249158 \n", + "std 0.155270 0.433418 0.429463 0.437233 0.432769 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.500000 0.000000 1.000000 0.000000 \n", + "max 1.000000 1.000000 1.000000 1.000000 1.000000 " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 继续观察数据基本统计信息\n", + "dataset.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# 获得数据集的特征(输入变量)和输出\n", + "x = np.array(dataset.iloc[:, 1:])\n", + "y = np.array(dataset.iloc[:, 0])\n", + "# 分割数据集\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=33)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# 绘制混淆矩阵函数\n", + "def plot_confusion_matrix(cm, classes,\n", + " normalize=False,\n", + " title='Confusion matrix',\n", + " cmap=plt.cm.Blues):\n", + " plt.figure()\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=45)\n", + " plt.yticks(tick_marks, classes)\n", + "\n", + " fmt = '.2f' if normalize else 'd'\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, format(cm[i, j], fmt),\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')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# 模型性能评估\n", + "def model_performance_evaluation(model_name, test, pred):\n", + " print(model_name, '| 准确率: %.4f' % accuracy_score(test, pred))\n", + " print(model_name,'| 均方误差: %.4f' % mean_squared_error(test, pred))\n", + " print(model_name, '| R2-score: %.4f' % r2_score(test, pred))\n", + " print(model_name, '| 混淆矩阵:\\n', confusion_matrix(test, pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 3 对数几率回归模型" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# 模型参数组合\n", + "param_lr = {'penalty':['l1','l2'], 'C':[1,1e+2,1e+4], 'max_iter':[100,1000,10000]}" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\Anaconda\\lib\\site-packages\\sklearn\\model_selection\\_validation.py:378: FitFailedWarning: \n", + "45 fits failed out of a total of 90.\n", + "The score on these train-test partitions for these parameters will be set to nan.\n", + "If these failures are not expected, you can try to debug them by setting error_score='raise'.\n", + "\n", + "Below are more details about the failures:\n", + "--------------------------------------------------------------------------------\n", + "45 fits failed with the following error:\n", + "Traceback (most recent call last):\n", + " File \"d:\\Anaconda\\lib\\site-packages\\sklearn\\model_selection\\_validation.py\", line 686, in _fit_and_score\n", + " estimator.fit(X_train, y_train, **fit_params)\n", + " File \"d:\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py\", line 1162, in fit\n", + " solver = _check_solver(self.solver, self.penalty, self.dual)\n", + " File \"d:\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py\", line 54, in _check_solver\n", + " raise ValueError(\n", + "ValueError: Solver lbfgs supports only 'l2' or 'none' penalties, got l1 penalty.\n", + "\n", + " warnings.warn(some_fits_failed_message, FitFailedWarning)\n", + "d:\\Anaconda\\lib\\site-packages\\sklearn\\model_selection\\_search.py:952: UserWarning: One or more of the test scores are non-finite: [ nan 0.77682581 nan 0.77682581 nan 0.77682581\n", + " nan 0.77842581 nan 0.77842581 nan 0.77842581\n", + " nan 0.77842581 nan 0.77842581 nan 0.77842581]\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
LogisticRegression(C=100.0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LogisticRegression(C=100.0)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 建模、训练和预测\n", + "base_line_model = LogisticRegression() # 默认 penalty='l2'\n", + "lr = GridSearchCV(estimator=base_line_model, param_grid=param_lr, cv=5, n_jobs=3)\n", + "lr.fit(x_train, y_train)\n", + "y_pred_lr = lr.predict(x_test)\n", + "lr.best_estimator_" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "对数几率回归模型在训练集上的性能 -- \n", + "LogisticRegression | 准确率: 0.7849\n", + "LogisticRegression | 均方误差: 0.2151\n", + "LogisticRegression | R2-score: 0.0889\n", + "LogisticRegression | 混淆矩阵:\n", + " [[327 58]\n", + " [ 76 162]]\n", + "\n", + "\n", + "\n", + "对数几率回归模型在测试集上的性能 -- \n", + "LogisticRegression | 准确率: 0.8097\n", + "LogisticRegression | 均方误差: 0.1903\n", + "LogisticRegression | R2-score: 0.1986\n", + "LogisticRegression | 混淆矩阵:\n", + " [[140 24]\n", + " [ 27 77]]\n" + ] + } + ], + "source": [ + "# 模型性能评估\n", + "print(\"对数几率回归模型在训练集上的性能 -- \")\n", + "model_performance_evaluation('LogisticRegression', y_train, lr.predict(x_train))\n", + "print(\"\\n\"*2)\n", + "print(\"对数几率回归模型在测试集上的性能 -- \")\n", + "model_performance_evaluation('LogisticRegression', y_test, y_pred_lr)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制混淆矩阵\n", + "cnf_matrix = confusion_matrix(y_test, y_pred_lr)\n", + "np.set_printoptions(precision=2) # 设置打印数量的阈值\n", + "class_names = [0, 1]\n", + "plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion matrix')" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "该支持向量机模型的AUC值为 0.7970215759849906\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制ROC曲线并计算AUC值\n", + "auc_lr = roc_auc_score(y_test, y_pred_lr)\n", + "print(f\"该支持向量机模型的AUC值为 {auc_lr}\")\n", + "fpr_lr, tpr_lr, thresholds = roc_curve(y_test, y_pred_lr)\n", + "plt.plot(fpr_lr, tpr_lr, label=\"对数几率模型: \"+str(round(auc_lr, 3)))\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC')\n", + "plt.xlim([0,1])\n", + "plt.ylim([0,1.1])\n", + "plt.grid()\n", + "plt.legend(loc='lower right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 4 决策树" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.tree import DecisionTreeClassifier, export_graphviz\n", + "params_dt = {'criterion':['entropy','gini'], 'splitter':['best', 'random']}" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
DecisionTreeClassifier(splitter='random')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "DecisionTreeClassifier(splitter='random')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "base_line_model = DecisionTreeClassifier()\n", + "dtc = GridSearchCV(estimator=base_line_model, param_grid=params_dt, cv=5, n_jobs=3)\n", + "dtc.fit(x_train, y_train)\n", + "y_pred_dt = dtc.predict(x_test)\n", + "dtc.best_estimator_" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "决策树模型在 训练集 上的性能 -- \n", + "DecisionTree | 准确率: 0.8411\n", + "DecisionTree | 均方误差: 0.1589\n", + "DecisionTree | R2-score: 0.3269\n", + "DecisionTree | 混淆矩阵:\n", + " [[350 35]\n", + " [ 64 174]]\n", + "\n", + "\n", + "\n", + "决策树模型在 测试集 上的性能 -- \n", + "DecisionTree | 准确率: 0.8470\n", + "DecisionTree | 均方误差: 0.1530\n", + "DecisionTree | R2-score: 0.3558\n", + "DecisionTree | 混淆矩阵:\n", + " [[151 13]\n", + " [ 28 76]]\n" + ] + } + ], + "source": [ + "# 模型性能评估\n", + "print(\"决策树模型在 训练集 上的性能 -- \")\n", + "model_performance_evaluation('DecisionTree', y_train, dtc.predict(x_train))\n", + "print(\"\\n\"*2)\n", + "\n", + "print(\"决策树模型在 测试集 上的性能 -- \")\n", + "model_performance_evaluation('DecisionTree', y_test, y_pred_dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 计算混淆矩阵\n", + "cnf_matrix = confusion_matrix(y_test, y_pred_dt)\n", + "np.set_printoptions(precision=2) # 设置打印数量的阈值\n", + "class_names = [0, 1]\n", + "# 绘制混淆矩阵\n", + "plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion matrix')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "该支持向量机模型的AUC值为 0.825750469043152\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制ROC曲线并计算AUC值\n", + "auc_dt = roc_auc_score(y_test, y_pred_dt)\n", + "print(f\"该支持向量机模型的AUC值为 {auc_dt}\")\n", + "fpr_dt, tpr_dt, thresholds = roc_curve(y_test, y_pred_dt)\n", + "plt.plot(fpr_dt, tpr_dt, label=\"决策树: \"+str(round(auc_dt, 3)))\n", + "plt.plot(fpr_lr, tpr_lr, label=\"对数几率模型: \"+str(round(auc_lr, 3)))\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC')\n", + "plt.xlim([0,1])\n", + "plt.ylim([0,1.1])\n", + "plt.grid()\n", + "plt.legend(loc='lower right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 5 神经网络" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.neural_network import MLPClassifier\n", + "params_mlp = {'solver':['sgd', 'lbfgs'], 'alpha': [1e-3, 1e-4], 'learning_rate_init':[1e-3, 1e-4] }" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
MLPClassifier(hidden_layer_sizes=(6, 6, 6), learning_rate_init=0.0001,\n",
+       "              max_iter=1000, solver='lbfgs')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "MLPClassifier(hidden_layer_sizes=(6, 6, 6), learning_rate_init=0.0001,\n", + " max_iter=1000, solver='lbfgs')" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 神经网络训练模型\n", + "base_line_model = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(6, 6, 6), max_iter=1000)\n", + "mlp = GridSearchCV(estimator=base_line_model, param_grid=params_mlp, cv=5, n_jobs=3)\n", + "mlp.fit(x_train, y_train)\n", + "y_pred_nn = mlp.predict(x_test)\n", + "mlp.best_estimator_" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "神经网络模型在 训练集 上的性能 -- \n", + "Neural Network | 准确率: 0.8363\n", + "Neural Network | 均方误差: 0.1637\n", + "Neural Network | R2-score: 0.3065\n", + "Neural Network | 混淆矩阵:\n", + " [[353 32]\n", + " [ 70 168]]\n", + "\n", + "\n", + "\n", + "神经网络模型在 测试集 上的性能 -- \n", + "Neural Network | 准确率: 0.8321\n", + "Neural Network | 均方误差: 0.1679\n", + "Neural Network | R2-score: 0.2929\n", + "Neural Network | 混淆矩阵:\n", + " [[150 14]\n", + " [ 31 73]]\n" + ] + } + ], + "source": [ + "# 模型性能评估\n", + "print(\"神经网络模型在 训练集 上的性能 -- \")\n", + "model_performance_evaluation('Neural Network', y_train, mlp.predict(x_train))\n", + "print(\"\\n\"*2)\n", + "\n", + "print(\"神经网络模型在 测试集 上的性能 -- \")\n", + "model_performance_evaluation('Neural Network', y_test, y_pred_nn)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 计算混淆矩阵\n", + "cnf_matrix = confusion_matrix(y_test, y_pred_nn)\n", + "np.set_printoptions(precision=2) # 设置打印数量的阈值\n", + "class_names = [0, 1]\n", + "# 绘制混淆矩阵\n", + "plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion matrix')" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "神经网络的AUC值为 0.8082786116322701\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制ROC曲线并计算AUC值\n", + "auc_nn = roc_auc_score(y_test, y_pred_nn)\n", + "print(f\"神经网络的AUC值为 {auc_nn}\")\n", + "fpr_nn, tpr_nn, thresholds = roc_curve(y_test, y_pred_nn)\n", + "plt.plot(fpr_nn, tpr_nn, label=\"神经网络: \"+str(round(auc_nn, 3)))\n", + "plt.plot(fpr_dt, tpr_dt, label=\"决策树: \"+str(round(auc_dt, 3)))\n", + "plt.plot(fpr_lr, tpr_lr, label=\"对数几率模型: \"+str(round(auc_lr, 3)))\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC')\n", + "plt.xlim([0,1])\n", + "plt.ylim([0,1.1])\n", + "plt.grid()\n", + "plt.legend(loc='lower right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# 6、支持向量机\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
SVC(C=100, gamma=1)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "SVC(C=100, gamma=1)" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import svm\n", + "params_svm = {'kernel':['rbf','linear'], 'gamma':[10,1,0.1,1e-2], 'C':[1,100,1e4]}\n", + "# 支持向量机训练模型\n", + "base_line_model = svm.SVC() # 默认 kernel='rbf'\n", + "svc = GridSearchCV(estimator=base_line_model, param_grid=params_svm, cv=5, n_jobs=3)\n", + "svc.fit(x_train, y_train)\n", + "y_pred_svm = svc.predict(x_test)\n", + "svc.best_estimator_" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "支持向量机模型在 训练集 上的性能 -- \n", + "Support Vector Machinen | 准确率: 0.8411\n", + "Support Vector Machinen | 均方误差: 0.1589\n", + "Support Vector Machinen | R2-score: 0.3269\n", + "Support Vector Machinen | 混淆矩阵:\n", + " [[348 37]\n", + " [ 62 176]]\n", + "\n", + "\n", + "\n", + "支持向量机模型在 测试集 上的性能 -- \n", + "Support Vector Machine | 准确率: 0.8507\n", + "Support Vector Machine | 均方误差: 0.1493\n", + "Support Vector Machine | R2-score: 0.3715\n", + "Support Vector Machine | 混淆矩阵:\n", + " [[151 13]\n", + " [ 27 77]]\n" + ] + } + ], + "source": [ + "# 模型性能评估\n", + "print(\"支持向量机模型在 训练集 上的性能 -- \")\n", + "model_performance_evaluation('Support Vector Machinen', y_train, svc.predict(x_train))\n", + "print(\"\\n\"*2)\n", + "print(\"支持向量机模型在 测试集 上的性能 -- \")\n", + "model_performance_evaluation('Support Vector Machine', y_test, y_pred_svm)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "该支持向量机模型的AUC值为 0.8305581613508443\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制ROC曲线并计算AUC值\n", + "auc_svm = roc_auc_score(y_test, y_pred_svm)\n", + "print(f\"该支持向量机模型的AUC值为 {auc_svm}\")\n", + "fpr_svm, tpr_svm, thresholds = roc_curve(y_test, y_pred_svm)\n", + "plt.plot(fpr_svm, tpr_svm, label=\"支持向量机: \"+str(round(auc_svm, 3)))\n", + "plt.plot(fpr_nn, tpr_nn, label=\"神经网络: \"+str(round(auc_nn, 3)))\n", + "plt.plot(fpr_dt, tpr_dt, label=\"决策树: \"+str(round(auc_dt, 3)))\n", + "plt.plot(fpr_lr, tpr_lr, label=\"对数几率模型: \"+str(round(auc_lr, 3)))\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC')\n", + "plt.xlim([0,1])\n", + "plt.ylim([0,1.1])\n", + "plt.grid()\n", + "plt.legend(loc='lower right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 由上述结果可以看到,决支持向量机的分类准确率最高" + ] + } + ], + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}