Python打卡训练营day22——2025.05.11

泰坦尼克号生还数据

import warnings
warnings.filterwarnings("ignore") #忽略警告信息
 
# 数据处理清洗包
import pandas as pd
import numpy as np
import random as rnd
 
# 可视化包
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
 
# 机器学习算法相关包
from sklearn.linear_model import LogisticRegression, Perceptron, SGDClassifier
#逻辑回归、感知机、随机梯度下降法
from sklearn.svm import SVC, LinearSVC
#支持向量机、线性支持向量机
from sklearn.neighbors import KNeighborsClassifier
#最近邻
from sklearn.naive_bayes import GaussianNB
#朴素贝叶斯
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
 
 
train_df = pd.read_csv('./titanic/train.csv')
test_df = pd.read_csv('./titanic/test.csv')
combine = [train_df, test_df] # 合并数据
#这只是放到一个列表，以便后续合并，现在还没合并
#combined_df = pd.concat([train_df, test_df], axis=1, ignore_index=True)这才是合并
#combine.head()会报错，因为列表没有head方法
 
 
# 获取所有特征名
print(train_df.columns.values)
 
 
# 预览数据
train_df.head()
 
 
train_df.tail()
 
 
print(train_df.isnull().sum())
# 返回每列（特征）中的缺失值数量
print('_'*40)
#打印一行分隔线，其中包含40个连续的下划线字符
test_df.isnull().sum()
 
 
train_df.info()
print('_'*40)
test_df.info()
#714 non-null意为714个非空值
# RangeIndex: 891 entries, 0 to 890 表示891行数据
# Data columns (total 12 columns) 表示12列（11个特征 1个标签）
 
 
round(train_df.describe(percentiles=[.5, .6, .7, .75, .8, .9, .99]),2)
 
 
train_df.describe(include=['O'])
 
 
train_df[['Pclass','Survived']].groupby(['Pclass'], as_index=False).mean().sort_values(by='Survived', ascending=False)
 
 
train_df[['Sex','Survived']].groupby(['Sex'], as_index=False).mean().sort_values(by='Survived', ascending=False)
 
 
train_df[['SibSp','Survived']].groupby(['SibSp'], as_index=False).mean().sort_values(by='Survived',ascending=False)
 
 
train_df[['Parch','Survived']].groupby(['Parch'], as_index=False).mean().sort_values(by='Survived',ascending=False)
 
 
g = sns.FacetGrid(train_df, col='Survived')  #FacetGrid(data, row, col, hue, height, aspect, palette, ...)
# col='Survived'指定了将数据分成两列，分别对应于Survived列的0和1
 
g.map(plt.hist, 'Age', bins=20)
# plt.hist来绘制直方图，并传递了'Age'列作为数据，，bins=20指定了直方图的分箱数
 
 
#grid = sns.FacetGrid(train_df, col='Survived', row='Pclass', size=2.5, aspect=1.6)
grid = sns.FacetGrid(train_df, col='Pclass', hue='Survived') 
grid.map(plt.hist, 'Age', alpha=0.5, bins=20)
grid.add_legend();
 
 
grid = sns.FacetGrid(train_df, col='Embarked')
grid.map(sns.pointplot, 'Pclass', 'Survived', 'Sex', palette='deep')
grid.add_legend();
 
 
grid = sns.FacetGrid(train_df, col='Embarked', hue='Survived', palette={0: 'b', 1: 'r'})
grid.map(sns.barplot, 'Sex', 'Fare', alpha=.5, ci=None)
grid.add_legend()
 
 
print("Before", train_df.shape, test_df.shape, combine[0].shape, combine[1].shape)
 
train_df = train_df.drop(['Ticket', 'Cabin'], axis=1)
test_df = test_df.drop(['Ticket', 'Cabin'], axis=1)
combine = [train_df, test_df]
 
"After", train_df.shape, test_df.shape, combine[0].shape, combine[1].shape
 
 
train_df['Name'].head(10)
 
 
# 使用正则表达式提取Title特征
for dataset in combine:
    dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
# 从姓名字符串中匹配一个或多个字母，并且以句点 (.) 结尾的部分，这通常是表示称号的部分
# 提取的称号被存储在一个新的 Title 列中
pd.crosstab(train_df['Title'], train_df['Sex']).sort_values(by='female', ascending=False)  # pd.crosstab列联表
#这部分代码使用 pd.crosstab 来创建一个列联表，用于计算不同称号 和性别之间的关系
#crosstab 会统计每个组合的数量，并返回一个交叉表。
 
 
grid = sns.FacetGrid(train_df,  col='Title', hue='Survived', col_wrap=3, size=2.5, aspect=1.6)
# hue='Survived'：根据 Survived 列的不同取值对每个子图着色，以区分生存和未生存的乘客。
# col_wrap=3：表示每行最多可以有3列子图。
grid.map(plt.hist, 'Age', alpha=0.5, bins=20)
grid.add_legend()
 
 
combine
#还没有按列合并，还是2个数据表
 
 
for dataset in combine:
    dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',
                                                 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
 
    dataset['Title'] = dataset['Title'].replace(['Mlle', 'Ms'], 'Miss')
    dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')
    
train_df[['Title', 'Survived']].groupby(['Title'], as_index=False).mean()
 
 
train_df.head()
 
 
# 将分类标题转换为序数
title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
    dataset['Title'] = dataset['Title'].map(title_mapping)  
    # 将序列中的每一个元素，输入函数，最后将映射后的每个值返回合并，得到一个迭代器
    dataset['Title'] = dataset['Title'].fillna(0)  
 
train_df.head()
 
 
# 现在可以从训练和测试数据集中删除Name特征以及训练集中的PassengerId 特征
train_df = train_df.drop(['Name', 'PassengerId'], axis=1)
test_df = test_df.drop(['Name'], axis=1)
combine = [train_df, test_df]
train_df.shape, test_df.shape
 
 
# 转换分类特征Sex
for dataset in combine:
    dataset['Sex'] = dataset['Sex'].map( {'female': 1, 'male': 0} ).astype(int)  #男性赋值为0，女性赋值为1，并转换为整型数据
 
train_df.head()
 
 
# 绘制Age, Pclass, Sex复合直方图
#grid = sns.FacetGrid(train_df, row='Pclass', col='Sex', size=2.2, aspect=1.6)
grid = sns.FacetGrid(train_df, col='Pclass', hue='Sex')
grid.map(plt.hist, 'Age', alpha=.5, bins=20)
grid.add_legend()
 
 
# 创建空数组
guess_ages = np.zeros((2,3))
guess_ages
 
# 遍历 Sex (0 或 1) 和 Pclass (1, 2, 3) 来计算六种组合的 Age 猜测值
for dataset in combine:
    # 第一个for循环计算每一个分组的Age预测值
    for i in range(0, 2):
        for j in range(0, 3):
            guess_df = dataset[(dataset['Sex'] == i) & \
                                  (dataset['Pclass'] == j+1)]['Age'].dropna()
 
            # age_mean = guess_df.mean()
            # age_std = guess_df.std()
            # age_guess = rnd.uniform(age_mean - age_std, age_mean + age_std)
 
            age_guess = guess_df.median()
 
            # 将随机年龄浮点数转换为最接近的 0.5 年龄（四舍五入）
            guess_ages[i,j] = int( age_guess/0.5 + 0.5 ) * 0.5
            
    # 第二个for循环对空值进行赋值        
    for i in range(0, 2):
        for j in range(0, 3):
            dataset.loc[ (dataset.Age.isnull()) & (dataset.Sex == i) & (dataset.Pclass == j+1),\
                    'Age'] = guess_ages[i,j]
 
    dataset['Age'] = dataset['Age'].astype(int)
train_df.head()
 
 
train_df['AgeBand'] = pd.cut(train_df['Age'], 5)  # 将年龄分割为5段,等距分箱
train_df[['AgeBand', 'Survived']].groupby(['AgeBand'], as_index=False).mean().sort_values(by='AgeBand', ascending=True)
 
 
# 将这些年龄区间替换为序数
for dataset in combine:    
    dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
    dataset.loc[(dataset['Age'] > 16) & (dataset['Age'] <= 32), 'Age'] = 1
    dataset.loc[(dataset['Age'] > 32) & (dataset['Age'] <= 48), 'Age'] = 2
    dataset.loc[(dataset['Age'] > 48) & (dataset['Age'] <= 64), 'Age'] = 3
    dataset.loc[ dataset['Age'] > 64, 'Age'] = 4
train_df.head()
 
 
train_df = train_df.drop(['AgeBand'], axis=1)  # 删除训练集中的AgeBand特征
combine = [train_df, test_df]
train_df.head()
test_df
 
 
for dataset in combine:
    dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
 
train_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False).mean().sort_values(by='Survived', ascending=False)
 
 
# 创建新特征IsAlone
for dataset in combine:
    dataset['IsAlone'] = 0
    dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
 
train_df[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False).mean()
 
 
train_df = train_df.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
test_df = test_df.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
combine = [train_df, test_df]
 
train_df.head(20)
 
 
# 创建Age*Pclass特征以此用来结合Age和Pclass变量
for dataset in combine:
    dataset['Age*Pclass'] = dataset.Age * dataset.Pclass
 
train_df.loc[:, ['Age*Pclass', 'Age', 'Pclass']].head(10)
train_df[['Age*Pclass', 'Survived']].groupby(['Age*Pclass'], as_index=False).mean()
 
 
freq_port = train_df.Embarked.dropna().mode()[0] 
# mode() 计算众数，这里只有一个值，加不加[0] 都一样，一般返回的众数是每一列的众数构成的series
for dataset in combine:
    dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)
    
train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False).mean().sort_values(by='Survived', ascending=False)
 
 
# 同样转换分类特征为序数
for dataset in combine:
    dataset['Embarked'] = dataset['Embarked'].map( {'S': 0, 'C': 1, 'Q': 2} ).astype(int)
 
train_df.head()
 
 
# 测试集中Fare有一个缺失值，用中位数进行填补
test_df['Fare'].fillna(test_df['Fare'].dropna().median(), inplace=True)
test_df.head()
 
 
plt.hist(train_df['Fare'])
 
 
# 对票价进行连续数据离散化
train_df['FareBand'] = pd.qcut(train_df['Fare'], 4)  # 根据样本分位数进行分箱，等频分箱
train_df[['FareBand', 'Survived']].groupby(['FareBand'], as_index=False).mean().sort_values(by='FareBand', ascending=True)
 
 
for dataset in combine:
    dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
    dataset.loc[(dataset['Fare'] > 7.91) & (dataset['Fare'] <= 14.454), 'Fare'] = 1
    dataset.loc[(dataset['Fare'] > 14.454) & (dataset['Fare'] <= 31), 'Fare']   = 2
    dataset.loc[ dataset['Fare'] > 31, 'Fare'] = 3
    dataset['Fare'] = dataset['Fare'].astype(int)
 
train_df = train_df.drop(['FareBand'], axis=1)
combine = [train_df, test_df]
    
train_df.head(10)
 
 
test_df.head(10)
 
 
X_train = train_df.drop("Survived", axis=1)
Y_train = train_df["Survived"]
X_test  = test_df.drop("PassengerId", axis=1).copy()
X_train.shape, Y_train.shape, X_test.shape
 
 
# 逻辑回归模型
logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)  # logreg.predict_proba(X_test)[:,1]
acc_log = round(logreg.score(X_train, Y_train) * 100, 2)
# 乘100成百分数表示
acc_log
 
 
coeff_df = pd.DataFrame(train_df.columns.delete(0))
#columns.delete(0) 用于删除数据框（DataFrame）中的第一列：数据框的索引列
coeff_df.columns = ['Feature']
coeff_df["Correlation"] = pd.Series(logreg.coef_[0])
#=创建新列 'Correlation'。`logreg.coef_` 包含了逻辑回归模型的系数，`[0]` 表示获取系数的第一个元素（通常逻辑回归模型只有一个系数数组）。
#pd.Series()将这个系数数组转换为 pandas 的 Series 对象，以便添加到数据框中。
coeff_df.sort_values(by='Correlation', ascending=False)
#逻辑回归也可以反映出特征重要性（系数的绝对值），同时还包含正负影响
 
 
# 支持向量机模型
svc = SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train) * 100, 2)
acc_svc
 
 
# KNN
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train) * 100, 2)
acc_knn
 
 
# 朴素贝叶斯分类器
gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train) * 100, 2)
acc_gaussian
 
 
# 感知机
perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train) * 100, 2)
acc_perceptron
 
 
# 线性SVC
linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train) * 100, 2)
acc_linear_svc
 
 
# SDG随机梯度下降
sgd = SGDClassifier()
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train) * 100, 2)
acc_sgd
 
 
# 决策树
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train) * 100, 2)
acc_decision_tree
 
 
# 决策树可视化
from sklearn import tree
import graphviz
import pydotplus  
from IPython.display import Image
dot_data = tree.export_graphviz(decision_tree, out_file=None, 
                         feature_names=X_train.columns,  
                         class_names=['0','1'],  
                         max_depth=3,
                         filled=True, rounded=True,  
                         special_characters=True)  
graph = pydotplus.graph_from_dot_data(dot_data)  
Image(graph.create_png())
 
 
dot_data = tree.export_graphviz(decision_tree, out_file=None,
                         feature_names=X_train.columns,  
                         #class_names=['0','1'],  
                         filled=True, rounded=True,  
                         special_characters=True)  
graph = pydotplus.graph_from_dot_data(dot_data)  
graph.write_pdf("DTtree.pdf") 
 
train_df[(train_df['Age*Pclass']>2.5) & (train_df['Fare']<=1.5)&(train_df['Fare']>0.5)&(train_df['IsAlone']>0.5)&(train_df['Age']>0.5)& \
         (train_df['Embarked']<=1.5) &(train_df['Embarked']>0.5)&(train_df['Fare']<=2.5)&(train_df['Age']<=1.5)&(train_df['Pclass']>1.5)& \
         (train_df['Title']<=1.5)]
 
 
# 随机森林
random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train) * 100, 2)
acc_random_forest
 
 
models = pd.DataFrame({
    'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression', 
              'Random Forest', 'Naive Bayes', 'Perceptron', 
              'Stochastic Gradient Decent', 'Linear SVC', 
              'Decision Tree'],
    'Score': [acc_svc, acc_knn, acc_log, 
              acc_random_forest, acc_gaussian, acc_perceptron, 
              acc_sgd, acc_linear_svc, acc_decision_tree]})
models.sort_values(by='Score', ascending=False)
# 对比多个模型的预测结果 选取最好的模型提交
 
 
submission = pd.DataFrame({
        "PassengerId": test_df["PassengerId"],
        "Survived": Y_pred
    })
submission.to_csv('./submission.csv', index=False)
# submission 是一个新的数据框（DataFrame），用于存储提交文件的数据
# "PassengerId"：这一列包含了测试数据集中乘客的唯一标识符（PassengerId）。
# "Survived"：这一列包含了模型的预测结果，表示相应乘客是否幸存（1表示幸存，0表示未幸存）
 
 

@浙大疏锦行