来源商业新知网，原标题：代码详解：TensorFlow Core带你探索深度神经网络“黑匣子”
想学TensorFlow？先从低阶API开始吧~某种程度而言，它能够帮助我们更好地理解Tensorflow，更加灵活地控制训练过程。本文演示了如何使用低阶TensorFlow Core 搭建卷积神经网络（ConvNet）模型，并演示了使用TensorFlow编写自定义代码的方法。
对很多开发人员来说，神经网络就像一个“黑匣子”， 而TensorFlow Core的应用，则将我们带上了对深度神经网络后台“黑幕”的探索进程。
本文将MNIST手写数字数据集加载到数据迭代器，使用图和会话，搭建新的卷积神经网络体系结构，使用不同选项训练模型，作出预测，保存训练模型。同时，也会提供完整的代码以及Keras中的等效模型，以便使用Keras的用户进行直接比较，加深了解，同时高阶API在搭建神经网络方面的强大功能也能得到展示。
MNIST数据集
MNIST是一组28x28大小的手写数字的灰度图像，其中训练集有60000张图像，测试集有10000张图像。
首先，加载并处理MNIST图像。
预计训练模型输入形状为[batch_size, height, width, channels]（[批量大小，高度，宽度，通道]）。由于灰度图是单通道图像，它们的形状为 [60000,28,28]，因此需要添加通道维度，使得形状为 [60000,28,28,1]。而且图像的数据类型是uint8（像素值范围为0-255），因此需要将其除以255，才能缩放到0-1之间的范围。这样第一张图像就可显示为一个样例。
attn_layer = AttentionLayer(name='attention_layer')([encoder_out,decoder_out])
import tensorflow as tf
import numpy as np
mnist = tf.keras.datasets.mnist
(train_images, train_labels),(test_images, test_labels) = mnist.load_data()
# Normalize and reshape images to [28,28,1]
train_images = np.expand_dims(train_images.astype(np.float32) / 255.0, axis=3)
test_images = np.expand_dims(test_images.astype(np.float32) / 255.0, axis=3)
# View a sample image
import matplotlib.pyplot as plt
plt.figure(dpi=100)
plt.imshow(np.squeeze(train_images[0]), cmap='gray')
plt.title('Number: {}'.format(train_labels[0]))
plt.show()
由于标签是整数值（例如0、1、2），即分类值，需要转换成one-hot编码（例如[1,0,0], [0,1,0], [0,0,1]）用于训练。将Keras的to_categorical编码器转换标签，也可以选择用Scikit-learn的OneHotEncoder 编码器。
如下所示，测试集标签不用转化成one-hot编码。
from keras.utils import to_categorical
train_labels = to_categorical(train_labels)
图和会话
用TensorFlow创建模型分为两个步骤：创建一个图；在会话中执行图。
图概述了计算数据流。这种数据流图决定在张量（多维数据阵列）上执行操作的时间和方式。图形可以在会话内部或外部创建，但只能在会话内部使用。只有在会话中才能初始化张量，执行操作，训练模型。
数据迭代器
为了演示数据流图和会话，创建数据集迭代器。由于MNIST图像和真值标签是Numpy数组的切片，因此可以通过将数组传递到tf.data.dataset.from_tensor_slices方法中来创建数据集。然后为数据集创建迭代器。我们希望它在每次运行时返回一个 batch_size（批量大小）图像数量和标签数量，如果不确定训练次数，则返回重复。
batch_size = 128
dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels))
iterator = dataset.repeat().batch(batch_size).make_initializable_iterator()
data_batch = iterator.get_next(
现在我们定义了一个数据流图，为了获得一批新图像和新标签，我们在会话中运行data_batch。
但是还未完成。虽然数据流图创建好了，但图像还没有被完全传递进来。为此，迭代器需要在会话中初始化。
sess = tf.Session()
sess.run(iterator.initializer)
现在有一个会话正在运行，只需运行data_batch就可以检索第一批图像。图像的形状为[batch_size, height, width, channels]，标签的形状为[batch_size, classes]。可以通过以下方式检查：
batch_images, batch_labels = sess.run(data_batch)
print('Images shape: {}'.format(batch_images.shape))
print('Labels shape: {}'.format(batch_labels.shape)
Images shape: (128, 28, 28, 1)
Labels shape: (128, 10)
通过两次运行data_batch来显示前两批中的第一个图像。
# Get the first batch of images and display first image
batch_images, batch_labels = sess.run(data_batch)
plt.subplot(1, 2, 1)
plt.imshow(np.squeeze(batch_images)[0], cmap='gray')
# Get a second batch of images and display first image
batch_images, batch_labels = sess.run(data_batch)
plt.subplot(1, 2, 2)
plt.imshow(np.squeeze(batch_images)[0], cmap='gray')
plt.show()
在第一批中，第一个图像是5。 在第二批中，第一个图像是1。
然后可以通过sess.close()关闭会话。 但是，请记住，当会话关闭时，信息将丢失。 例如，如 果如下图所示关闭并重新启动会话，那么数据迭代器将从头开始启动。（注意，迭代器需要在每个会话中初始化。）
# New session
sess = tf.Session()
sess.run(iterator.initializer)
# Get the first batch of images and display first image
batch_images, batch_labels = sess.run(data_batch)
plt.subplot(1, 2, 1)
plt.imshow(np.squeeze(batch_images)[0], cmap='gray')
# Close and restart session
sess.close()
sess = tf.Session()
sess.run(iterator.initializer)
# Get a second batch of images and display first image
batch_images, batch_labels = sess.run(data_batch)
plt.subplot(1, 2, 2)
plt.imshow(np.squeeze(batch_images)[0], cmap='gray')
plt.show()
因为会话已关闭，并且创建了新会话，所以数据迭代器开始重新启动，并再次显示相同的图像。
使用with语句
会话也可以通过“with”语句启动和自动关闭。在“with”块的末尾，会话将按指示关闭。
with tf.Session() as sess:
sess.run(iterator.initializer)
for _ in range(2):
batch_images, batch_labels = sess.run(data_batch)
img = np.squeeze(batch_images)[0]
plt.imshow(img, cmap='gray')
plt.show()
# sess is closed
卷积神经网络模型
下面将演示如何使用TensorFlow构建下图所示的基本卷积神经网络模型：
该体系结构有四个卷积层。前两层有16个过滤器，后两层有32个过滤器，所有过滤器的尺寸为3x3。四个卷积层中都添加了偏差和relu激活函数。最后两层是完全连接（密集）的层。
权值和偏差
卷积神经网络中的初始权重需要对称破缺的随机值，以便网络能够学习。xavier_initializer设定项“旨在保持所有层中梯度比例大致相同”，通常用于初始化模型的权重。通过使用带有tf.get_variable的初始值设定项来创建层的权重。每个卷积层都有形状为[filter_height, filter_width, in_channels, out_channels]的滤波器。由于致密层是完全连接的，并且没有3x3大小的滤波器，因此它们的形状为[in_channels, out_channels]。同时，还创建了偏差，每个偏差的大小与相应层的out_channels 的大小相同，并用零初始化。
创建weights（权值）和biases（参数） 字典，以便组织和简化。
weights = {
# Convolution Layers
'c1': tf.get_variable('W1', shape=(3,3,1,16),
initializer=tf.contrib.layers.xavier_initializer()),
'c2': tf.get_variable('W2', shape=(3,3,16,16),
initializer=tf.contrib.layers.xavier_initializer()),
'c3': tf.get_variable('W3', shape=(3,3,16,32),
initializer=tf.contrib.layers.xavier_initializer()),
'c4': tf.get_variable('W4', shape=(3,3,32,32),
initializer=tf.contrib.layers.xavier_initializer()),
# Dense Layers
'd1': tf.get_variable('W5', shape=(7*7*32,128),
initializer=tf.contrib.layers.xavier_initializer()),
'out': tf.get_variable('W6', shape=(128,n_classes),
initializer=tf.contrib.layers.xavier_initializer()),
}
biases = {
# Convolution Layers
'c1': tf.get_variable('B1', shape=(16), initializer=tf.zeros_initializer()),
'c2': tf.get_variable('B2', shape=(16), initializer=tf.zeros_initializer()),
'c3': tf.get_variable('B3', shape=(32), initializer=tf.zeros_initializer()),
'c4': tf.get_variable('B4', shape=(32), initializer=tf.zeros_initializer()),
# Dense Layers
'd1': tf.get_variable('B5', shape=(128), initializer=tf.zeros_initializer()),
'out': tf.get_variable('B6', shape=(n_classes), initializer=tf.zeros_initializer()),
}
因为MNIST图像是灰度的，所以第一层的in_channels为1。输出层需要将out_channels 设为10，因为有10个类。其他层中的滤波器数量可以根据性能或速度进行调整，但是in_channels中的每一个滤波器都需要与前一层的out_channels 相同。在下面创建卷积神经网络时，将解释第一个致密层采用7*7*32大小的原因。
卷积层
TensorFlow有一个tf.nn.conv2d函数，可用于将张量与权重卷积。为了简化卷积层，创建一个函数，它接受输入数据x 并应用一个具有权重W的二维卷积，添加一个偏差b，使用relu函数激活。
#Define 2D convolutional function
def conv2d(x, W, b, strides=1):
x = tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x )
模型图
另一个函数可用于绘制模型图。这将把MNIST图像作为data（数据），并使用不同层中的权重和偏差。
如体系结构所示，在第二层和第四层卷积层之后，层的高度和宽度都会减小。池化操作将滑动一个窗口，只使用区域内的单个最大值。通过使用2x2窗口（ksize=[1,2,2,1]）和跨距2（strides=[1,2,2,1]），尺寸将减少一半。这有助于减少模型大小，同时保留最重要的功能。对于输入的奇数尺寸，输出形状由除以2后的上限确定（例如7/2=4）。
在第四卷积层之后，张量需要在完全连接层之前进行整形，使其变平。完全连接层的权重不是用于二维卷积，而是仅用于矩阵乘法，因此不使用conv2d 函数。
在最后两层之间添加一个脱落层样本，帮助减少过度拟合，其中权值下降的概率为0.2。脱落层只能在训练期间使用，因此如果模型用于预测，则应包含training 标记以绕过该层。如果在预测过程中包含了脱落层，那么模型的输出将不一致，并且由于随机下降的权重而具有较低的准确性。
def conv_net(data, weights, biases, training=False):
# Convolution layers
conv1 = conv2d(data, weights['c1'], biases['c1']) # [28,28,16]
conv2 = conv2d(conv1, weights['c2'], biases['c2']) # [28,28,16]
pool1 = tf.nn.max_pool(conv2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
# [14,14,16]
conv3 = conv2d(pool1, weights['c3'], biases['c3']) # [14,14,32]
conv4 = conv2d(conv3, weights['c4'], biases['c4']) # [14,14,32]
pool2 = tf.nn.max_pool(conv4, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
# [7,7,32]
# Flatten
flat = tf.reshape(pool2, [-1, weights['d1'].get_shape().as_list()[0]])
# [7*7*32] = [1568]
# Fully connected layer
fc1 = tf.add(tf.matmul(flat, weights['d1']), biases['d1']) # [128]
fc1 = tf.nn.relu(fc1) # [128]
# Dropout
if training:
fc1 = tf.nn.dropout(fc1, rate=0.2)
# Output
out = tf.add(tf.matmul(fc1, weights['out']), biases['out']) # [10]
return out
不同层的形状在代码注释中给出。从28x28图像开始，两个最大池层将大小缩小了两倍，因此其宽度和高度减小到（28/2）/2=7大小。在用于密集层之前，需要对权重进行扁平化和重塑。由于在第四个卷积层中有32个滤波器，因此扁平层的第一个形状尺寸为7x7x32（这就是为什么使用它来获得weights['d1']的形状）。
构建卷积神经网络图
接下来构建用于模型训练的数据流图。
一个重要的概念是使用占位符，因此首先使用它们创建卷积神经网络。不过，还会展示如何在没有占位符的情况下制作模型。
占位符
我们需要确定如何将来自数据迭代器的数据输入到模型图中。为此，可以制作一个占位符，指示将一些形状为[batch_size, height, width, channels] 的张量输入conv_net函数。将height （高度）和width （宽度）设置为28，将channels （通道）设置为1，并通过将其设置为None（无），将批次大小保留为变量。
现在可以使用带有weights （权重）和biases （偏差）字典的Xtrain 占位符作为conv_net函数的输入来获取logits输出。
Xtrain = tf.placeholder(tf.float32, shape=(None, 28, 28, 1))
logits = conv_net(Xtrain, weights, biases）
此步骤将允许我们通过将一个或多个图像输入Xtrain 占位符来训练模型。
损失
该模型基于一组10个互斥类对图像进行分类。在训练过程中，通过使用softmax将logits转换为图像属于每个类的相对概率，然后通过softmax的交叉熵计算损失。
这些都可以用TensorFlow的softmax交叉熵一步完成。测量一批图像的损失，可以使用tf.reduce_mean 获取批处理的平均损失。
我们可以再次为图使用ytrain占位符，该图将用于提供MNIST标签。回想一下标签经过了one-hot编码，批处理中的每个图像都有一个标签，所以形状应该是[batch_size, n_classes]。
ytrain = tf.placeholder(tf.float32, shape=(None, n_classes))
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,
labels=ytrain))
优化器
该损失用于通过网络对损失进行反向传播来更新模型权重和偏差。学习率用于缩小更新，从而防止权重在优化值周围分散或跳跃。
Adam优化器是由具有动量的Adagrad和RMSProp结合而成，并已证明可以与卷积神经网络一起良好运行。这里我使用学习率为1e-4的Adam优化器。然后计算梯度，并通过运行最小化方法更新权重。
optimizer = tf.train.AdamOptimizer(1e-4)
train_op = optimizer.minimize(loss)
现在train_op是训练模型的关键，因为它能运行optimizer.minimize。为了训练模型，只需将图像输入到图中，然后运行train_op 即可根据损失更新权重。
训练模型
准确性
使用测试图像来测量训练期间的准确性。对于每个图像，执行模型推理，并使用具有最大logit值的类作为预测。准确性就是正确预测的分数。我们需要使用整数值而不是one-hot编码来比较预测与标签，因此需要使用argmax（这就是test_labels未转换为one-hot编码的原因，否则必须将其转换回标签）。
准确性可使用TensorFlow的准确性运算符测量，该运算符有两个输出。第一个输出是不更新度量的准确性，第二个输出是我们将使用的输出，它用更新度量返回准确性。
test_predictions = tf.nn.softmax(conv_net(test_images, weights, biases))
acc,acc_op = tf.metrics.accuracy(predictions=tf.argmax(test_predictions,1),
labels=tests_labels )
初始化变量
需要初始化局部变量（临时变量，如准确性中的total 和count 度量）和全局变量（如模型权重和偏差），以便在会话中使用。
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
输入图像
回想一下，对于每一批，都会创建一组需要输入到占位符Xtrain 和ytrain中新的图像和真值。如上图所示，可以从data_batch（数据批次）中获得batch_images （批次图像）和batch_labels （批次标签）。然后，通过创建一个以占位符为键，数据为值的字典，将它们输入占位符，然后在sess.run()中运行train_op 时将字典传递到feed_dict 参数。
batch_images, batch_labels = sess.run(data_batch)
feed_dict = {Xtrain: batch_images, ytrain: batch_labels}
sess.run(train_op, feed_dict=feed_dict)
训练会话
通过在会话中调用 train_op，图中的所有步骤都将按上述方式运行。我们将使用tqdm 查看每次训练期间训练的进程。在每次训练之后，测量并打印出准确性。
from tqdm import tqdm
nepochs = 5
sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
sess.run(iterator.initializer)
for epoch in range(nepochs):
for step in tqdm(range(int(len(train_images)/batch_size))):
# Batched data
batch_images, batch_labels = sess.run(data_batch)
# Train model
feed_dict = {Xtrain: batch_images, ytrain: batch_labels}
sess.run(train_op, feed_dict=feed_dict)
# Test model
accuracy = sess.run(acc_op)
print('nEpoch {} Accuracy: {}'.format(epoch+1, accuracy))
该模型将继续用给定的训练次数进行训练。经过5次训练，该模型的准确性约为0.97。
无占位符训练
上面的样例演示了在图像中输入的占位符，但是可以将conv_net和batch_labels 中的batch_images直接使用在tf.nn.softmax_cross_entropy_with_logits_v2的labels 参数中，使该图更加简洁。然后可以训练模型，便不必向图中输入任何张量，如下所示：
batch_images, batch_labels = iterator.get_next()
logits = conv_net(batch_images, weights, biases, training=True)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,
labels=batch_labels))
train_op = optimizer.minimize(loss)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
sess.run(iterator.initializer)
for epoch in range(nepochs):
for step in tqdm(range(int(len(train_images)/batch_size)))
sess.run(train_op)
accuracy = sess.run(acc_op)
print('nEpoch {} Accuracy: {}'.format(epoch+1, accuracy))
访问其它节点
可以通过在会话中单独或在列表中调用图中的不同节点来访问它们。如果运行节点列表，则会给出输出列表。例如，假设希望在训练期间看到每个图像批的损失，这可以通过在会话中运行train_op列表中的loss来完成。在这里，将使用tqdm打印每次训练期间每个批次的损失。
for epoch in range(nepochs):
prog_bar = tqdm(range(int(len(train_images)/batch_size)))
for step in prog_bar:
_,cost = sess.run([train_op,loss])
prog_bar.set_description("cost: {}".format(cost))
accuracy = sess.run(acc_op)
print('nEpoch {} Accuracy: {}'.format(epoch+1, accuracy ))
预测
测试预测
使用测试准确性中的test_predictions （测试_预测）来对性能进行可视化，这些性能用于对样例图像进行分类。在这里，显示前25个测试图像，并使用整数预测作为标题。
onehot_predictions = sess.run(test_predictions)
predictions = np.argmax(np.squeeze(onehot_predictions), axis=1)
f, axarr = plt.subplots(5, 5, figsize=(25,25))
for idx in range(25):
axarr[int(idx/5), idx%5].imshow(np.squeeze(test_images[idx]), cmap='gray')
axarr[int(idx/5), idx%5].set_title(str(predictions[idx]),fontsize=50 )
预测新图像批次
如果要预测一组新图像，只需在会话中对一批图像运行 conv_net函数即可进行预测。例如，以下内容可用于获取测试集中前25个图像的预测：
predictions = sess.run(tf.argmax(conv_net(test_images[:25], weights, biases), axis=1))
然后可以像上面一样将predictions （预测）用于显示图像。
预测单一图像
回想一下，模型期望输入具有形状[batch_size, height, width, channels]。这意味着，如果对单个图像进行预测，则需要扩展图像的维度，使第一个维度（batch_size）成为一个单一维度。这里预测了测试集中的第1000个图像。
img = test_images[1000]
print(img.shape) # [28, 28, 1]
img = np.expand_dims(img, 0)
print(img.shape) # [1, 28, 28, 1]
prediction = sess.run(tf.argmax(conv_net(img, weights, biases), axis=1))
plt.imshow(np.squeeze(img), cmap='gray')
plt.title(np.squeeze(prediction), fontsize=40)
预测概率
预测的归一化概率分布可以使用softmax,按conv_net 模型中的logits来计算。
idx = 1000
img = np.expand_dims(test_images[idx], 0)
plt.imshow(np.squeeze(img), cmap='gray')
# Predict value
prediction = conv_net(img, weights, biases)
probabilities = tf.nn.softmax(prediction)
probs = sess.run(probabilities)
probs = np.squeeze(probs)
# Plot probabilities
plt.figure(dpi=150)
plt.bar(range(10), probs)
for i in range(10):
plt.text(i-0.3, probs[i]+0.05, s='{:.2f}'.format(probs[i]), size=10)
plt.ylim([0,1.1])
plt.xticks(range(10))
plt.ylabel('Probability')
plt.xlabel('Predicted Number')
该模型预测该数字为9的概率很高。
有些数字对模型来说并不是那么容易预测。例如，这里是测试集中的另一个图像（idx=3062）。
虽然模型的确预测8是最有可能的类，但它的概率只有0.48，而且其它几个数字的概率增加了。
以下是一个错误的预测样例(idx=259)：
该模型错误地预测了0，而数字6只是可能性为第二的预测。
保存模型
如前所述，只要会话仍然打开，就可以进行预测。如果会话关闭，经过训练的权重和偏差将丢失。使用tf.train.Saver可以将会话和模型图以及经过训练的权重和偏差保存为检查点。
saver = tf.train.Saver()
saver.save(sess, './model.ckpt')
完整的代码样例
结合上面的信息，下面是一个脚本样例，用于创建、训练和保存卷积神经网络并显示对手写数字样本的预测。
import tensorflow as tf
import numpy as np
from tqdm import tqdm
from keras.datasets import mnist
from keras.utils import to_categorical
import matplotlib.pyplot as plt
# MNIST Dataset
(train_images, train_labels),(test_images, test_labels) = mnist.load_data()
train_images = np.expand_dims(train_images.astype(np.float32) / 255.0, axis=3)
test_images = np.expand_dims(test_images.astype(np.float32) / 255.0, axis=3)
train_labels = to_categorical(train_labels)
# Training parameters
batch_size = 128
n_epochs = 5
n_classes = 10
learning_rate = 1e-4
# 2D Convolutional Function
def conv2d(x, W, b, strides=1):
x = tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x)
# Define Weights and Biases
weights = {
# Convolution Layers
'c1': tf.get_variable('W1', shape=(3,3,1,16),
initializer=tf.contrib.layers.xavier_initializer()),
'c2': tf.get_variable('W2', shape=(3,3,16,16),
initializer=tf.contrib.layers.xavier_initializer()),
'c3': tf.get_variable('W3', shape=(3,3,16,32),
initializer=tf.contrib.layers.xavier_initializer()),
'c4': tf.get_variable('W4', shape=(3,3,32,32),
initializer=tf.contrib.layers.xavier_initializer()),
# Dense Layers
'd1': tf.get_variable('W5', shape=(7*7*32,128),
initializer=tf.contrib.layers.xavier_initializer()),
'out': tf.get_variable('W6', shape=(128,n_classes),
initializer=tf.contrib.layers.xavier_initializer()),
}
biases = {
# Convolution Layers
'c1': tf.get_variable('B1', shape=(16), initializer=tf.zeros_initializer()),
'c2': tf.get_variable('B2', shape=(16), initializer=tf.zeros_initializer()),
'c3': tf.get_variable('B3', shape=(32), initializer=tf.zeros_initializer()),
'c4': tf.get_variable('B4', shape=(32), initializer=tf.zeros_initializer()),
# Dense Layers
'd1': tf.get_variable('B5', shape=(128), initializer=tf.zeros_initializer()),
'out': tf.get_variable('B6', shape=(n_classes), initializer=tf.zeros_initializer()),
}
# Model Function
def conv_net(data, weights, biases, training=False):
# Convolution layers
conv1 = conv2d(data, weights['c1'], biases['c1']) # [28,28,16]
conv2 = conv2d(conv1, weights['c2'], biases['c2']) # [28,28,16]
pool1 = tf.nn.max_pool(conv2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
# [14,14,16]
conv3 = conv2d(pool1, weights['c3'], biases['c3']) # [14,14,32]
conv4 = conv2d(conv3, weights['c4'], biases['c4']) # [14,14,32]
pool2 = tf.nn.max_pool(conv4, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
# [7,7,32]
# Flatten
flat = tf.reshape(pool2, [-1, weights['d1'].get_shape().as_list()[0]])
# [7*7*32] = [1568]
# Fully connected layer
fc1 = tf.add(tf.matmul(flat, weights['d1']), biases['d1']) # [128]
fc1 = tf.nn.relu(fc1) # [128]
# Dropout
if training:
fc1 = tf.nn.dropout(fc1, rate=0.2)
# Output
out = tf.add(tf.matmul(fc1, weights['out']), biases['out']) # [10]
return out
# Dataflow Graph
dataset = tf.data.Dataset.from_tensor_slices((train_images,train_labels)).repeat().batch(batch_size)
iterator = dataset.make_initializable_iterator()
batch_images, batch_labels = iterator.get_next()
logits = conv_net(batch_images, weights, biases, training=True)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=batch_labels))
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss)
test_predictions = tf.nn.softmax(conv_net(test_images, weights, biases))
acc,acc_op = tf.metrics.accuracy(predictions=tf.argmax(test_predictions,1), labels=test_labels)
# Run Session
with tf.Session() as sess:
# Initialize Variables
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
sess.run(iterator.initializer)
# Train the Model
for epoch in range(n_epochs):
prog_bar = tqdm(range(int(len(train_images)/batch_size)))
for step in prog_bar:
_,cost = sess.run([train_op,loss])
prog_bar.set_description("cost: {:.3f}".format(cost))
accuracy = sess.run(acc_op)
print('nEpoch {} Accuracy: {:.3f}'.format(epoch+1, accuracy))
# Show Sample Predictions
predictions = sess.run(tf.argmax(conv_net(test_images[:25], weights, biases), axis=1))
f, axarr = plt.subplots(5, 5, figsize=(25,25))
for idx in range(25):
axarr[int(idx/5), idx%5].imshow(np.squeeze(test_images[idx]), cmap='gray')
axarr[int(idx/5), idx%5].set_title(str(predictions[idx]),fontsize=50)
# Save Model
saver = tf.train.Saver()
saver.save(sess, './model.ckpt')
Keras的等效模型
Keras是一种高阶API，可以通过使用其顺序模型API（功能API也是对更复杂的神经网络的一种选择）大大简化上述代码。
请注意，不需要使用会话。此外，模型权重和偏差不需要在模型外部定义。它们是在添加层时创建的，而且它们的形状是自动计算的。
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D, Input
from keras.optimizers import Adam
from keras.datasets import mnist
from keras.utils import to_categorical
import numpy as np
# MNIST Dataset
(train_images, train_labels),(test_images, test_labels) = mnist.load_data()
train_images = np.expand_dims(train_images.astype(np.float32) / 255.0, axis=3)
test_images = np.expand_dims(test_images.astype(np.float32) / 255.0, axis=3)
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
# Training parameters
batch_size = 128
n_epochs = 5
n_classes = 10
# Create the model
model = Sequential()
# Convolution Layers
model.add(Conv2D(16, 3, activation='relu', input_shape=(28, 28, 1), padding='same'))
model.add(Conv2D(16, 3, activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=2, padding='same'))
model.add(Conv2D(32, 3, activation='relu', padding='same'))
model.add(Conv2D(32, 3, activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=2, padding='same'))
# Dense Layers
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(n_classes, activation='softmax'))
# Optimizer
optimizer = Adam(lr=1e-4)
# Compile
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['categorical_accuracy'])
# Train model
model.fit(train_images,
train_labels,
epochs=n_epochs,
batch_size=batch_size,
validation_data=(test_images, test_labels)
)
# Show Sample Predictions
predictions = model.predict(test_images[:25])
predictions = np.argmax(predictions, axis=1)
f, axarr = plt.subplots(5, 5, figsize=(25,25))
for idx in range(25):
axarr[int(idx/5), idx%5].imshow(np.squeeze(test_images[idx]), cmap='gray')
axarr[int(idx/5), idx%5].set_title(str(predictions[idx]),fontsize=50)
# Save Model
model.save_weights("model.h5")
总结
TensorFlow图创建了计算数据流用于训练模型，而且这些会话用于实际训练中。本文展示了创建图和在训练对话中运行图时使用的不同步骤和选项。当大致了解了如何创建图并在会话中使用时，开发自定义神经网络和使用TensorFlow Core来满足特定需求就会变得更容易。
显而易见，keras更为简洁，并且该API有利于测试新的神经网络。然而，对于新的人工智能开发人员来说，许多步骤可能是“黑匣子”，而本教程可以帮助展示其后台发生的事情。
编译组：陈枫、黄琎
相关链接：
https://towardsdatascience.com/guide-to-coding-a-custom-convolutional-neural-network-in-tensorflow-bec694e36ad3