而泰坦尼克号数据分析比赛是 Kaggle 上的一个比赛,通过训练集和测试机来预测乘客的生还情况。

环境

• Python 3.6
• WSL ubuntu 18.04
• VS Code
• Tensorflow 1 / Tensorflow 2

读取数据

首要目的是将数据读取到内存中，pandas 库可以方便的对数据进行读取。

import pandas as pd
# /mnt/e/python-learn/data/titanic/train.csv
titanic_test_data = pd.read_csv(r'/mnt/e/python-learn/data/titanic/train.csv')

数据清洗

数据清洗在数据分析中占有很重要的一部分。通过下面代码我们可以知道读入数据的数据结构。

titanic_test_data.info()

当执行该代码的时候，会打印出下面的结构。

<class ‘pandas.core.frame.DataFrame’>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
PassengerId 891 non-null int64
Survived 891 non-null int64
Pclass 891 non-null int64
Name 891 non-null object
Sex 891 non-null object
Age 714 non-null float64
SibSp 891 non-null int64
Parch 891 non-null int64
Ticket 891 non-null object
Fare 891 non-null float64
Cabin 204 non-null object
Embarked 889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB

通过观察可以发现，部分数据是丢失的，比如说 Age、Cabin、Embarked。

这里可以看出所有的属性字段，但是有一些字段对于我们的研究是无关的。

PassgengerId 该属性对于乘客是否被救是无关的。

Name，姓名可以说对我们的研究是不太相关的，但是也不能说完全不相关，比如说我们可以从姓名中找到该乘客的家族等。这里我们可以选择把他剔除掉。

Ticket 该字段每个值都是不同的，不会对预测结果产生影响。

Cabin 值缺失太多，我们无法直接去使用

所以我们先把这些无用值进行剔除。

titanic_test_data = titanic_test_data[['Survived', 'Pclass',
                                       'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]

下面就要对这些缺失值进行补全。对缺失值进行补全的方法有很多：

1. 忽略元组

2. 人工填写缺失值

3. 使用一个全局常量填充缺失值

4. 使用属性的中心度量填充缺失值

5. 使用与给定元组属同一类的所有样本的属性均值或者中位数

6. 使用最有可能的值填充缺失值

这里我采用了使用第四点，使用属性的中心度量填充缺失值。

使用平均值对数据进行填充。

# Age
age_median = titanic_train_data['Age'].mean()
titanic_train_data['Age'] = titanic_train_data['Age'].fillna(age_median)

数据归一化

可以看出来，有些属性的值是字符串类型，这些类型对于计算机来说是操作不利的，要将字符串类型改为数值类型。

Sex 这一栏中，给定的值为 male 和 female 两个值，我们可以将它们转化为 0 与 1。

titanic_train_data['Sex'] = [ 1 if x == 'male' else 0 for x in titanic_train_data.Sex]

还有 embarked 也可以进行调整，将字符 C,S,Q 进行转换。

titanic_train_data['Embarked'][titanic_train_data['Embarked'] == 'S'] = 1
titanic_train_data['Embarked'][titanic_train_data['Embarked'] == 'C'] = 2
titanic_train_data['Embarked'][titanic_train_data['Embarked'] == 'Q'] = 3

最后将 label 数据分离出来。

y_data = titanic_train_data
titanic_train_data = titanic_train_data[['Pclass','Sex', 'Age', 'SibSp','Parch', 'Fare', 'Embarked']]
y_label = y_data[['Survived']]

可以用上述方法处理测试集数据。

对 Embarked 进行补全，我们采取出现频率最高的进行补全。

embarked_value = titanic_train_data['Embarked'].value_counts().index[0]
titanic_train_data['Embarked'] = titanic_train_data['Embarked'].fillna(
    embarked_value)

训练模型

创建 Tensor

创建 Tensor。采用线性回归，$ y=\omega x^{\tau } + b $ 。

在数据处理的时候，只留下了7列数据来供我们使用，而最后的结果值只有一个。所以我们对数据进行定义的时候要明白我们的定义的形状。

y = tf.placeholder(name='y', shape=[None, 1], dtype=tf.float32)
x = tf.placeholder(name='x', shape=[None, 7], dtype=tf.float32)
w = tf.Variable(tf.random_uniform([1, 7]), name='w', dtype=tf.float32)
b = tf.Variable(tf.random_uniform([1]), name='b')

Tensor 定义完成后，需要进行对式子进行表达。

z = tf.matmul(w, tf.transpose(x)) + b

损失函数

损失函数是对模型评估的重要方法，这里采用交叉熵进行评估。

loss = tf.nn.sigmoid_cross_entropy_with_logits(
    labels=y_label_data_array_shape , logits=z)
loss = tf.reduce_mean(loss)

优化器

通过优化器来对函数进行求解。这里采用 AdagradOptimizer 算法进行计算，学习率初值为 0.5 。

optimizer = tf.train.AdagradOptimizer(0.5).minimize(loss=loss)

进行训练

我选择了 epoch 为 10000，进行 10000 轮的迭代。同时要对 y_label 进行一下转换，保证形状的正确性。

epoch = 10000
y_label_data_array_shape = tf.reshape(y_label, [1, 891])
y_label_data_array_shape = tf.to_float(y_label_data_array_shape)

每次都将所有的值进行投喂，进行结果训练，并没100次将值进行打印输出，查看当前计算的损失值。

最后将输出的值进行划分为 0 和 1 .

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for i in range(epoch):
        feed = {x: titanic_train_data, y: y_label}
        sess.run(optimizer, feed_dict=feed)

        if i % 100 == 0:
            loss_value = sess.run(
                [loss], feed_dict=feed)
            print(i//100 + 1,   ' loss =>', loss_value)

    pred = sess.run(tf.nn.sigmoid(z) , feed_dict={x: titanic_test_data})
    
    sur = [1 if x > 0.5 else 0 for x in  pred.flatten()]
    submission = pd.DataFrame({
        'PassengerId': original_test_data['PassengerId'],
        'Survived':  sur
    })

    submission.to_csv('titanic-submission.csv', index=False)

这里通过测试集的正确率是 0.78 。

算法还在不断完善。

后记

在国庆期间， Google 发布了 Tensorflow 2。相较于 tf1, tf2 做了很多更改，更加的推荐使用 keras 来进行模型的搭建，也更改了很多 API，比如说不再需要 PlaceHolder，运行不需要再进行 Session 管理，这些更改都极大的我们使用和上手的难度，使 tf 更加易用。

下面贴出 tf2 的兼容代码

tf.compat.v1.disable_eager_execution()
y = tf.compat.v1.placeholder(name='y', shape=[None,1], dtype=tf.float32)
x = tf.compat.v1.placeholder(name='x', shape=[None, 7], dtype=tf.float32)
w = tf.Variable(tf.random.normal([1, 7]), name='w', dtype=tf.float32)
b = tf.Variable(tf.random.normal([1]), name='b')
y_label_tensor = tf.convert_to_tensor(y_label,dtype=tf.float32,dtype_hint=True)
y_label_data_array_shape = tf.reshape(y_label_tensor, [1, 891])

y_label_data_array_shape = tf.cast(y_label_data_array_shape,dtype=tf.float32)
#  z 为预测值
z = tf.matmul(w, tf.transpose(x)) + b

# sigmoid 
# 交叉熵
loss = tf.nn.sigmoid_cross_entropy_with_logits(
    labels=y_label_data_array_shape , logits=z)
loss = tf.reduce_mean(loss)

optimizer = tf.compat.v1.train.AdagradOptimizer(0.1).minimize(loss=loss)

epoch = 10000
loss_value_in_plt = []

with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    feed = {x: titanic_train_data, y: y_label}
    for i in range(epoch):
   
        sess.run(optimizer, feed_dict=feed)

        if i % 100 == 0:
            loss_value = sess.run(
                [loss], feed_dict=feed)
            loss_value_in_plt.append(loss_value)

            print(i//100 + 1,   ' loss =>', loss_value)

    pred = sess.run(tf.nn.sigmoid(z) , feed_dict={x: titanic_test_data})
    
    sur = [1 if x > 0.5 else 0 for x in  pred.flatten()]
    submission = pd.DataFrame({
        'PassengerId': original_test_data['PassengerId'],
        'Survived':  sur
    })

    submission.to_csv('titanic-submission.csv', index=False)

print("训练完毕")

然而，tf2 更加推荐使用 keras。下面是采用 Keras 进行的训练代码。

x = titanic_train_data
y = y_label
model = tf.keras.Sequential()

model.add(tf.keras.layers.Dense(1,input_shape=(7,),activation='sigmoid'))

model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['acc'])

history = model.fit(x,y,epochs=epoch,batch_size=50,verbose=0)

l = model.predict(titanic_test_data)

survived = [1 if x > 0.5 else 0 for x in l]

submission = pd.DataFrame({
    'PassengerId': original_test_data['PassengerId'],
    'Survived':  survived
})

submission.to_csv('titanic-submission.csv', index=False)

MSE

MSE 叫做均方误差

$$L\left (y,\bar{y} \right ) = \frac{1}{n} \sum _{i=1}^{n}\left ( y_{i} - \bar{y_{i}} \right )^{2}$$

在 Tensorflow 中实现

用 tensorflow 实现该函数比较简单，通过内置API方便实现。

tf.reduce_mean(tf.square(y_true - y_pred))

均方误差大部分人都可以很明白它是做什么，为什么这样做。

交叉熵（Cross-Entropy）

第一次接触熵这个词应该是高中化学，表示体系混乱程度的度量。现在熵这个词已经延伸到很多领域，比如说信息熵。

信息熵

信息熵是克劳德·艾尔伍德·香农提出的，用于描述信源的不确定度，代表着随机变量或整个系统的不确定性，熵越大，随机变量或系统的不确定性就越大。

真实分布与非正式分布

例如一个质地均匀的六面骰子🎲，其中有三面全是一点，另外三面是二点，三点和四点。如果丢一次骰子，出现一点的概论为多少。

我们已知了当前骰子六个面的点数情况，那么按照真实分布来说 出现一点的概率为 1/2，所以信息熵为1/2，但是假设我们并不知道骰子六面的分布情况，仍旧一位和普通的骰子一样，那么出现一点的概率为1/6，这就是非真实分布。

并不是任何情况下我们都能了解或者知道事物的真实分布，如何用非真实分布来做出最优解。这就是交叉熵。

交叉熵

交叉熵是度量两个概论分布间的差异性。其中的两个概论分布就是上文所提及的真实分布(p)和非真实分布(q)。

公式

$$H(p,q) = \sum _{k=1}^{N}p_{k}log_{2}\frac{1}{q_{k}} = - \sum _{k=1}^{N}p_{k}log_{2}q_{k}$$

对于丢骰子来说 真实分布是 1/2 非真实分布为 1/6 所以 H(p,q) = 1/2 × log2 (6) = 0.5 × 2.584963 = 1.2924815 。该值远远大于真实分布 1/2 。因此交叉熵越低代表策略越好。

最低的交叉熵就是通过真实分布来进行计算的，因此此时的交叉熵==信息熵。

在 Tensorflow 中实现

loss = tf.nn.sigmoid_cross_entropy_with_logits_v2(labels=y_true,logits=y_pred)
loss = tf.reduce_mean(loss)

参考资料

如何通俗的解释交叉熵与相对熵?

刚刚开始学习 tensorflow 很多东西不是很明白，所以在这里逐条记录，方便记忆和日后的查阅。不过话又说回来，为什么这API的命名如此混乱，一会大写一会小写？

开发环境

系统：Ubuntu 16.04 (WSL)

Python 版本：3.5.2-64bit

Tensorflow 版本: 1.14.0

张量

张量在tensorflow中表示数据的标准方式。简单地说，张量就是多维数组，时二维表到更高维度的扩展。

API 记录

constant

通过 tf.constant() 生成常量张量。

tf.constant(value, dtype=None, shape=None, name='Const', verify_shape=False)

通过定义形状(shape)可以生成同属性(dtype)同值(value)的常量矩阵。其中 verify_shape 规定了 形状是否可以被改变，默认不允许。

constant_0 = tf.constant(0.1, dtype=tf.float32, shape=[2, 2]) 
# [[0.1 0.1]][[0.1 0.1]]

同样可以单独定义

constant_1 = tf.constant([1, 2, 3], tf.int32, name='constant_1')
# [1,2,3]

Variable

变量张量,变量主要是在机器学习中用于训练时候进行的输入和输出变化。

Variable(
    initial_value=None, 
    trainable=None, 
    collections=None, 
    validate_shape=True, 
    caching_device=None, 
    name=None, 
    variable_def=None, 
    dtype=None, 
    expected_shape=None, 
    import_scope=None, 
    constraint=None, 
    use_resource=None, 
    synchronization=VariableSynchronization.AUTO, 
    aggregation=VariableAggregation.NONE, 
    shape=None
)

get_variable

get_variable 也是初始化一个变量，通过 initializer 进行初始化。

x = tf.placeholder(tf.int32, name='x')
y = tf.placeholder(tf.int32, name='y')
get_v = tf.get_variable(
    'v1', initializer=tf.constant_initializer, shape=(3,3))
add = tf.add(x, y, name='add')
with tf.Session() as s:
    s.run(tf.global_variables_initializer())
    print(s.run(get_v))
# [[0. 0. 0.][0. 0. 0.][0. 0. 0.]]

初始化的操作有如下，详情见操作中表初始化操作。

通过 get_variable 初始化的张量，在进行session 运行的时候，要通过 global_variables_initializer 进行全局变量初始化。

注意 在使用该方法时，如果遇到命名冲突会进行报错。

placeholder

placeholder 主要是声明一个张量( Tensor )，但是没有进行赋值，只给该张量规定了类型( dtype )，形状( shape )，和名称( name )。其中 形状，省略后为一维矩阵，名称可以省略。

num1 = tf.placeholder(tf.float32, [2, 2], name='num1')

该条语句生成了一个 2×2 的矩阵，类型全为 float32，名称为 num1 。

当前 num1 没有任何值，要想在后期使用它，在使用时应该给予赋值。

Session

所有的运行都要在 Session 中，所有的操作都要在 Session 中进行。

1. 首先要创建会话 Session sess = tf.Session()
2. 通过 sess.run() 进行计算
3. session.close() 关闭

Session.run()

run(
    fetches,
    feed_dict=None,
    options=None,
    run_metadata=None
)

对于 run 方法有四个参数。

• fetches 可以看作一个操作，要将执行的操作进行传入。
• feed_dict 可以对placeholder 进行赋值操作。对 placeholder 声明的张量进行赋值。
• options
• run_metadata

操作

Tensorflow 在数据流图上都是基于操作，故记录一些操作。

transpose

用于矩阵的交换，如果是二维矩阵表示矩阵转置，三位或者更高维度的矩阵，可以表示互换。

x = tf.placeholder(tf.int32, shape=(2, 3))
with tf.Session() as sess:
    print(sess.run(tf.transpose(x), feed_dict={x: [[1, 2, 3], [3, 4, 5]]}))

# [[1 3]
# [2 4]
# [3 5]]

conv2d

该API是用于卷积神经网络的卷积操作，tf.nn.conv2d(x,w,strudes,padding) 。有着四个参数

truncated_normal

truncated_normal(shape, dtype, seed=0, seed2=0, name=None)该函数会产生正太分布。

• seed
• seed2

参考

• Tensorflow API
• TensorFlow学习–tf.session.run()
• tensorflow中常量(constant)、变量(Variable)、占位符(placeholder)和张量类型转换reshape()
• tensorflow 中文社区