TensorFlow之高层封装（TensorFlow-Slim、TFLearn、Keras、Estimator）学习总结

最新推荐文章于 2024-08-23 00:48:25 发布

J-JunLiang

最新推荐文章于 2024-08-23 00:48:25 发布

阅读量2.4k

点赞数 3

CC 4.0 BY-SA版权

分类专栏：学习笔记 TensorFlow 文章标签： TensorFlow高层封装 Keras TensorFlow-Slim Estimator TFLearn

本文链接：https://blog.youkuaiyun.com/jliang3/article/details/88368665

作者：jliang

https://blog.youkuaiyun.com/jliang3

说明：以下所有代码使用版本TensorFlow1.4.0或1.12.0版本

import tensorflow as tf
print(tf.__version__)

1.12.0

10.TensorFlow高层封装

TensorFlow的高层封装有很多

10.1 TensorFlow高层封装总览

TensorFlow高层封装主要有4个：

TensorFlow-Slim
TFLearn
Keras
Estimator。

TensorFlow-Slim

TensorFlow-Slim是Google官方给出的相对较早的TensorFlow高层封装
Google通过TensorFlow-Slim开源了一些已经训练好的图像分析的模型，所以目前在图像识别问题中TensorFlow-Slim扔被较多地使用。
TensorFlow-Slim最特别的一个地方是它对一些标准的神经网络进行了封装，比如VGG、Inception以及ResNet，而且google开源的训练好的图像分析模型基本是通过TensorFlow-Slim实现的。

TensorFlow-Slim实现LeNet-5网络

import tensorflow as tf
import tensorflow.contrib.slim as slim
import numpy as np

from tensorflow.examples.tutorials.mnist import input_data

# 通过TensorFlow-Slim定义LeNet-5网络结构
def lenet5(inputs):
    # 将输入数据转化为一个4维数组，其中第一维表示batch大小，另外三维表示一张图片
    inputs = tf.reshape(inputs, [-1, 28, 28, 1])
    
    # 定义第一层卷积层，深度为32，过滤器大小为5*5，使用全0填充
    net = slim.conv2d(inputs, 32, [5,5], padding='SAME', scope='layer1-conv')
    # 定义一个最大池化层，其过滤器大小为2*2，步长为2
    net = slim.max_pool2d(net, 2, stride=2, scope='layer2-max-pool')
    
    net = slim.conv2d(net, 64, [5,5], padding='SAME', scope='layer3-conv')
    net = slim.max_pool2d(net, 2, stride=2, scope='layer4-max-pool')
    
    # 使用flatten()将4维矩阵转为2维，这样可以方便后面的全连接层计算。
    # 通过封装好的函数，用户不再需要自己计算通过卷积层之后的矩阵的大小。
    net = slim.flatten(net, scope='flatten')
    
    # 定义全连接层，该全连接层有500个隐藏节点
    net = slim.fully_connected(net, 500, scope='layer5')
    net = slim.fully_connected(net, 10, scope='output')
    return net

# 通过TensorFlow-Slim定义网络结构，并使用之前章节中给出的方式训练定义好的模型。
def train(mnist):
    x = tf.placeholder(tf.float32, [None, 784], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, 10], name='y-input')
    
    y = lenet5(x)
    
    # 定义损失函数和训练方法
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=y, labels=tf.argmax(y_, 1))
    loss=tf.reduce_mean(cross_entropy)
    train_op = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
    
    # 训练过程
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        for i in range(10000):
            xs, ys = mnist.train.next_batch(100)
            _, loss_value = sess.run([train_op, loss], feed_dict={x: xs, y_:ys})
            
            if i % 1000 == 0:
                print('After {} training step(s), loss on training batch is {}'.format(
                i, loss_value))
                
def main(argv=None):
    mnist=input_data.read_data_sets('MNIST_data', one_hot=True)
    train(mnist)
    
main()

Please use tf.one_hot on tensors.
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
WARNING:tensorflow:From /Users/jliang/anaconda3/envs/py36/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.
Instructions for updating:
Please use alternatives such as official/mnist/dataset.py from tensorflow/models.
After 0 training step(s), loss on training batch is 2.3039710521698
After 1000 training step(s), loss on training batch is 0.7978101372718811
...
After 8000 training step(s), loss on training batch is 0.295499712228775
After 9000 training step(s), loss on training batch is 0.24138087034225464

TFLearn

TFLearn是一个更加简洁的TensorFlow高层封装，可以更加容易地完成模型定义、模型训练以及模型评测的过程。
TFLearn没有集成在TensorFlow的安装包中，需要单独安装：pip install tflearn
与原生TensorFlow不同的地方在于，TFLearn不仅使神经网络定义更加简洁，还将模型训练的过程也进行了封装。
在定义神经网络的前向传播过程之后，TFLearn可以通过regression函数来指定损失函数和优化方法。
更方便的是，不仅TFLearn能很好地封装模型定义，tflearn.DNN也能很好地封装模型训练的过程，使用fit函数可以指定训练中使用的数据和训练轮数。
TFLearn官网：http://tflearn.org/

TFLearn实现LeNet-5模型

import tflearn

from tflearn.layers.core import input_data, fully_connected
from tflearn.layers.conv import conv_2d, max_pool_2d
from tflearn.layers.estimator import regression

import tflearn.datasets.mnist as mnist

# 读取MNIST数据
trainX, trainY, testX, testY = mnist.load_data(data_dir='MNIST_data', one_hot=True)

# 将图像数据reshape成卷积神经网络输出的格式
trainX = trainX.reshape([-1, 28, 28, 1])
testX = testX.reshape([-1, 28, 28, 1])

# 构建神经网络，这个过程和TensorFlow-Slim比较类似
net = input_data(shape=[None, 28, 28, 1], name='input')

# 通过TFLearn封装好的API定义一个深度为5，过滤器为5*5，激活函数为ReLU的卷积层
net = conv_2d(net, 32, 5, activation='relu')
# 定义一个2*2的最大池化层
net = max_pool_2d(net, 2)

net = conv_2d(net, 64, 5, activation='relu')
net = max_pool_2d(net, 2)
net = fully_connected(net, 500, activation='relu')
net = fully_connected(net, 10, activation='softmax')

# 使用TFLearn封装好的函数定义学习任务。指定优化器有sgd，学习率为0.01，损失函数为交叉熵
net = regression(net, optimizer='sgd', learning_rate=0.01, 
                 loss='categorical_crossentropy')

# 通过定义的网络结构训练模型，并在指定的验证集数据上验证模型效果。
model = tflearn.DNN(net, tensorboard_verbose=0)

model.fit(trainX, trainY, n_epoch=20, validation_set=([testX, testY]), 
         show_metric=True)

Training Step: 17199  | total loss: [1m[32m0.41563[0m[0m | time: 95.406s
| SGD | epoch: 020 | loss: 0.41563 - acc: 0.9683 -- iter: 54976/55000
Training Step: 17200  | total loss: [1m[32m0.37548[0m[0m | time: 101.037s
| SGD | epoch: 020 | loss: 0.37548 - acc: 0.9715 | val_loss: 0.02762 - val_acc: 0.9901 -- iter: 55000/55000
--

10.2 Keras介绍

Keras是目前使用最为广泛的深度学习工具之一，它的底层可以支持TensorFlow、MXNet、CNTK和Theano。
如今，Keras更是被直接引入了TensorFlow的核心代码库，称为TensorFlow官方提供的高层封装之一。
与TFLearn类似，Keras API也对模型定义、损失函数、训练过程等进行了封装，整个训练过程和TFLearn基本一致，可分为数据处理、模型定义和模型训练三部分。
使用原生keras API需要先安装：pip install keras

Keras实现LeNet-5网络

先定义一个Sequential类，然后再Sequential实例中通过add函数添加网络层。
Keras把卷积层、池化层、RNN结构（LSTM、GRU）、全连接层等常用的神经网络结构都做了封装，可以很方便地实现深层神经网络。
在网络结构定义好后，Sequential实例可以通过compile函数指定优化函数、损失函数以及训练过程中需要监控的指标。
Keras对优化函数、损失函数以及监控指标都有封装，同时也支持使用自定义的方式。

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from keras import backend as K

num_classes = 10
img_rows, img_cols = 28, 28

# 通过keras加载MNIST数据，其中trainX就是一个60000*28*28的数组，trainY是每张图片对应的数字
(trainX, trainY), (testX, testY) = mnist.load_data()

# 因为不同的底层（TensorFlow或MXNet）对输入的要求不一样，所以这里需要根据对图像
# 编码的格式要求来设置输入层的格式。
if K.image_data_format() == 'channels_first':
    trainX = trainX.reshape(trainX.shape[0], 1, img_rows, img_cols)
    testX = testX.reshape(testX.shape[0], 1, img_rows, img_cols)
    
    # 因为MNIST中图片时黑白的，所以第一维取值为1
    input_shape = (1, img_rows, img_cols)
else:
    trainX = trainX.reshape(trainX.shape[0], img_rows, img_cols, 1)
    testX = testX.reshape(testX.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)
    
# 将图像像素转化为0到1之间的实数
trainX = trainX.astype('float32')
testX = testX.astype('float32')
trainX /= 255.0
testX /= 255.0

# 将标准答案转化为需要的格式（one-hot编码）
trainY = keras.utils.to_categorical(trainY, num_classes)
testY = keras.utils.to_categorical(testY, num_classes)

# 使用Keras定义模型
model = Sequential()
# 一层深度为32，