diff --git a/2、幸福感数据分析/第5组-杜佳璐/第5组实战/实例_数据处理_泰坦尼克号幸存.ipynb b/2、幸福感数据分析/第5组-杜佳璐/第5组实战/实例_数据处理_泰坦尼克号幸存.ipynb new file mode 100644 index 0000000..e375b51 --- /dev/null +++ b/2、幸福感数据分析/第5组-杜佳璐/第5组实战/实例_数据处理_泰坦尼克号幸存.ipynb @@ -0,0 +1,2786 @@ +{ + "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": 2, + "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": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 导入，读取数据\n", + "titanic_df = pd.read_csv('data//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": 3, + "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": 4, + "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": 4, + "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": 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", + "
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": 5, + "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": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\dululu\\AppData\\Local\\Temp/ipykernel_25844/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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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 7, + "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": 7, + "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": 8, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestRegressor" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\anaconda\\lib\\site-packages\\sklearn\\base.py:464: UserWarning: X does not have valid feature names, but RandomForestRegressor was fitted with feature names\n", + " warnings.warn(\n", + "D:\\anaconda\\lib\\site-packages\\seaborn\\distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 10, + "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.398601
3(60.105, 80.0]0.217391
\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.398601\n", + "3 (60.105, 80.0] 0.217391" + ] + }, + "execution_count": 10, + "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": 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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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": 11, + "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": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 13, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 14, + "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": 14, + "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": 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", + "
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": 15, + "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": 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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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": 16, + "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": 17, + "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": 18, + "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": 19, + "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": 20, + "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": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset = titanic_df\n", + "# 观察数据\n", + "dataset.head()" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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.1604940.0258140.2502810.2435470.2570150.249158
std0.4865920.4779900.4779900.3913720.2811410.4478760.4287900.4050280.4976650.4196700.4928500.3672700.1586680.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.160494 \n", + "std 0.428790 0.405028 0.497665 0.419670 0.492850 0.367270 \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.025814 0.250281 0.243547 0.257015 0.249158 \n", + "std 0.158668 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": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 继续观察数据基本统计信息\n", + "dataset.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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": 23, + "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": 24, + "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": 25, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# 模型参数组合\n", + "#param_lr = {'penalty':['l1','l2'], 'C':[1,1e+2,1e+4], 'max_iter':[1e+2,1e+3,1e+4]}" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# 建模、训练和预测\n", + "#base_line_model = LogisticRegression() # 默认 penalty='l2'\n", + "lr = LogisticRegression()\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": 31, + "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": 32, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 33, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "该支持向量机模型的AUC值为 0.7970215759849906\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 34, + "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": 35, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
DecisionTreeClassifier(criterion='entropy', 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(criterion='entropy', splitter='random')" + ] + }, + "execution_count": 35, + "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": 36, + "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": 37, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 38, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "该支持向量机模型的AUC值为 0.825750469043152\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 39, + "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": 40, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
MLPClassifier(hidden_layer_sizes=(6, 6, 6), 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), max_iter=1000, solver='lbfgs')" + ] + }, + "execution_count": 40, + "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": 41, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "神经网络模型在 训练集 上的性能 -- \n", + "Neural Network | 准确率: 0.8266\n", + "Neural Network | 均方误差: 0.1734\n", + "Neural Network | R2-score: 0.2657\n", + "Neural Network | 混淆矩阵：\n", + " [[336 49]\n", + " [ 59 179]]\n", + "\n", + "\n", + "\n", + "神经网络模型在 测试集 上的性能 -- \n", + "Neural Network | 准确率: 0.8060\n", + "Neural Network | 均方误差: 0.1940\n", + "Neural Network | R2-score: 0.1829\n", + "Neural Network | 混淆矩阵：\n", + " [[144 20]\n", + " [ 32 72]]\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": 42, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 43, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "神经网络的AUC值为 0.7851782363977485\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": 44, + "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": 44, + "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": 45, + "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": 46, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "该支持向量机模型的AUC值为 0.8305581613508443\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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": [] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}