1-1 结构化数据建模流程范例

最新推荐文章于 2024-06-30 22:07:15 发布

Avada__Kedavra

最新推荐文章于 2024-06-30 22:07:15 发布

阅读量1.1k

点赞数 1

分类专栏： TensorFlow 2.0

本文链接：https://blog.csdn.net/u014128608/article/details/110443266

版权

TensorFlow 2.0 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

一、准备数据

titanic数据集（下载链接：https://www.kaggle.com/c/titanic/data）的目标是根据乘客信息预测他们在Titanic号撞击冰山沉没后能否生存。

结构化数据一般会使用Pandas中的DataFrame进行预处理。

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
import tensorflow as tf 
from tensorflow.keras import models,layers

dftrain_raw = pd.read_csv('./data/titanic/train.csv')
dftest_raw = pd.read_csv('./data/titanic/test.csv')
dftrain_raw.head(10)

在这里插入图片描述
字段说明：

Survived:0代表死亡，1代表存活【y标签】
Pclass:乘客所持票类，有三种值(1,2,3) 【转换成onehot编码】
Name:乘客姓名【舍去】
Sex:乘客性别【转换成bool特征】
Age:乘客年龄(有缺失) 【数值特征，添加“年龄是否缺失”作为辅助特征】
SibSp:乘客兄弟姐妹/配偶的个数(整数值) 【数值特征】
Parch:乘客父母/孩子的个数(整数值)【数值特征】
Ticket:票号(字符串)【舍去】
Fare:乘客所持票的价格(浮点数，0-500不等) 【数值特征】
Cabin:乘客所在船舱(有缺失) 【添加“所在船舱是否缺失”作为辅助特征】
Embarked:乘客登船港口:S、C、Q(有缺失)【转换成onehot编码，四维度 S,C,Q,nan】
利用Pandas的数据可视化功能我们可以简单地进行探索性数据分析EDA（Exploratory Data Analysis）。

label分布情况：备注[1]

%matplotlib inline 
%config InlineBackend.figure_format = 'png'
ax = dftrain_raw['Survived'].value_counts().plot(kind = 'bar',
     figsize = (12,8),fontsize=15,rot = 0)
ax.set_ylabel('Counts',fontsize = 15)
ax.set_xlabel('Survived',fontsize = 15)

在这里插入图片描述
年龄分布情况：

%matplotlib inline
%config InlineBackend.figure_format = 'png'
ax = dftrain_raw['Age'].plot(kind = 'hist',bins = 20,color= 'purple',
                    figsize = (12,8),fontsize=15)

ax.set_ylabel('Frequency',fontsize = 15)
ax.set_xlabel('Age',fontsize = 15)

在这里插入图片描述
年龄和label的相关性

%matplotlib inline
%config InlineBackend.figure_format = 'png'
ax = dftrain_raw.query('Survived == 0')['Age'].plot(kind = 'density',
                      figsize = (12,8),fontsize=15)
dftrain_raw.query('Survived == 1')['Age'].plot(kind = 'density',
                      figsize = (12,8),fontsize=15)
ax.legend(['Survived==0','Survived==1'],fontsize = 12)
ax.set_ylabel('Density',fontsize = 15)
ax.set_xlabel('Age',fontsize = 15)```

在这里插入图片描述
下面为正式的数据预处理

def preprocessing(dfdata):

    dfresult= pd.DataFrame()

    #Pclass
    dfPclass = pd.get_dummies(dfdata['Pclass'])
    dfPclass.columns = ['Pclass_' +str(x) for x in dfPclass.columns ]
    dfresult = pd.concat([dfresult,dfPclass],axis = 1)

    #Sex
    dfSex = pd.get_dummies(dfdata['Sex'])
    dfresult = pd.concat([dfresult,dfSex],axis = 1)

    #Age
    dfresult['Age'] = dfdata['Age'].fillna(0)
    dfresult['Age_null'] = pd.isna(dfdata['Age']).astype('int32')

    #SibSp,Parch,Fare
    dfresult['SibSp'] = dfdata['SibSp']
    dfresult['Parch'] = dfdata['Parch']
    dfresult['Fare'] = dfdata['Fare']

    #Carbin
    dfresult['Cabin_null'] =  pd.isna(dfdata['Cabin']).astype('int32')

    #Embarked
    dfEmbarked = pd.get_dummies(dfdata['Embarked'],dummy_na=True)
    dfEmbarked.columns = ['Embarked_' + str(x) for x in dfEmbarked.columns]
    dfresult = pd.concat([dfresult,dfEmbarked],axis = 1)

    return(dfresult)

x_train = preprocessing(dftrain_raw)
y_train = dftrain_raw['Survived'].values

x_test = preprocessing(dftest_raw)

print("x_train.shape =", x_train.shape )
print("x_test.shape =", x_test.shape )

output

x_train.shape = (891, 15)
x_test.shape = (418, 15)

二、定义模型

使用Keras接口有以下3种方式构建模型：

使用Sequential按层顺序构建模型
使用函数式API构建任意结构模型
继承Model基类构建自定义模型。

此处选择使用最简单的Sequential，按层顺序模型。

model = models.Sequential()
model.add(layers.Dense(20, activation='relu', input_shape=(15, )))
model.add(layers.Dense(10, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

等同于

model = models.Sequential([
    layers.Dense(20, activation = 'relu', input_shape=(15, )),
    layers.Dense(10, activation='relu'),
    layers.Dense(1, activation='sigmoid')])

上述两段代码可以快速完成 3 层网络的搭建，第 1 层的输出节点数设计为20，第 2 层节点数为 10，输出层节点数设计为 1。直接调用这个模型对象 model(x)就可以返回模型最后一层的输出。

神经网络的核心组件是层（layer），它是一种数据处理模块。

model中包含了3个Dense层，它们是密集连接(也叫全连接)的神经层。

可以通过model.summary()输出模型各层的参数状况。

model.summary()

在这里插入图片描述
model.summary()用于输出模型各层的参数状况：

Output Shape：经过该层后，输出数据的维度。
Param：每层参数的个数。Param = （输入数据维度 + 1）* 神经元个数
之所以要加1，是考虑到每个神经元都有一个Bias。

三、训练模型

训练模型通常有3种方法，内置fit方法，内置train_on_batch方法，以及自定义训练循环。此处我们选择最常用也最简单的内置fit方法。

在训练阶段，先通过compile()指定网络使用的优化器对象，损失函数，评价指标。

通过模型训练将binary_crossentropy最小化。

# 二分类问题选择二元交叉熵损失函数
# 模型训练中选择 adam 优化器、评估指标选择 AUC
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['AUC'])

history = model.fit(x_train, y_train,
                    batch_size=64,
                    epochs=30,
                    validation_split=0.2)  # 分割一部分训练数据用于验证)

output

loss：训练集上的loss
val_loss：验证集上的loss

Epoch 1/30
12/12 [==============================] - 0s 22ms/step - loss: 0.8087 - auc: 0.5287 - val_loss: 0.7104 - val_auc: 0.5894
Epoch 2/30
12/12 [==============================] - 0s 2ms/step - loss: 0.7171 - auc: 0.6003 - val_loss: 0.6742 - val_auc: 0.5702
Epoch 3/30
12/12 [==============================] - 0s 2ms/step - loss: 0.6978 - auc: 0.5724 - val_loss: 0.6298 - val_auc: 0.6240
Epoch 4/30
12/12 [==============================] - 0s 2ms/step - loss: 0.6520 - auc: 0.6435 - val_loss: 0.5809 - val_auc: 0.7217
Epoch 5/30
12/12 [==============================] - 0s 2ms/step - loss: 0.6325 - auc: 0.6818 - val_loss: 0.5586 - val_auc: 0.7475
Epoch 6/30
12/12 [==============================] - 0s 2ms/step - loss: 0.6123 - auc: 0.7162 - val_loss: 0.5486 - val_auc: 0.8033
Epoch 7/30
12/12 [==============================] - 0s 2ms/step - loss: 0.6017 - auc: 0.7209 - val_loss: 0.5278 - val_auc: 0.8419
Epoch 8/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5923 - auc: 0.7481 - val_loss: 0.5122 - val_auc: 0.8486
Epoch 9/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5833 - auc: 0.7548 - val_loss: 0.5062 - val_auc: 0.8618
Epoch 10/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5856 - auc: 0.7727 - val_loss: 0.5092 - val_auc: 0.8793
Epoch 11/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5678 - auc: 0.7800 - val_loss: 0.4898 - val_auc: 0.8704
Epoch 12/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5615 - auc: 0.7854 - val_loss: 0.4869 - val_auc: 0.8798
Epoch 13/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5568 - auc: 0.7938 - val_loss: 0.4824 - val_auc: 0.8859
Epoch 14/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5497 - auc: 0.7992 - val_loss: 0.4765 - val_auc: 0.8861
Epoch 15/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5497 - auc: 0.8158 - val_loss: 0.4871 - val_auc: 0.8813
Epoch 16/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5425 - auc: 0.8099 - val_loss: 0.4721 - val_auc: 0.8917
Epoch 17/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5518 - auc: 0.8136 - val_loss: 0.4614 - val_auc: 0.8844
Epoch 18/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5276 - auc: 0.8175 - val_loss: 0.4485 - val_auc: 0.8905
Epoch 19/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5188 - auc: 0.8238 - val_loss: 0.4470 - val_auc: 0.8867
Epoch 20/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5161 - auc: 0.8261 - val_loss: 0.4515 - val_auc: 0.8913
Epoch 21/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5132 - auc: 0.8349 - val_loss: 0.4394 - val_auc: 0.8857
Epoch 22/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5073 - auc: 0.8364 - val_loss: 0.4476 - val_auc: 0.8838
Epoch 23/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5071 - auc: 0.8379 - val_loss: 0.4358 - val_auc: 0.8825
Epoch 24/30
12/12 [==============================] - 0s 2ms/step - loss: 0.5075 - auc: 0.8251 - val_loss: 0.4210 - val_auc: 0.8887
Epoch 25/30
12/12 [==============================] - 0s 2ms/step - loss: 0.4999 - auc: 0.8311 - val_loss: 0.4335 - val_auc: 0.8806
Epoch 26/30
12/12 [==============================] - 0s 2ms/step - loss: 0.4888 - auc: 0.8405 - val_loss: 0.4192 - val_auc: 0.8868
Epoch 27/30
12/12 [==============================] - 0s 2ms/step - loss: 0.4857 - auc: 0.8411 - val_loss: 0.4256 - val_auc: 0.8870
Epoch 28/30
12/12 [==============================] - 0s 3ms/step - loss: 0.4816 - auc: 0.8454 - val_loss: 0.4143 - val_auc: 0.8878
Epoch 29/30
12/12 [==============================] - 0s 2ms/step - loss: 0.4773 - auc: 0.8477 - val_loss: 0.4123 - val_auc: 0.8885
Epoch 30/30
12/12 [==============================] - 0s 2ms/step - loss: 0.4860 - auc: 0.8372 - val_loss: 0.4176 - val_auc: 0.8897

fit() 会返回训练过程的数据记录——History对象，该对象包含一个成员history，它是一个字典。

history.history.keys()

output

dict_keys(['loss', 'auc', 'val_loss', 'val_auc'])

四、评估模型

我们首先评估一下模型在训练集和验证集上的效果。

def plot_metric(history, metric):
    train_metrics = history.history[metric]
    val_metrics = history.history['val_'+metric]
    epochs = range(1, len(train_metrics) + 1)
    plt.plot(epochs, train_metrics, 'bo--')
    plt.plot(epochs, val_metrics, 'ro-')
    plt.title('Training and validation '+ metric)
    plt.xlabel("Epochs")
    plt.ylabel(metric)
    plt.legend(["train_"+metric, 'val_'+metric])
    plt.show()

训练集与验证集的loss：

plot_metric(history, "loss")

在这里插入图片描述
训练集与验证集的auc：

plot_metric(history, "auc")

在这里插入图片描述

五、使用模型

model.predict(x_test[0:10])

output

array([[0.07118174],
       [0.42037037],
       [0.11576572],
       [0.12125668],
       [0.5064089 ],
       [0.19314587],
       [0.40002865],
       [0.28856397],
       [0.57163274],
       [0.13519394]], dtype=float32)

预测类别

model.predict_classes(x_test[0:10])

output

array([[0],
       [0],
       [0],
       [0],
       [1],
       [0],
       [0],
       [0],
       [1],
       [0]], dtype=int32)

六、保存模型

可以使用Keras方式保存模型，也可以使用TensorFlow原生方式保存。前者仅仅适合使用Python环境恢复模型，后者则可以跨平台进行模型部署。

推荐使用后一种方式进行保存。

6.1 Keras方式保存

# 保存模型结构及权重

model.save('./data/keras_model.h5')  

del model  #删除现有模型

# identical to the previous one
model = models.load_model('./data/keras_model.h5')
model.predict(x_test[0:10])

array([[0.07118174],
       [0.42037037],
       [0.11576572],
       [0.12125668],
       [0.5064089 ],
       [0.19314587],
       [0.40002865],
       [0.28856397],
       [0.57163274],
       [0.13519394]], dtype=float32)

# 保存模型结构
json_str = model.to_json()

# 恢复模型结构
model_json = models.model_from_json(json_str)

#保存模型权重
model.save_weights('./data/keras_model_weight.h5')

# 恢复模型结构
model_json = models.model_from_json(json_str)
model_json.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['AUC']
    )

# 加载权重
model_json.load_weights('./data/keras_model_weight.h5')
model_json.predict(x_test[0:10])

6.2 TensorFlow原生方式保存

# 保存权重，该方式仅仅保存权重张量
model.save_weights('./data/tf_model_weights.ckpt', save_format="tf")

# 保存模型结构与模型参数到文件,该方式保存的模型具有跨平台性便于部署

model.save('./data/tf_model_savedmodel', save_format="tf")
print('export saved model.')

model_loaded = tf.keras.models.load_model('./data/tf_model_savedmodel')
model_loaded.predict(x_test[0:10])

备注

1. %matplotlib inline的作用？

%matplotlib inline是在使用jupyter notebook 或者 jupyter qtconsole的时候，才会经常用到。

其作用是内嵌画图，省略掉plt.show()这一步骤，直接显示图像。如果不加%matplotlib inline的话，我们在画图结束之后需要加上一行plt.show()才可以显示图像。

2. tf.keras.backend.clear_session()的作用

销毁当前的TF图并创建一个新图，有助于避免旧模型/图层混乱。

3. 关于layers中 input_shape的含义

input_shape=(15, )，这个指的是输入一维的数据。这里一维的数据需要使用‘，’来表示一个元组量。其列代表的是数据的每个属性，而行代表的是每个数据的全部数据。（我理解，每个数据为15维度，整个数据集为（batch_size, 15），代表输入数据维度）。例如，考虑一个含有32个样本的batch，每个样本都是10个向量组成的序列，每个向量长为16，则其输入维度为(32,10,16)，其不包含batch大小的input_shape为(10,16)

4. 模型训练中的epoch、batch size、batch/batch number、iterations

epoch：一个epoch指代所有的数据送入网络中完成一次前向计算及反向传播的过程。那么，为什么我们需要多个epoch呢？我们都知道，在训练时，将所有数据迭代训练一次是不够的，需要反复多次才能拟合收敛。
batch/batch number：由于一个epoch常常太大，计算机无法负荷，我们会将它分成几个较小的batches。~~对一个batch 的样本前向传播 → 计算loss → 反向传播更新参数。~~
batch size：指的是批量大小，也就是一次训练的样本数量。我们训练的时候一般不会一次性将样本全部输入模型，而是分批次的进行训练，每一批里的样本数量就是batch_size。
iterations：所谓iterations就是完成一次epoch所需的batch个数。刚刚提到的，batch numbers就是iterations。

简单一句话说就是，我们有2000个数据，分成4个batch，那么batch size就是500。运行所有的数据进行训练，完成1个epoch，需要进行4次iterations。

5. 如果，loss 选择交叉熵损失函数， metrics选择 auc的话，是怎样优化的呢？

在训练阶段，目的是将loss最小化。AUC是可以观测的另一个评估指标。

每轮epoch的loss是指完成最后一个batch后得到的该轮epoch的loss的加权平均。
metrics是在这次更新完参数后对标签值和预测值进行计算，这里的预测值是模型训练完成后再正向传播得到的ouput，因此相比于loss中的y_pred，metrics的y_pred使用新的神经网络参数计算的。