利用机器学习 - Python 进行飞船泰坦尼克号项目

2025年3月17日 | 阅读11分钟

飞船泰坦尼克号问题是基础泰坦尼克号生存问题的进阶版本，是机器学习爱好者必须面对并预测一个人生存机会的一次挑战。

飞船泰坦尼克号项目问题陈述

在此项目中，一艘飞船载有几个人去太空旅行。由于技术问题，许多人被传送到另一个星球。利用各种机器学习算法，我们需要预测将被传送到另一个星球还是留在同一艘飞船上的人。

解决飞船泰坦尼克号问题的方法

步骤 1：库和数据集

第一步是导入所需的库，包括用于构建和分析机器学习模型的numpy、pandas、matplotlib、sklearn 等。然后，我们将加载飞船泰坦尼克号问题的数据集并将其存储在 pandas 数据框中。

步骤 2：数据清洗

加载数据集后，我们将清洗数据。数据清洗包括检查数据中的空值，用某些值（可能是其他值的平均值或 0）替换空值，并在继续之前检查异常值。我们可以借助图表分析数据。可以使用 describe() 方法检查空值。

步骤 3：特征工程

现在，我们将选择特征来构建模型并预测结果。我们将通过比较不同的特征来收集重要信息。

步骤 4：探索性数据分析

我们将进行探索性数据分析，研究不同特征之间的关系。我们将使用饼图和条形图等不同图表可视化这些关系，以研究相关性。

步骤 5：拆分数据集

我们将使用train_test_split 模型将数据集拆分为训练和测试数据集，并使用 Standard Scaler 对数据进行归一化。

步骤 6：模型训练

现在，我们将使用逻辑回归、SVC 和 XGBClassifier 等不同的机器学习算法训练我们的数据集，并检查它们的准确性。

步骤 7：选择最佳模型

我们将选择准确率最高的模型。

步骤 8：混淆矩阵和验证数据

使用性能最佳的机器学习模型，我们将打印混淆矩阵和验证数据。

步骤 9：预测

使用创建的机器学习模型，我们可以预测该人将被传送到新星球还是留在原地。

现在，让我们开始实施飞船泰坦尼克号问题。

导入库和数据集

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sb
  
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn import metrics
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.linear_model import LogisticRegression
  
import warnings
warnings.filterwarnings('ignore')

我们已经导入了所需的库，如 numpy、pandas、matplotlib、sklearn 包，如 train_test_split、不同的算法等。

现在我们将加载数据集。

data = pd.read_csv("spaceship_titanic.csv")
data.head()

输出

Spaceship Titanic Project using Machine Learning - Python

我们已经读取了数据集并将其存储在数据框中。我们使用 head() 函数打印了前 5 条记录。

数据集的数据预处理

输出

(8693, 18)

我们将更深入地研究数据。

输出


RangeIndex: 8693 entries, 0 to 8692
Data columns (total 18 columns):
 #   Column        Non-Null Count  Dtype  
---  ------        --------------  -----  
 0   PassengerId   8693 non-null   object 
 1   HomePlanet    8693 non-null   object 
 2   CryoSleep     8677 non-null   object 
 3   Cabin         8693 non-null   object 
 4   Destination   8664 non-null   object 
 5   Age           8693 non-null   int64  
 6   VIP           8674 non-null   object 
 7   RoomService   8693 non-null   float64
 8   FoodCourt     8678 non-null   float64
 9   ShoppingMall  8693 non-null   float64
 10  Spa           8683 non-null   float64
 11  VRDeck        8674 non-null   float64
 12  Transported   8693 non-null   bool   
 13  Grouped       8693 non-null   bool   
 14  Deck          8693 non-null   object 
 15  Side          8678 non-null   object 
 16  Has_expenses  8693 non-null   bool   
 17  Is_Embryo     8690 non-null   object 
dtypes: bool(3), float64(5), int64(1), object(9)
memory usage: 1.0+ MB

使用shape() 函数，我们可以检查数据集的行数和列数。info() 函数将告诉我们数据集中是否有任何空值，以及每列的数据类型。

查看上面的输出，我们可以看到数据集中有很多空值。

现在我们将使用 describe() 方法获得数据集的描述性统计视图。它提供了计数、唯一值、最常见值和频率等信息。

输出

替换空值的最简单方法之一是，对于连续数据，用均值填充空值；对于分类数据，用众数填充空值。但是，在这种情况下，我们将尝试检查独立特征之间的关系，然后利用它们巧妙地填充空值。

data.isnull().sum().plot.bar()
plt.show()

输出

clm = data.loc[:,'RoomService':'VRDeck'].columns
data.groupby('VIP')[clm].mean()

输出

我们可以看到，VIP 花费比非 VIP 人员更多。

data.groupby('CryoSleep')[clm].mean()

输出

CryoSleep 中的乘客在航程中被限制在自己的房间里，并处于昏迷状态。因此，他们无法在船上设施上花费金钱。因此，当 CryoSleep 等于 True 时，我们可以输入 0。

temp = data['CryoSleep'] == True
data.loc[temp, clm] = 0.0

我们将使用 VIP 及其费用之间的关系来替换空值。

for c in clm:
    for val in [True, False]:
        temp = data['VIP'] == val
        k = data[temp].mean()
        data.loc[temp, c] = data.loc[temp, c].fillna(k)

col = 'HomePlanet'
temp = data['VIP'] == False
data.loc[temp, col] = data.loc[temp, col].fillna('Earth')
  
temp = data['VIP'] == True
data.loc[temp, col] = data.loc[temp, col].fillna('Europa')

我们已经用不同的值填充了 VIP 列中的空值。

在观察了异常值之后，我们将用均值填充年龄空值。为此，我们将绘制箱线图。

sb.boxplot(data['Age'])
plt.show()

输出

通过这个箱线图，我们可以计算出均值，然后替换空值。

temp = data[data['Age'] < 60]['Age'].mean()
data['Age'] = data['Age'].fillna(temp)

由于我们已经填充了年龄值的空值。现在我们将再次检查是否有空值。

data.isnull().sum().plot.bar()
plt.show()

输出

从这个图中，我们注意到了更多的空值。让我们替换它们。

for cls in data.columns:
    # Checking for null values
    if data[cls].isnull().sum() == 0:
        continue
          
    # The mode will replace the categorical data type values
    if data[cls].dtype == object or data[cls].dtype == bool:
        data[cls] = data[cls].fillna(data[cls].mode()[0])
          
    # Else fill by mean
    else:
        data[cls] = data[cls].fillna(data[cls].mean())
  
data.isnull().sum().sum()

输出

最后，我们从数据集中删除了所有空值。

特征工程

由于我们已经预处理了数据，现在是时候选择特征并将数据添加到其中了。我们将添加一些特征以从数据中获得更多见解并进行更准确的预测。

输出

我们可以看到有些特征包含组合数据。我们将分离数据并从中创建一些新特征。

new_data = data["PassengerId"].str.split("_", n=1, expand=True)
data["RoomNo"] = new_data[0].astype(int)
data["PassengerNo"] = new_data[1].astype(int)
  
data.drop(['PassengerId'], axis=1, inplace=True)

我们将 PassengerID 特征拆分为 RoomNo 和 PassengerNo。

df1 = data['RoomNo']
for i in range(data.shape[0]):
      temp = df1 == df1[i]
      data['PassengerNo'][i] = (temp).sum()

new_data = data["Cabin"].str.split("/", n=2, expand=True)
data["F1"] = new_data[0]
data["F2"] = new_data[1].astype(int)
data["F3"] = new_data[1]
  
data.drop(['Cabin'], axis=1,
        inplace=True)

我们将 Cabin 特征拆分为三个新列 F1、F2 和 F3。并删除了 Cabin 列。

data['LeasureBill'] = data['RoomService'] + data['FoodCourt'] + data['ShoppingMall'] + data['Spa'] + data['VRDeck']

我们将 RoomService、FoodCourt 等不同列合并到 LeseaureBill 中。

探索性数据分析

我们已经转换了不同的特征。现在，是时候可视化和分析数据了。

x = data['Transported'].value_counts()
color= '#4F6272', '#B7C3F3'
plt.pie(x.values,
        labels=x.index,
        autopct='%1.1f%%', colors = color)
plt.show()

输出

从这个饼图中，我们可以看到两个类别具有相等的分布。因此，训练模型将很容易。

data.groupby('VIP').mean()['LeasureBill'].plot.bar()
plt.show()

输出

for col in data.columns:
      # encode the categorical column 
    if data[col].dtype == object:
        lE = LabelEncoder()
        data[col] = lE.fit_transform(data[col])
  
    # In the case of the boolean data type 
    if data[col].dtype == 'bool':
        data[col] = data[col].astype(int)
  
data.head()

输出

5 行 × 22 列

plt.figure(figsize=(10,10))
sb.heatmap(data.corr()>0.8,
           annot=True,
           cbar=False)
plt.show()

输出

训练模型

features = data.drop(['Transported'], axis=1)
target = data.Transported
  
X_train, X_val, Y_train, Y_val = train_test_split(features, target,
                                      test_size=0.1,
                                      random_state=22)
  
X_train.shape, X_val.shape

输出

((7823, 21), (870, 21))

我们将数据集拆分为训练和测试数据集，其中 90% 是训练数据，10% 是测试数据。

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_val = scaler.transform(X_val)

我们已经使用 Standard Scaler 对数据集进行了缩放。

现在，我们将检查不同机器学习模型的训练和验证准确性。

for i in range(len(models)):
    models[i].fit(X_train, Y_train)
  
    print(f'{models[i]} : ')
  
    train_preds = models[i].predict_proba(X_train)[:, 1]
    print('Training Accuracy : ', ras(Y_train, train_preds))
  
    val_preds = models[i].predict_proba(X_val)[:, 1]
    print('Validation Accuracy : ', ras(Y_val, val_preds))
    print()

输出

LogisticRegression() : 
Training Accuracy :  0.878723950049363
Validation Accuracy :  0.8617140797897147

XGBClassifier(base_score=None, booster=None, callbacks=None,
              colsample_bylevel=None, colsample_bynode=None,
              colsample_bytree=None, early_stopping_rounds=None,
              enable_categorical=False, eval_metric=None, feature_types=None,
              gamma=None, gpu_id=None, grow_policy=None, importance_type=None,
              interaction_constraints=None, learning_rate=None, max_bin=None,
              max_cat_threshold=None, max_cat_to_onehot=None,
              max_delta_step=None, max_depth=None, max_leaves=None,
              min_child_weight=None, missing=nan, monotone_constraints=None,
              n_estimators=100, n_jobs=None, num_parallel_tree=None,
              predictor=None, random_state=None, ...) : 
Training Accuracy :  0.9891161010670031
Validation Accuracy :  0.8838555136303896

SVC(probability=True) : 
Training Accuracy :  0.9049843360030313
Validation Accuracy :  0.8660093483698648

我们可以看到，逻辑回归具有87% 的训练准确率和 86% 的验证准确率。XGBClassifier 具有98% 的训练准确率和 88% 的验证准确率。SVC 具有90% 的训练准确率和 86% 的验证准确率。XGB 分类器具有最高的准确率，因此最适合该模型。

评估模型

在三个机器学习模型中，XGB 分类器表现最佳。现在我们将创建一个混淆矩阵并打印预测结果。

y_pred = models[1].predict(X_val)
y_pred

输出

array([0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1,
       1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1,
       0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1,
       1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0,
       1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1,
       1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1,
       1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1,
       1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0,
       1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0,
       1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1,
       0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0,
       0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1,
       1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,
       0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1,
       1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,
       1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1,
       0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0,
       1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1,
       0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0,
       1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1,
       1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0,
       1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
       0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0,
       1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1,
       1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1,
       1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0,
       0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,
       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1,
       0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0,
       0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1,
       0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0,
       0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0,
       1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1,
       1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,
       1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0,
       1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1])

预测 0 表示 False，1 表示 True。

 
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
y_pred = models[1].predict(X_val)
cm = confusion_matrix(Y_val, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
plt.show()

输出

print(metrics.classification_report
      (Y_val, models[1].predict(X_val)))

输出

              precision    recall  f1-score   support

           0       0.82      0.79      0.80       458
           1       0.78      0.80      0.79       412

    accuracy                           0.80       870
   macro avg       0.80      0.80      0.80       870
weighted avg       0.80      0.80      0.80       870

下一话题Python 中的朴素贝叶斯算法

利用机器学习 - Python 进行飞船泰坦尼克号项目

飞船泰坦尼克号项目问题陈述

解决飞船泰坦尼克号问题的方法

数据集的数据预处理

特征工程

探索性数据分析

训练模型

评估模型

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

利用机器学习 - Python 进行飞船泰坦尼克号项目

飞船泰坦尼克号项目问题陈述

解决飞船泰坦尼克号问题的方法

数据集的数据预处理

特征工程

探索性数据分析

训练模型

评估模型

相关帖子

Python 解决方案：Largest Rectangle Hackerrank

Python 中的 reduce()

自定义 Python 模块 'configparser' 的解析行为

Matplotlib 子图中的图例

Python 中的转义序列

Python %s - 字符串格式化

使用 Python 进行 Boyer Moore 算法模式搜索

Python 中的队列

使用 Dash 进行 Python 数据可视化界面开发

如何删除 Python 列表中的最后一个元素

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器