预热TensorFlow2.0(1)——IRIS数据集实战

96
王鹏你妹
2019.01.16 15:10* 字数 1473

TensorFlow 2.0 即将问世,很多API该删的删,该改的改。在这篇文章中我就2.0 版本中以下两点更新,为大家做一下预热(注意:笔者使用的是tensorflow1.9版)。
在tensorflow2.0中:

  • 将使用 Keras 和 eager execution,帮助大家轻松构建模型。
  • 删除了queue runner 以支持 tf.data,帮助大家更快,更方便的构建数据流。

当然还有很多其他的更新,这里笔者不做介绍。

导入tensorflow,开启eager模式

在2.0版本中,默认使用eager模式,所以将不用加tfe.enable_eager_execution()去开启eager模式。

import os
from sklearn.datasets import load_iris
import tensorflow as tf
import tensorflow.contrib.eager as tfe
tfe.enable_eager_execution()

IRIS数据集

Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据集包含150个数据集,分为3类,每类50个数据,每个数据包含4个属性。可通过花萼长度,花萼宽度,花瓣长度,花瓣宽度4个属性预测鸢尾花卉属于(Setosa,Versicolour,Virginica)三个种类中的哪一类。数据集格式如下:
5.1, 3.5, 1.4, 0.2, Iris-setosa
4.9, 3.0, 1.4, 0.2, Iris-setosa
...
7.0, 3.2, 4.7, 1.4, Iris-versicolor
6.4, 3.2, 4.5, 1.5, Iris-versicolor
...
6.3, 3.3, 6.0, 2.5, Iris-virginica
5.8, 2.7, 5.1, 1.9, Iris-virginica

使用tf.data.Dataset读入数据

本次实验中IRIS数据我直接从sklearn的dataset中获取。这里笔者定义了一个数据集的生成器,然后通过tf.data.Dataset.from_generator 从生成器中读入数据,使用data类自带的shuffle,batch,repeat函数构建数据集。

  • shuffle用来打乱数据,其中buffer_size越大,数据打乱的范围就越大;
  • batch将数据流转化成一批一批的,需指定batch_size;
  • repeat是将数据重复几次(和训练过程中的epoch一致)。比如,我的数据集是150个数据,data = data.repeat(2) 意味着构建一个300个数据的迭代器,迭代器里面数据用完了就会报OutOfRangeError的错误。如果不指定就代构建一个无限循环的迭代器。这里笔者构建了一个无限循环的迭代器。
iris = load_iris() #the dataset has 150 labeled datas  
def generate_data():
    for i,j in zip(iris["data"],iris["target"]):
        yield (i,j)   #i  is feature:[1.2, 3.1, 0.3, 6.2 ] ,j is label :0 or 1 or 2
 
data = tf.data.Dataset.from_generator(generate_data,(tf.float32,tf.int32), (tf.TensorShape([4]), tf.TensorShape([])))
data = data.shuffle(150)# shuffle all data
data = data.batch(10)# 
#data = data.repeat(2)
data = data.repeat()
iter_data = data.make_one_shot_iterator()

从迭代器中拿出一个数据瞧一瞧:

feature_e,label_e = iter_data.get_next()

feature_e就是一个batch的特征数据,10个4维的特征向量。


feature_e

label_e就是与之相对应的10个标签数据。如下图:


label_e

使用tf.keras构建模型

模型构建使用tf.keras API 很快构建一个三层,每层的神经元个数分别为10,10,3的神经网络。

model = tf.keras.Sequential([
        tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)),  # input shape required
        tf.keras.layers.Dense(10, activation=tf.nn.relu),
        tf.keras.layers.Dense(3)
])

构建完模型后,我们把feature_e喂给它,输出结果如下图所示:
模型返回了10行3维的输出,此时你可以用tf.nn.softmax将输出转化为每一类对应的概率。不过tensoflow的loss function已经帮我们实现了这一步。

model(feature_e)
模型输出

接下来我们同测试一下神经网络的效果,还未训练就来测试,有没有搞错。确实,从预测结果来看效果很差,所以,我们需要让它学习起来。

print("Prediction: {}".format(tf.argmax(model(feature_e), axis=1)))
print("Labels: {}".format(label_e))
预测和原标签的对比

定义损失函数,自动求梯度函数

有了模型之后,我们需要通过loss反向传播和梯度下降优化模型。所以定义了loss 函数和自动求梯度函数。

def loss(model,x,y):
    y_ = model(x)
    return tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_)

def grad(model, inputs, targets):
    with tf.GradientTape() as tape:
        loss_value = loss(model, inputs, targets)
    return loss_value, tape.gradient(loss_value, model.trainable_variables)
loss(model,feature_e,label_e)

执行上方代码就可以得到模型在一个batch的数据上的loss。


loss
grad(model,feature_e,label_e)

通过上述代码,我们查看神经网络每个参数。从下图的运行结果,我们可以清晰地看到网络第一层shape为[4,10]的Weight和shape为[10,]的Bias的在loss函数中的梯度值。

with tf.GradientTape() as tape:
     loss_value = loss(model, inputs, targets)

可以自动计算输入变量的梯度。


Gradient

定义梯度下降优化器

定义了一个学习率为0.01的优化器,帮助我们优化损失函数,训练模型。

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

global_step=tf.train.get_or_create_global_step()
loss_value, grads = grad(model,data_e,label_e)
optimizer.apply_gradients(zip(grads, model.variables),global_step)
print("Step: {},Loss: {}".format(global_step.numpy(),loss_value.numpy()))

其中tf.train.get_or_create_global_step()用来记录模型所执行的步数,optimizer.apply_gradients用来优化模型参数。执行上述代码模型就做了一步优化。


单步优化

定义模型训练函数

这里我们定义了train_model函数,需要传入dataset迭代器,神经网络模型,和优化器。
由于数据集的大小为150,batch_size为10,所以我将round_num设为15,这样一轮下来模型就把所有的数据全部看过一遍,也就是一个epoch。

def train_model(training_dataset, model, optimizer):
    train_loss_results = []
    train_accuracy_results = []
    for epoch in range(202):
        epoch_loss_avg = tfe.metrics.Mean()
        epoch_accuracy = tfe.metrics.Accuracy()  
        for round_num in range(15):
                feature,label =  training_dataset.get_next() 
                loss , gradients = grad(model,feature,label)
                optimizer.apply_gradients(zip(gradients, model.variables),
                                          global_step=tf.train.get_or_create_global_step())
                epoch_loss_avg(loss)  # add current batch loss
                epoch_accuracy(tf.argmax(model(data_), axis=1, output_type=tf.int32),label)
        if epoch  % 50 == 0:
            print("Epoch {:03d}: Loss: {:.3f}, Accuracy: {:.3%}".format(epoch,
                                                                        epoch_loss_avg.result(),
                                                                        epoch_accuracy.result()))

万事俱备,只欠东风,让神经网络跑起来。200个epoch,就让网络的准确率达到了百分之99。不要太开心,在这么少量的数据集上多半过拟合了。

train_model(iter_ ,model, optimizer)
train

无所谓,至少这个神经网络应该比没训练之前强吧,我来验证一下,让训练过后的它再预测一遍。

print("Prediction: {}".format(tf.argmax(model(feature_e), axis=1)))
print("Labels: {}".format(label_e))
预测和原标签的对比

哇,只错了一个,不得不说,它确实学乖了。

结语

这里我们通过一个iris数据集的小例子,简单的介绍了一下即将到来的tensorflow2.0的模型构建过程中,需要用到的新API——tf.datatf.keras
和旧版的tf比,新的API是不是要好用的多。而且在eager动态图模式下,整个workflow已经完全抛弃了以前先定义静态图,再通过一个session去运行图的流程,确实方便了许多。同志们不要犹豫,拥抱tensorflow2.0,赶紧用起来吧。

参考:
https://tensorflow.google.cn/tutorials/eager/custom_training_walkthrough

日记本
Web note ad 1