使用TensorFlow实现DNN

这一节使用TF实现一个多层神经网络模型来对MNIST数据集进行分类,这里我们设计一个含有两个隐藏层的神经网络,在输出部分使用softmax对结果进行预测。

使用高级API实现多层神经网络

这里我们使用tensorflow.contrib包,这是一个高度封装的包,里面包含了许多类似seq2seq、keras一些实用的方法。
先引入数据

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./") #自动下载数据到这个目录
X_train = mnist.train.images
X_test = mnist.test.images
y_train = mnist.train.labels.astype("int")
y_test = mnist.test.labels.astype("int")
>>X_train
array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       ..., 
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.]], dtype=float32)
>>len(X_train)
55000
>>len(X_train[0])
784
>>X_train[0]
array([ 0.,  0.,  0., ...,  0.,  0.,  0.], dtype=float32)
>>y_test
array([7, 2, 1, ..., 4, 5, 6])

模型的主要代码

features_cols = tf.contrib.learn.infer_real_valued_columns_from_input(X_train)
dnn_clf = tf.contrib.learn.DNNClassifier(hidden_units=[300,100], n_classes=10, feature_columns=features_cols)
dnn_clf.fit(X_train, y_train, batch_size=50, steps=10000)
from sklearn.metrics import accuracy_score
y_pred = dnn_clf.predict(X_test)
print(accuracy_score(y_test, list(y_pred)))

其中infer_real_valued_columns_from_input这个方法根据名字可以看出,它是根据输入的数据来推算出数据的类型,该例子中features_cols的值为
[_RealValuedColumn(column_name='', dimension=784, default_value=None, dtype=tf.float32, normalizer=None)],短短几行代码就实现了一个多层神经网络模型。并且可能会发现上面这些与之前介绍的有些不同,不需要对变量进行初始化,不需要创建session,使用起来十分的简单。

使用TF实现多层神经网络

高度封装的API调用起来固然很爽,但是自己不了解内部的原理使用起来就不是那么的踏实,下面就使用TF实现同样的模型,代码主要分为两部分,构建TF计算流图和执行计算图。希望读者能够对比上面的代码来看接下来的部分。

构建TF计算流图

首先我们需要根据输入的数据来设定输入的参数,使用的数据集MNIST为28*28的矩阵,整个神经网络包含两个隐藏层

n_inputs = 28 * 28
n_hidden1 = 300
n_hidden2 = 100
n_output = 10
X = tf.placeholder(tf.float32,shape=(None,n_inputs),name='X')
y = tf.placeholder(tf.int64,shape=(None),name='y')#注意数据类型

上面使用占位符的方法来声明模型的输入X和y,需要注意的是占位符的数据类型,在执行阶段,占位符会被输入的数据所替代。接下来我们需要创建模型的两个隐藏层和输出层,两个隐藏使用Relu作为激活函数,输出层使用softmax。每一层需要指定节点的个数。

def neuron_layer(X,n_neurons,name,activation=None):
    with tf.name_scope(name):
        n_inputs = int(X.get_shape()[1]) #特征个数
        stddev = 2 / np.sqrt(n_inputs)
        init = tf.truncated_normal((n_inputs,n_neurons),stddev=stddev)
        W = tf.Variable(init,name='weight')
        b = tf.Variable(tf.zeros([n_neurons]),name='baise')
        z = tf.matmul(X,W) + b
        if activation == "relu":
            return tf.nn.relu(z)
        else:
            return z

我将逐行的对上面代码进行解释:

  • 1.为了方便在TensorBoard上面查看,每一层的神经网络都创建一个name_scope。这一步是可选操作,如果不需要在TensorBoard查看那就可以忽略掉。
  • 2.根据输入的数据的形状来获取数据的特征个数(第二个维度)
  • 3.接下来的代码是创建权重矩阵W和偏置b,权重W不能使用0进行初始化,这样会导致所有的神经元的输出为0,出现对称失效问题,这里使用truncated normal分布(Gaussian)来初始化权重,

    tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
    通过指定均值和标准方差来生成正态分布,抛弃那些大于2倍stddev的值。这样将有助于加快训练速度。在初始化b的时候,每一层只有一个偏置,我们全部设置为0,这样并不会出现对称失效问题。
  • 4.下面的是在每一个神经元中的操作y=XW+b  y=X·W+b ,使用向量化运算计算输入与权重的和运算
  • 5.最后就是激活函数的选择了

下面我们就开始像搭建积木一样创建我们的神经网络了,每一层的输入为上一层的输出:

with tf.name_scope("dnn"):
    hidden1 = neuron_layer(X,n_hidden1,"hidden1",activation="relu")
    hidden2 = neuron_layer(hidden1,n_hidden2,"hidden2",activation="relu")
    logits = neuron_layer(hidden2,n_output,"output")

上面这一段代码的输出层并没有经过softmax激活函数,这是考虑到后续优化求解原因,在后续工作中单独做处理。上面这段代码就是一个神经网络全连接的简化版本,当然TF的contrib模块也提供了全连接的函数fully_connected

from tensorflow.contrib.layers import fully_connected
with tf.name_scope("dnn"):
    hidden1 = fully_connected(X, n_hidden1, scope="hidden1")#激活函数默认为relu
    hidden2 = fully_connected(hidden1, n_hidden2, scope="hidden2")
    logits = fully_connected(hidden2, n_outputs, scope="outputs",activation_fn=None)

现在,模型已经有了。接下来套路就是设计损失函数,优化损失函数求解参数。输出层softmax输出的为在各个类别上面的得分,损失函数使用交叉熵
y  log(y  ) −∑y′log(y′) 。在这里我们使用TF提供的tf.nn.sparse_softmax_cross_entropy_with_logits(_sentinel=None, labels=None, logits=None, name=None)来计算损失函数,该方法先计算softmax再计算cross entropy,主要有两个参数需要考虑

  • 1.labels:输入的为标签的index,例如本例子有10个类别,取值范围为0-9
  • 2.logits:为输入到softmax激活函数之前的模型的输出

最后再使用reduce_mean()计算loss。

with tf.name_scope("loss"):
    xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y,logits=logits)#labels允许的数据类型有int32, int64
    loss = tf.reduce_mean(xentropy,name="loss")

note:TF还提供了softmax_cross_entropy_with_logits(),和上面方法的区别该方法输入的label为一个one-hot向量。
到这里我们的模型损失函数已经都有了,就到了优化阶段,本文使用梯度下降方法

learning_rate = 0.01
with tf.name_scope("train"):
    optimizer = tf.train.GradientDescentOptimizer(learning_rate)
    training_op = optimizer.minimize(loss)

模型有了结果,就需要对得到的模型进行衡量。简单起见,这里使用accuracy作为评估指标,判断模型输出结果的最高值的index是否和label的index相等

with tf.name_scope("eval"):
    correct = tf.nn.in_top_k(logits,y,1) #取值最高的一位
    accuracy = tf.reduce_mean(tf.cast(correct,tf.float32)) #结果boolean转为0,1

模型构建阶段最后一个工作就是初始化里面的变量

init = tf.global_variables_initializer()
saver = tf.train.Saver()

执行计算流图

这一部分相对前面工作要简单很多,

n_epoch = 400 
batch_size = 50
with tf.Session() as sess:
    init.run()
    for epoch in range(n_epoch):
        for iteration in range(mnist.train.num_examples // batch_size):#需要迭代的轮数
            X_batch,y_batch = mnist.train.next_batch(batch_size)
            sess.run(training_op,feed_dict={X:X_batch,y:y_batch})
        acc_train = accuracy.eval(feed_dict={X:X_batch,y:y_batch})
        acc_test = accuracy.eval(feed_dict={X:mnist.test.images,mnist.test.labels})
        print (epoch,"Train accuracy", acc_train,"Test accuracy",acc_test)
    saver.save(sess, "./my_model.pk")

上面这段代码使用的是mini-batch方法训练神经网络,最后将模型持久化到本地。后续的使用

with tf.Session() as sess:
    saver.restore(sess, "./my_model.pk") #加载
    X_new_scaled = mnist.test.images[:20]
    Z = logits.eval(feed_dict={X: X_new_scaled}) #模型
    y_pred = np.argmax(Z, axis=1)

总结

本文介绍了TF在实际数据集MNIST上面的使用,为input和target创建占位符,创建神经网络的layer,得到一个DNN,并为整个模型设置损失函数,对损失函数进行优化求解,最后对模型进行评估。

相关推荐