• Titanic 泰坦尼克号预测-Tensorflow 方法-【Kaggle 比赛】

    本文介绍Kaggle入门比赛Titanic泰坦尼克号幸存预测的解题思路，使用的是神经网络和Tensorflow框架。提交代码附在本文的最后部分。

    基本思路为:

    1. 导入数据集
    2. 对数据预处理
    3. 训练
    4. 预测并输出结果

    一、入门介绍

    1. 比赛介绍

            Kaggle是一个数据建模和数据分析竞赛平台。

            泰坦尼克号幸存预测是Kaggle上的一个入门级比赛，利于平台给的数据集，预测泰坦尼克号上不同乘客的幸存情况，并熟悉机器学习基础知识。

    2. 板块介绍

    Titanic比赛的主页-Kaggle
    Titanic比赛的主页-Kaggle

    比赛地址：Titanic - Machine Learning from Disaster

    Titanic - Machine Learning from Disasterhttps://www.kaggle.com/competitions/titanic

    Kaggle的主页面如上，我们主要关注 Overview、Data 和 Submit Predictions 三个板块

    • Overview: 比赛的基本介绍
    • Data: 数据集的结构和字段介绍，在这里可以下载所需要的数据集
    • Submit Predictions: 提交预测结果，并查看本次比赛的分数

    其他板块如 Code 可以查看其他团队分享的代码，Discussion 是解题思路的分享，Leaderboard 是分数排行榜。

    3. 平台提交流程

    1. 首先在 data 板块中点击“Download All”下载训练集和测试集
    2. 训练集附带真实结果，而测试集是用来做预测并提交结果
    3. 编写代码预测后，按照要求的格式在 Submit Predictions 上传结果，并查看本次提交的分数与排名

    二、方法介绍

    1.理解需求

    比赛很简单：创建一个模型，预测哪些乘客在泰坦尼克号沉船中幸存下来。
    下载下来的数据包括三个文件：训练集（train.csv）, 测试集（test.csv）, 提交示例（gender_submission.csv）

    • 训练集（train.csv）:用于神经网络进行训练的数据集，包含真实结果列(Survival)
    • 测试集（test.csv）:训练好模型后，用此文件中数据进行预测得到结果
    • 提交示例（gender_submission.csv）:最终提交结果的格式示例，包含 PassengerId 和 Survived 两列

    2.数据预处理

    • 可以用各种工具（pandas、Excel 和 Kaggle 自带表格等）分析训练集的数据，判断每一列的数据类型和是否有空缺等情况
    • 去除对结果不影响的列
    • 对空缺的单元进行填充

    3.构建模型

    • 使用 keras 的 Sequence 模型
    • 隐藏层使用 relu 激活函数

    4.模型评估

    • 使用 keras 的 compile, fit, evaluate 方法进行训练和评估
    • 使用 keras 的 predict 方法预测结果，并将结果按提交示例形成 csv 文件输出

    三、编码过程

    • 首先在 data 板块中点击“Download All”下载训练集和测试集

    1.导入数据 load_data

    • 使用 pandas 的 read_csv 方法，导入数据 load_data
    1. # 提前将所有包引入
    2. import pandas as pd
    3. import numpy as np
    4. import tensorflow as tf
    5. from tensorflow.python.keras import activations
    6. import matplotlib.pyplot as plt
    7. from tensorflow.keras import regularizers
    8. import datetime
    9.  
    10. # 导入数据
    11. def load_data(path_url, test_path_url):
    12.     raw_train_dataset = pd.read_csv(path_url)
    13.     raw_test_dataset = pd.read_csv(test_path_url)
    14.     return raw_train_dataset, raw_test_dataset
    15.  
    16. if __name__ == "__main__":
    17.     # 1. 导入数据
    18.     path_url = r"kaggle\titanic\train.csv"
    19.     test_path_url = r"kaggle\titanic\test.csv"
    20.     raw_train_dataset, raw_test_dataset = load_data(path_url, test_path_url)

    2.数据预处理 preprocess

    • 首先我们确定数据集 features_test

      训练集 train.csv 中共包含 12 列，分别是 passengerId,survival,pclass,name,sex,Age,sibsp,parch,ticket,fare,cabin,embarked。

      通过分析可知对预测结果有影响的列为 Pclass,Sex,Fare,Age,SibSp,Parch,Embarked，而Survived为真实标签列。PassengerId在测试集中会用到。

      根据以上分析确定所需的列，形成features_test，将训练集裁剪为所需列。

    • 接下来对数据的缺失值进行填补

      用pandas的describe()和isnull().sum()方法可以对训练集进行数值统计，考虑以中位数来替代缺失值。其中缺失较多的列为Age和Fare列。

    • 数据类型统一为数字编码
      考虑Sex和Embarked列是字符串，将其修改为每一个可能性字符单独一列，并去除原列。

    • 归一化输入（标准化）
      第一步是零均值化，每个训练数据𝑥减去均值𝜇。第二步是归一化方差。

    • 分别处理训练集和测试集
      对于训练集，我们要把Survived列单独提出来作为标签，即真实值。

      对于测试集，对比提交示例（gender_submission.csv）文件，我们保留PassengerId列作为索引id。

    1. # 数据预处理的基础方法
    2. def preprocess(raw_dataset, features, train=True):
    3.     """用于predict的数据预处理
    4.     Args:
    5.         input: dataset = pandas.DataFrame对象
    6.     """
    7.     # 以中位数来替代
    8.     if "Age" in features:
    9.         raw_dataset["Age"].fillna(raw_dataset["Age"].median(), inplace=True)
    10.     raw_dataset["Fare"].fillna(raw_dataset["Fare"].median(), inplace=True)
    11.     # Embarked也可以为最多值
    12.     raw_dataset["Embarked"].fillna(raw_dataset["Fare"].median(), inplace=True)
    13.     dataset = raw_dataset[features]
    14.     dataset = dataset.copy()
    15.  
    16.     # 由于 embarked=登船港口, Port of Embarkation	C = Cherbourg, Q = Queenstown, S = Southampton
    17.  
    18.     Embarked = dataset.pop("Embarked")
    19.  
    20.     # 根据 embarked 列来写入新的 3 个列
    21.     dataset["S"] = (Embarked == "S") * 1.0
    22.     dataset["C"] = (Embarked == "C") * 1.0
    23.     dataset["Q"] = (Embarked == "Q") * 1.0
    24.  
    25.     # 根据 sex 列来写入新的 2 个列
    26.     Sex = dataset.pop("Sex")
    27.     dataset["Male"] = (Sex == "male") * 1.0
    28.     dataset["Female"] = (Sex == "female") * 1.0
    29.  
    30.     dataset_withoutna = dataset
    31.     if train:
    32.         labels = dataset_withoutna["Survived"]
    33.         dataset_withoutna.pop("PassengerId")
    34.         dataset_withoutna.pop("Survived")
    35.         # 标准化,归一化输入
    36.         train_stats = dataset_withoutna.describe()
    37.         train_stats = train_stats.transpose()
    38.         normed_train_data = (dataset_withoutna - train_stats["mean"]) / train_stats[
    39.             "std"
    40.         ]
    41.         return np.array(normed_train_data), np.array(labels)
    42.     else:
    43.         labels = dataset.pop("PassengerId")
    44.         dataset.fillna(0, inplace=True)
    45.         test_stats = dataset.describe()
    46.         test_stats = test_stats.transpose()
    47.         normed_test_data = (dataset - test_stats["mean"]) / test_stats["std"]
    48.         return np.array(normed_test_data), np.array(labels)
    49.  
    50. if __name__ == "__main__":
    51.  
    52.     # 1. 导入数据
    53.     path_url = r"kaggle\titanic\train.csv"
    54.     test_path_url = r"kaggle\titanic\test.csv"
    55.  
    56.     raw_train_dataset, raw_test_dataset = load_data(path_url, test_path_url)
    57.  
    58.     # 2. 数据预处理
    59.     features_test = [
    60.         "PassengerId",
    61.         "Pclass",
    62.         "Sex",
    63.         "Fare",
    64.         "Age",
    65.         "SibSp",
    66.         "Parch",
    67.         "Embarked",
    68.     ]
    69.     features_train = features_test + ["Survived"]
    70.  
    71.     # 获取预处理后的训练集和标签
    72.     train_dataset, labels = preprocess(raw_train_dataset, features_train)

    3.训练 train 

    • 采用Sequential构建网络模型
      通过Kera 提供的网络容器Sequential生成网络模型，模型的深度为4层，分别有64、32、16和1个的神经单元，前三层使用relu激活函数并应用𝐿2正则化。

    • compile,fit,evaluate和predict
      在Sequential搭建好网络结构后，compile,fit,evaluate和predict是常用的keras训练和验证的方法。

      首先是compile，即模型装配。用于设置网络使用的优化器对象、损失函数类型，评价指标等设定。这里我们选定Adam优化器，binary_crossentropy损失函数，设置测量指标为准确率。

      接下来是fit，即模型训练。模型装配完成后，即可通过 fit()函数送入待训练的数据集和验证用的数据集，这一步称为模型训练。此处可选定epochs数量，并设定从训练集中切分出的验证集的比例。

      evaluate，即模型测试，测试在训练所有样本上的性能表现。

      predict，即模型预测，可使用训练好的模型去预测新样本的标签信息。predict方法将在下一节预测输出中使用。

      evaluate和predict的区别是，evaluate是用已有的真实结果进行检测，而predict是单纯输出预测结果。

    1. # 训练
    2. def train(train_dataset, labels, epochs=120, batch_size=512, is_plot=False):
    3.     model = tf.keras.Sequential(
    4.         [
    5.             # 1. input_shape = 输入形状
    6.             # ND 张量的形状：. 最常见的情况是带有 shape 的 2D 输入。
    7.             # (batch_size, ..., input_dim)(batch_size, input_dim)
    8.             # train_dataset.shape[1] = 4
    9.             # 现在模型就会以尺寸为 (*, 4) 的数组作为输入，
    10.             # 2. kernel_regularizer = 应用于kernel权重矩阵的正则化函数。
    11.             # 𝐿2正则化：范数的平方
    12.             tf.keras.layers.Dense(
    13.                 64,
    14.                 activation="relu",
    15.                 input_shape=(train_dataset.shape[1],),
    16.                 kernel_regularizer=regularizers.l2(0.001),
    17.             ),
    18.             tf.keras.layers.Dense(
    19.                 32, activation="relu", kernel_regularizer=regularizers.l2(0.001)
    20.             ),
    21.             tf.keras.layers.Dense(16, activation="relu"),
    22.             tf.keras.layers.Dense(1, name="prediction"),
    23.         ]
    24.     )
    25.  
    26.     # 在 Keras 中提供了 compile()和 fit()函数方便实现逻辑。
    27.     # compile：首先通过compile 函数指定网络使用的优化器对象、损失函数类型，评价指标等设定，这一步称为装配
    28.     # fit： 模型装配完成后，即可通过 fit()函数送入待训练的数据集和验证用的数据集
    29.     model.compile(
    30.         # Adam的学习律默认为0.001
    31.         optimizer=tf.keras.optimizers.Adam(),
    32.         # BinaryCrossentropy:计算真实标签和预测标签之间的交叉熵损失
    33.         loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
    34.         # 设置测量指标为准确率
    35.         metrics=["accuracy"],
    36.     )
    37.  
    38.     # early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
    39.     # 模型装配完成后，即可通过 fit()函数送入待训练的数据集和验证用的数据集，这一步称为模型训练
    40.     # fit函数的参数:
    41.     # x = Input data
    42.     # y = Target data
    43.     # verbose = 'auto'、0、1 或 2 详细模式。
    44.     # 0 = 静音，1 = 进度条，2 = 每个 epoch 一行。'auto' 在大多数情况下默认为 1
    45.     history = model.fit(
    46.         x=train_dataset,
    47.         y=labels,
    48.         epochs=epochs,
    49.         validation_split=0.01,
    50.         batch_size=batch_size,
    51.         verbose="auto",
    52.         # callbacks=[early_stop]
    53.     )
    54.  
    55.     # 显示训练情况
    56.     if is_plot:
    57.         plot_history(history)
    58.  
    59.     # 可以通过 Model.evaluate(db)循环测试完 db 数据集上所有样本
    60.     loss, accuracy = model.evaluate(train_dataset, labels, verbose=2)
    61.     print("Accuracy:", accuracy)
    62.  
    63.     return model
    64.  
    65. if __name__ == "__main__":
    66.  
    67.     # 1. 导入数据
    68.     path_url = r"kaggle\titanic\train.csv"
    69.     test_path_url = r"kaggle\titanic\test.csv"
    70.  
    71.     raw_train_dataset, raw_test_dataset = load_data(path_url, test_path_url)
    72.  
    73.     # 2. 数据预处理
    74.     features_test = [
    75.         "PassengerId",
    76.         "Pclass",
    77.         "Sex",
    78.         "Fare",
    79.         "Age",
    80.         "SibSp",
    81.         "Parch",
    82.         "Embarked",
    83.     ]
    84.     features_train = features_test + ["Survived"]
    85.  
    86.     # 获取预处理后的训练集和标签
    87.     train_dataset, labels = preprocess(raw_train_dataset, features_train)
    88.  
    89.     # 3. 训练
    90.     model = train(train_dataset, labels, epochs=256, is_plot=True)
    91.

    4.真实预测并输出csv predict_out

    • 使用predict进行预测
    • 将大于0.5的值设置为1，反之设置为0
    • 输出提交的csv文件
      参考提交示例（gender_submission.csv）文件，第一列为PassengerId，第二列为预测结果，并使用to_csv方法输出csv文件。
    1. # 真实预测并输出csv
    2. def predict_out(model, csv_path):
    3.     # model.evaluate 和 model.predict 的区别
    4.     # https://blog.csdn.net/DoReAGON/article/details/88552348
    5.     # 两者差异：
    6.     # 1
    7.     # 输入输出不同
    8.     # model.evaluate输入数据(data)和金标准(label),然后将预测结果与金标准相比较,得到两者误差并输出.
    9.     # model.predict输入数据(data),输出预测结果
    10.     # 2
    11.     # 是否需要真实标签(金标准)
    12.     # model.evaluate需要,因为需要比较预测结果与真实标签的误差
    13.     # model.predict不需要,只是单纯输出预测结果,全程不需要金标准的参与.
    14.     predictions = model.predict(test_dataset)
    15.     # 通过astype()方法可以强制转换数据的类型。
    16.     predictions = (tf.sigmoid(predictions).numpy().flatten() > 0.5).astype(int)
    17.     print(predictions.shape, predictions)
    18.     # 输出结果
    19.     output = pd.DataFrame({"PassengerId": passenger_id, "Survived": predictions})
    20.     # index=False 不保存行索引,index=是否保留行索引
    21.     output.to_csv(csv_path, index=False)
    22.     print(f"您的提交文件保存成功! 位置在{csv_path}")
    23.     return predictions
    24.  
    25.  
    26. if __name__ == "__main__":
    27.  
    28.     # 1. 导入数据
    29.     path_url = r"kaggle\titanic\train.csv"
    30.     test_path_url = r"kaggle\titanic\test.csv"
    31.  
    32.     raw_train_dataset, raw_test_dataset = load_data(path_url, test_path_url)
    33.  
    34.     # 2. 数据预处理
    35.     features_test = [
    36.         "PassengerId",
    37.         "Pclass",
    38.         "Sex",
    39.         "Fare",
    40.         "Age",
    41.         "SibSp",
    42.         "Parch",
    43.         "Embarked",
    44.     ]
    45.     features_train = features_test + ["Survived"]
    46.  
    47.     # 获取预处理后的训练集和标签
    48.     train_dataset, labels = preprocess(raw_train_dataset, features_train)
    49.  
    50.     # 3. 训练
    51.     model = train(train_dataset, labels, epochs=256, is_plot=True)
    52.  
    53.     # 获取预处理后的测试集和序号
    54.     test_dataset, passenger_id = preprocess(
    55.         raw_test_dataset, features_test, train=False
    56.     )
    57.  
    58.     csv_path = f"./submission_{get_time()}.csv"
    59.     prediction = predict_out(model, csv_path)

     5.其他工具方法

    • 显示训练情况 plot_history

      使用model.fit的返回值History.history即训练数据记录，读取accuracy和val_accuracy来绘制准确率曲线。

      1. # 显示训练情况
      2. def plot_history(history):
      3.     # histoty的返回值
      4.     # A History object. Its History.history attribute is a record of training loss values and metrics values at successive epochs, as well as validation loss values and validation metrics values (if applicable).
      5.     # 一个历史对象。它的 History.history 属性是连续 epoch 的训练损失值和指标值的记录，
      6.     # 以及验证损失值和验证指标值（如果适用）。
      7.     # history.history：loss、accuracy、val loss、val accuracy
      8.     hist = pd.DataFrame(history.history)
      9.     hist["epoch"] = history.epoch
      10.  
      11.     plt.figure()
      12.     plt.xlabel("Num of Epochs")
      13.     plt.ylabel("value")
      14.     # plt.plot(hist["epoch"], hist["loss"], label="Loss")
      15.     # plt.plot(hist["epoch"], hist["val_loss"], label="val_loss")
      16.     plt.plot(hist["epoch"], hist["accuracy"], label="accuracy")
      17.     plt.plot(hist["epoch"], hist["val_accuracy"], label="val_accuracy")
      18.     plt.ylim([0, 1])
      19.     plt.legend()
      20.     plt.show()

    • 获取年月日时分秒 get_time

      在输出预测结果csv的时候附上时间，方便区别。

    1. # 获取年月日时分秒
    2. def get_time():
    3.     return datetime.datetime.now().strftime("%Y%m%d%H%M")
    • 主函数 main
    1. # #### Titanic - Machine Learning from Disaster
    2.  
    3. if __name__ == "__main__":
    4.  
    5.     # 1. 导入数据
    6.     path_url = r"kaggle\titanic\train.csv"
    7.     test_path_url = r"kaggle\titanic\test.csv"
    8.  
    9.     raw_train_dataset, raw_test_dataset = load_data(path_url, test_path_url)
    10.  
    11.     # 2. 数据预处理
    12.     features_test = [
    13.         "PassengerId",
    14.         "Pclass",
    15.         "Sex",
    16.         "Fare",
    17.         "Age",
    18.         "SibSp",
    19.         "Parch",
    20.         "Embarked",
    21.     ]
    22.     features_train = features_test + ["Survived"]
    23.  
    24.     # 获取预处理后的训练集和标签
    25.     train_dataset, labels = preprocess(raw_train_dataset, features_train)
    26.  
    27.     # 3. 训练
    28.     model = train(train_dataset, labels, epochs=256, is_plot=True)
    29.  
    30.     # 获取预处理后的测试集和序号
    31.     test_dataset, passenger_id = preprocess(
    32.         raw_test_dataset, features_test, train=False
    33.     )
    34.  
    35.     csv_path = f"./submission_{get_time()}.csv"
    36.     prediction = predict_out(model, csv_path)
    37.  
    38.     # 验证与原始数据raw_test_dataset长度是否一致
    39.     if prediction.shape[0] == raw_test_dataset.shape[0]:
    40.         print(f"--预测长度={prediction.shape[0]}校验通过 √")
    41.     else:
    42.         print(
    43.             f"--预测长度与raw_test_dataset长度不一致 ×,prediction.shape={prediction.shape},raw_test_dataset.shape={raw_test_dataset.shape}"
    44.         )
    45.

    四、总结

    调整validation_split的比例为0.01后，最后最高分数为0.78947，排名前8%。基本达到学习完成Titanic泰坦尼克号幸存预测比赛的程度。

    比赛中比较重要的是需要对数据进行仔细分析，可以利用Excel和pandas等工具分析数据，提取出有用的数据列，并对缺失值进行填补。

    五、参考资料

    1. 机器学习项目实战（一）： Kaggle Titanic机器学习项目实战（一）： Kaggle Titanichttps://wangxin1248.github.io/machinelearning/2018/10/titanic.html

    2. Kaggle入门系列（三）Titanic初试身手

    https://zhuanlan.zhihu.com/p/29086614http://xn--kaggletitanic-130u340bnvcfd1366ar7zf4cucvpmny2bdk67bza

    3. Titanic Tutorial

    Titanic Tutorialhttps://www.kaggle.com/code/alexisbcook/titanic-tutorial

    4. 用TensorFlow完成Kaggle Titanic竞赛

    用TensorFlow完成Kaggle Titanic竞赛https://www.jianshu.com/p/f5a7487e6ff2

    六、代码原文

    titanic_predict.py

    1. import pandas as pd
    2. import numpy as np
    3. import tensorflow as tf
    4. from tensorflow.python.keras import activations
    5. import matplotlib.pyplot as plt
    6. from tensorflow.keras import regularizers
    7. import datetime
    8.  
    9. # 显示训练情况
    10. def plot_history(history):
    11.     # histoty的返回值
    12.     # 一个历史对象。它的 History.history 属性是连续 epoch 的训练损失值和指标值的记录，以及验证损失值和验证指标值（如果适用）。
    13.     # history.history：loss、accuracy、val loss、val accuracy
    14.     hist = pd.DataFrame(history.history)
    15.     hist["epoch"] = history.epoch
    16.  
    17.     plt.figure()
    18.     plt.xlabel("Num of Epochs")
    19.     plt.ylabel("value")
    20.     plt.plot(hist["epoch"], hist["accuracy"], label="accuracy")
    21.     plt.plot(hist["epoch"], hist["val_accuracy"], label="val_accuracy")
    22.     plt.ylim([0, 1])
    23.     plt.legend()
    24.     plt.show()
    25.  
    26.  
    27. # 导入数据
    28. def load_data(path_url, test_path_url):
    29.     raw_train_dataset = pd.read_csv(path_url)
    30.     raw_test_dataset = pd.read_csv(test_path_url)
    31.     return raw_train_dataset, raw_test_dataset
    32.  
    33.  
    34. # 数据预处理的基础方法
    35. def preprocess(raw_dataset, features, train=True):
    36.     """用于predict的数据预处理
    37.     Args:
    38.         input: dataset = pandas.DataFrame对象
    39.     """
    40.     # 以中位数来替代
    41.     if "Age" in features:
    42.         raw_dataset["Age"].fillna(raw_dataset["Age"].median(), inplace=True)
    43.     raw_dataset["Fare"].fillna(raw_dataset["Fare"].median(), inplace=True)
    44.     raw_dataset["Embarked"].fillna(raw_dataset["Fare"].median(), inplace=True)
    45.     dataset = raw_dataset[features]
    46.     dataset = dataset.copy()
    47.  
    48.     # 由于 embarked=登船港口, Port of Embarkation	C = Cherbourg, Q = Queenstown, S = Southampton
    49.  
    50.     Embarked = dataset.pop("Embarked")
    51.  
    52.     # 根据 embarked 列来写入新的 3 个列
    53.     dataset["S"] = (Embarked == "S") * 1.0
    54.     dataset["C"] = (Embarked == "C") * 1.0
    55.     dataset["Q"] = (Embarked == "Q") * 1.0
    56.  
    57.     # 根据 sex 列来写入新的 2 个列
    58.     Sex = dataset.pop("Sex")
    59.     dataset["Male"] = (Sex == "male") * 1.0
    60.     dataset["Female"] = (Sex == "female") * 1.0
    61.  
    62.     dataset_withoutna = dataset
    63.     if train:
    64.         labels = dataset_withoutna["Survived"]
    65.         dataset_withoutna.pop("PassengerId")
    66.         dataset_withoutna.pop("Survived")
    67.         # 标准化
    68.         train_stats = dataset_withoutna.describe()
    69.         train_stats = train_stats.transpose()
    70.         normed_train_data = (dataset_withoutna - train_stats["mean"]) / train_stats[
    71.             "std"
    72.         ]
    73.         return np.array(normed_train_data), np.array(labels)
    74.     else:
    75.         labels = dataset.pop("PassengerId")
    76.         dataset.fillna(0, inplace=True)
    77.         test_stats = dataset.describe()
    78.         test_stats = test_stats.transpose()
    79.         normed_test_data = (dataset - test_stats["mean"]) / test_stats["std"]
    80.         return np.array(normed_test_data), np.array(labels)
    81.  
    82.  
    83. # 训练
    84. def train(train_dataset, labels, epochs=120, batch_size=512, is_plot=False):
    85.     model = tf.keras.Sequential(
    86.         [
    87.             # 1. input_shape = 输入形状
    88.             # ND 张量的形状：. 最常见的情况是带有 shape 的 2D 输入。
    89.             # 2. kernel_regularizer = 应用于kernel权重矩阵的正则化函数。
    90.             # 𝐿2正则化：范数的平方
    91.             tf.keras.layers.Dense(
    92.                 64,
    93.                 activation="relu",
    94.                 input_shape=(train_dataset.shape[1],),
    95.                 kernel_regularizer=regularizers.l2(0.001),
    96.             ),
    97.             tf.keras.layers.Dense(
    98.                 32, activation="relu", kernel_regularizer=regularizers.l2(0.001)
    99.             ),
    100.             tf.keras.layers.Dense(16, activation="relu"),
    101.             tf.keras.layers.Dense(1, name="prediction"),
    102.         ]
    103.     )
    104.  
    105.     # 在 Keras 中提供了 compile()和 fit()函数方便实现逻辑。
    106.     # compile：首先通过compile 函数指定网络使用的优化器对象、损失函数类型，评价指标等设定，这一步称为装配
    107.     # fit： 模型装配完成后，即可通过 fit()函数送入待训练的数据集和验证用的数据集
    108.     model.compile(
    109.         # Adam的学习律默认为0.001
    110.         optimizer=tf.keras.optimizers.Adam(),
    111.         # BinaryCrossentropy:计算真实标签和预测标签之间的交叉熵损失
    112.         loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
    113.         # 设置测量指标为准确率
    114.         metrics=["accuracy"],
    115.     )
    116.  
    117.  
    118.     # 模型装配完成后，即可通过 fit()函数送入待训练的数据集和验证用的数据集，这一步称为模型训练
    119.     # verbose = 'auto'、0、1 或 2 详细模式。
    120.     # 0 = 静音，1 = 进度条，2 = 每个 epoch 一行。'auto' 在大多数情况下默认为 1
    121.     history = model.fit(
    122.         x=train_dataset,
    123.         y=labels,
    124.         epochs=epochs,
    125.         validation_split=0.3,
    126.         batch_size=batch_size,
    127.         verbose="auto",
    128.         # callbacks=[early_stop]
    129.     )
    130.  
    131.     # 显示训练情况
    132.     if is_plot:
    133.         plot_history(history)
    134.  
    135.     # 可以通过 Model.evaluate(db)循环测试完 db 数据集上所有样本
    136.     loss, accuracy = model.evaluate(train_dataset, labels, verbose=2)
    137.     print("Accuracy:", accuracy)
    138.  
    139.     return model
    140.  
    141.  
    142. # 真实预测并输出csv
    143. def predict_out(model, csv_path):
    144.     # model.evaluate 和 model.predict 的区别
    145.     # https://blog.csdn.net/DoReAGON/article/details/88552348
    146.     # 两者差异：
    147.     # 1
    148.     # 输入输出不同
    149.     # model.evaluate输入数据(data)和金标准(label),然后将预测结果与金标准相比较,得到两者误差并输出.
    150.     # model.predict输入数据(data),输出预测结果
    151.     # 2
    152.     # 是否需要真实标签(金标准)
    153.     # model.evaluate需要,因为需要比较预测结果与真实标签的误差
    154.     # model.predict不需要,只是单纯输出预测结果,全程不需要金标准的参与.
    155.     predictions = model.predict(test_dataset)
    156.     # 通过astype()方法可以强制转换数据的类型。
    157.     predictions = (tf.sigmoid(predictions).numpy().flatten() > 0.5).astype(int)
    158.     print(predictions.shape, predictions)
    159.     # 输出结果
    160.     output = pd.DataFrame({"PassengerId": passenger_id, "Survived": predictions})
    161.     # index=False 不保存行索引,index=是否保留行索引
    162.     output.to_csv(csv_path, index=False)
    163.     print(f"您的提交文件保存成功! 位置在{csv_path}")
    164.     return predictions
    165.  
    166.  
    167. # 获取年月日时分秒
    168. def get_time():
    169.     return datetime.datetime.now().strftime("%Y%m%d%H%M")
    170.  
    171.  
    172. # #### Titanic - Machine Learning from Disaster
    173.  
    174. if __name__ == "__main__":
    175.  
    176.     # 1. 导入数据
    177.     path_url = r"kaggle\titanic\train.csv"
    178.     test_path_url = r"kaggle\titanic\test.csv"
    179.  
    180.     raw_train_dataset, raw_test_dataset = load_data(path_url, test_path_url)
    181.  
    182.     # 2. 数据预处理
    183.     features_test = [
    184.         "PassengerId",
    185.         "Pclass",
    186.         "Sex",
    187.         "Fare",
    188.         "Age",
    189.         "SibSp",
    190.         "Parch",
    191.         "Embarked",
    192.     ]
    193.     features_train = features_test + ["Survived"]
    194.  
    195.     # 获取预处理后的训练集和标签
    196.     train_dataset, labels = preprocess(raw_train_dataset, features_train)
    197.  
    198.     # 3. 训练
    199.     model = train(train_dataset, labels, epochs=256, is_plot=True)
    200.  
    201.     # 获取预处理后的测试集和序号
    202.     test_dataset, passenger_id = preprocess(
    203.         raw_test_dataset, features_test, train=False
    204.     )
    205.  
    206.     # 输出预测结果
    207.     csv_path = f"./submission_{get_time()}.csv"
    208.     prediction = predict_out(model, csv_path)
    209.  
    210.     # 验证与原始数据raw_test_dataset长度是否一致
    211.     if prediction.shape[0] == raw_test_dataset.shape[0]:
    212.         print(f"--预测长度={prediction.shape[0]}校验通过 √")
    213.     else:
    214.         print(
    215.             f"--预测长度与raw_test_dataset长度不一致 ×,prediction.shape={prediction.shape},raw_test_dataset.shape={raw_test_dataset.shape}"
    216.         )

    依赖库 requirements.txt

    1. pandas==1.4.3
    2. numpy==1.20.3
    3. matplotlib==3.4.3
    4. tensorflow-cpu==2.9.1
  • 相关阅读:
    《高效能人士的七个习惯》思维导图
    【虚拟现实】二、主要的AR/VR硬件设备
    Minecraft 1.16.5模组开发(五十三) 多种生物类型(Variant)
    linux系统---LNMP架构下部署社区论坛与博客
    A New Image Contrast Enhancement Algorithmusing Exposure Fusion Framework
    圣经投屏Java+sqlite3极速版
    东芝发布智能栅极驱动光电耦合器，简化功率器件外围电路的设计
    C语言基础篇 —— 3.4 二重指针
    搭建远端存储，深度解读SPDK NVMe-oF target
    Python搭配GBase 8s
  • 原文地址：https://blog.csdn.net/TimVan1596/article/details/126407492