使用 TensorFlow 和 Keras 编写卷积神经网络

卷积神经网络(CNN)是一种特殊的前馈神经网络,在其体系结构中包含卷积和汇聚层。CNN 架构,也称为 ConvNets,其一般模式是按以下顺序包含这些层:

  1. 全连接输入层
  2. 卷积、池化和完全连接层的多种组合
  3. 完全连接的输出层,具有 softmax 激活功能

CNN 架构已被证明在解决涉及图像学习的问题(例如图像识别和对象识别)方面非常成功。

在本文中,我们将学习与 ConvNets 相关的以下主题:

  • 理解卷积
  • 理解池化
  • CNN 架构模式 LeNet
  • 用于 MNIST 数据集的 LeNet
    • 使用 TensorFlow 编写用于 MNIST 数据集的 LeNet
    • 使用 Keras 编写用于 MNIST 数据集的 LeNet
  • 用于 CIFAR 数据集的 LeNet
    • 使用 TensorFlow 编写用于 CIFAR10 数据集的 LeNet
    • 使用 Keras 编写用于 CIFAR10 数据集的 LeNet

让我们从学习ConvNets背后的核心概念开始。

理解卷积

卷积(Convolution)是CNN架构背后的核心概念。简单来说,卷积是一种数学运算,它结合了两个来源的信息来产生一组新的信息。具体来说,它将一个称为内核的特殊矩阵应用于输入张量,以生成一组称为特征映射的矩阵。可以使用任何流行的算法将内核应用于输入张量。

生成卷积矩阵的最常用算法如下:

N_STRIDES = [1,1]
1. Overlap the kernel with the top-left cells of the image matrix.
2. Repeat while the kernel overlaps the image matrix:
    2.1 c_col = 0
    2.2 Repeat while the kernel overlaps the image matrix:
        2.1.1 set c_row = 0
        2.1.2 convolved_scalar = scalar_prod(kernel, overlapped cells)
        2.1.3 convolved_matrix(c_row,c_col) = convolved_scalar
        2.1.4 Slide the kernel down by N_STRIDES[0] rows.
        2.1.5 c_row = c_row + 1
    2.3 Slide the kernel to (topmost row, N_STRIDES[1] columns right)
    2.4 c_col = c_col + 1 

例如,让我们假设核矩阵是2 x 2矩阵,输入图像是3 x 3矩阵。下图逐步显示了上述算法:

在卷积操作结束时,我们得到以下特征图:

-6-8
-12-14

在上面的示例中,与卷积的原始输入相比,得到的特征映射的大小更小。通常,要素图的大小减小(内核大小-1)。 因此,要素图的大小是:

size_{feature\_map} = size_{features} - size_{kernel} + 1

3-D 张量

对于具有额外深度尺寸的三维张量,您可以将前面的算法视为应用于深度维度中的每个图层。将卷积应用于3D张量的输出也是2D张量,因为卷积运算添加了三个通道。

步幅(Stride,或译作“步长”)

数组N_STRIDES中的步幅是您希望通过其滑动内核的行或列的数字。在我们的例子中,我们使用了1的步幅。如果我们使用更大的步幅,那么特征图的大小将根据以下等式进一步减小:

size_{feature\_map} = \frac{size_{features} - size_{kernel}}{n_{strides}} + 1

填充(Padding)

如果我们不希望减小特征映射的大小,那么我们可以在输入的所有边上使用填充,使得特征的大小增加了单个填充尺寸的两倍。使用填充,可以按如下方式计算要素图的大小:

size_{feature\_map} = \frac{size_{features} + 2 \times size_{padding} - size_{kernel}}{n_{strides}} + 1

TensorFlow允许两种填充:SAME或VALID。SAME填充意味着添加填充,使输出要素图与输入要素具有相同的大小。VALID填充意味着没有填充。

应用先前提到的卷积算法的结果是特征映射,该映射是原始张量的滤波版本。例如,特征映射可能只有从原始图像中过滤出的轮廓。因此,内核也称为过滤器。对于每个内核,您将获得单独的2D特征映射。

根据您希望网络学习的功能,您必须应用适当的过滤器来强调所需的功能。但是,使用CNN,模型可以自动了解哪些内核在卷积层中最有效。

TensorFlow 中的卷积操作

TensorFlow 提供实现卷积算法的卷积层。例如,具有以下签名的 tf.nn.conv2d() 操作:

tf.nn.conv2d(
 input,
 filter,
 strides,
 padding,
 use_cudnn_on_gpu=None,
 data_format=None,
 name=None
)

input和filter表示形状为 [batch_size,input_height,input_width,input_depth] 的数据张量,以及形状为 [filter_height,filter_width,input_depth,output_depth] 的内核张量。内核张量中的 output_depth 表示应该应用于输入的内核的数量。步幅张量表示每个维度中要滑动的单元格数。如上所述,填充是VALID或SAME。

您可以在以下链接中找到有关TensorFlow中可用卷积操作的更多信息:

https://www.tensorflow.org/api_docs/python/tf/nn/convolution

https://tensorflow.google.cn/api_docs/python/tf/nn/convolution

您可以在以下链接中找到有关Keras中可用卷积层的更多信息:

https://keras.io/layers/convolutional/

以下链接提供了卷积的详细数学解释:

http://colah.github.io/posts/2014-07-Understanding-Convolutions/

http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/

卷积层或卷积运算将输入值或神经元连接到下一个隐藏层神经元。每个隐藏层神经元连接到相同数量的输入神经元,数量与内核元素的数量相同。所以在前面的例子中,内核有4个元素,因此隐藏层神经元连接到输入层的4个神经元(3×3个神经元中)。在我们的例子中,输入层的4个神经元的这个区域被称为CNN理论中的感受域(receptive field)。

卷积层的每个内核都有单独权重和偏置参数。权重参数的数量等于内核中元素的数量,并且只有一个偏置参数。内核的所有连接共享相同的权重和偏置参数。因此在我们的例子中,将有4个权重参数和1个偏置参数,但如果我们在卷积层中使用5个内核,则总共将有 5 \times 4 个权重参数和 5 \times 1 个偏置参数,每个特征映射都有一组参数(4个权重和1个偏置)。

理解池化

通常,在卷积运算中,会应用几个不同的内核,这会导致生成若干特征映射。因此,卷积运算会生成尺寸交大数据集。

例如,将形状为3 x 3 x 1的内核应用于具有28 x 28 x 1像素形状图像的MNIST数据集,可生成形状为26 x 26 x 1的特征映射。如果我们在一个卷积层中应用32个这样的滤波器,则输出的形状为32 x 26 x 26 x 1,即形状为26 x 26 x 1的32个特征图。

与形状为28 x 28 x 1的原始数据集相比,这是一个庞大的数据集。因此,为了简化下一层的学习,我们应用了“池化”的概念。

池化(Pooling)是指计算卷积特征空间区域的聚合统计量。两个最受欢迎的聚合统计数据是最大值和平均值。应用 max-pooling 的输出是所选区域的最大值,而应用 average-pooling 的输出是区域中数字的平均值。

译者注:Pooling 的大众翻译是“池化”。但我认为此种翻译没有突出“统计”、“聚合”等含义。因此,我认为将“Pooling”这个词译作“区域汇集”、“区域聚合”或“区域聚拢”,将“Max-pooling”译作“区域最大”,将“Average-pooling”译作“区域平均”更合适。

例如,假设特征映射的形状为3 x 3,形状的聚合区域为2 x 2。以下图像显示了使用[1,1] 的步幅应用“区域最大”运算的过程:

在“区域最大”运算结束后,我们得到以下矩阵:

56
89

通常,汇集操作应用非重叠区域,因此步幅张量和区域张量被设置为相同的值。

例如,TensorFlow具有max_pooling操作,其签名如下:

max_pool(
 value,
 ksize,
 strides,
 padding,
 data_format='NHWC',
 name=None
)

value 表示形状为 [batch_size,input_height,input_width,input_depth] 的输入张量 。对形状为 ksize 的矩形区域执行“池化”运算。这些区域每次偏移量由 strides 决定。

您可以在以下链接中找到有关TensorFlow中可用的池操作的更多信息:

https://www.tensorflow.org/api_docs/python/tf/nn/pool

https://tensorflow.google.cn/api_docs/python/tf/nn/pool

有关Keras中可用的池层的更多信息,请访问以下链接:

https://keras.io/layers/pooling/

以下链接提供了“池化”的详细数学说明:

http://ufldl.stanford.edu/tutorial/supervised/Pooling/

卷积神经网络架构模式——LeNet

LeNet是实现CNN的流行架构模式。在本文中,我们将学习如何通过按以下顺序创建图层来构建基于LeNet模式的CNN模型:

  1. 输入层
  2. 卷积层1——生成一组特征映射,带有 ReLU 激活函数
  3. 池化层1——生成一组统计聚合特征映射
  4. 卷积层2——生成一组特征映射,带有 ReLU 激活函数
  5. 池化层2——生成一组统计聚合特征映射
  6. 完全连接层——压平后的特征矩阵,带有 ReLU 激活函数
  7. 输出层——应用简单线性激活函数生成输出

LeNet系列模型由Yann LeCun及其研究人员提出。有关LeNet系列模型的更多详细信息,请访问以下链接:

http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf

Yann LeCun在以下链接中保留了LeNet系列模型的列表

http://yann.lecun.com/exdb/lenet/index.html

用于 MNIST 数据的 LeNet

您可以按照Jupyter笔记本 ch-09a_CNN_MNIST_TF_and_Keras 中的代码进行操作

准备MNIST数据,分隔为测试集和训练集:

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets(os.path.join('.','mnist'), one_hot=True)
X_train = mnist.train.images
X_test = mnist.test.images
Y_train = mnist.train.labels
Y_test = mnist.test.labels

使用 TensorFlow 编写用于 MNIST 的 LeNet 卷积神经网络

在TensorFlow中,应用以下步骤为MNIST数据构建基于LeNet的CNN模型:

  1. 定义超参数,以及 x 和 y 的占位符(输入图像和输出标签):
n_classes = 10 # 0-9 digits
n_width = 28
n_height = 28
n_depth = 1
n_inputs = n_height * n_width * n_depth # total pixels
learning_rate = 0.001
n_epochs = 10
batch_size = 100
n_batches = int(mnist.train.num_examples/batch_size)
# input images shape: (n_samples,n_pixels)
x = tf.placeholder(dtype=tf.float32, name="x", shape=[None, n_inputs])
# output labels
y = tf.placeholder(dtype=tf.float32, name="y", shape=[None, n_classes])

将输入 x 重塑为形状 (n_samples, n_width, n_height, n_depth):

x_ = tf.reshape(x, shape=[-1, n_width, n_height, n_depth])
  1. 使用形状为 4 x 4 的 32 个内核定义第一个卷积层,从而生成32个特征映射。
  • 首先,定义第一个卷积层的权重和偏置。我们使用正态分布填充参数:
layer1_w = tf.Variable(tf.random_normal(shape=[4,4,n_depth,32], stddev=0.1),name='l1_w')
layer1_b = tf.Variable(tf.random_normal([32]),name='l1_b')
  • 其次,使用 tf.nn.conv2d 函数定义卷积层。函数参数 stride 定义了内核张量在每个维度中应该滑动的元素。维度顺序由data_format确定,可以是“NHWC”或“NCHW”(默认情况下为“NHWC”)。通常,步幅中的第一个和最后一个元素设置为“1”。函数参数填充可以是 SAME 或 VALID。SAME 填充意味着输入将用零填充,使得在卷积之后输出与输入具有相同的形状。使用 tf.nn.relu() 函数添加 relu 激活:
layer1_conv = tf.nn.relu(tf.nn.conv2d(x_,layer1_w, strides=[1,1,1,1], padding='SAME') + layer1_b)
  • 使用 tf.nn.max_pool() 函数定义第一个池化层。参数 ksize 表示使用 2 x 2 x 1 个区域的池化操作,参数 stride 表示将区域滑动 2 x 2 x 1 个像素。因此,区域彼此不重叠。由于我们使用 max_pool,因此池化操作选择2 x 2 x 1区域中的最大值:
layer1_pool = tf.nn.max_pool(layer1_conv,ksize=[1,2,2,1], strides=[1,2,2,1],padding='SAME')

一个卷积层产生 32 个大小为 28 x 28 x 1 的特征映射,然后汇集成 32 x 14 x 14 x 1 的数据。

  1. 定义第二个卷积层,将该数据作为输入,并生成64个要特征映射。
  • 首先,定义第二个卷积层的权重和偏置。 我们使用正态分布填充参数:
layer2_w = tf.Variable(tf.random_normal(shape=[4,4,32,64], stddev=0.1),name='l2_w')
layer2_b = tf.Variable(tf.random_normal([64]),name='l2_b')
  • 接下来,使用 tf.nn.conv2d 函数定义卷积层:
layer2_conv = tf.nn.relu(tf.nn.conv2d(layer1_pool, layer2_w, strides=[1,1,1,1], padding='SAME' ) + layer2_b )
  • 使用tf.nn.max_pool函数定义第二个池化层:
layer2_pool = tf.nn.max_pool(layer2_conv,
    ksize=[1,2,2,1],
    strides=[1,2,2,1],
    padding='SAME'
)

第二个卷积层的输出形状为 64×14×14×1,然后汇集成形状为 64×7×7×1 的输出。

  1. 在进入1024个神经元的完全连接层之前重塑输出形状,以产生大小为1024的扁平输出:
layer3_w = tf.Variable(tf.random_normal(shape=[64*7*7*1,1024],stddev=0.1),name='l3_w')
layer3_b = tf.Variable(tf.random_normal([1024]),name='l3_b')
layer3_fc = tf.nn.relu(tf.matmul(tf.reshape(layer2_pool,[-1, 64*7*7*1]),layer3_w) + layer3_b)
  1. 完全连接层的输出送入具有10个输出的线性输出层。我们在这一层没有使用softmax,因为我们的损失函数自动将 softmax 应用于输出:
layer4_w = tf.Variable(tf.random_normal(shape=[1024, n_classes], stddev=0.1),name='l)
layer4_b = f.Variable(tf.random_normal([n_classes]),name='l4_b')
layer4_out = tf.matmul(layer3_fc,layer4_w)+layer4_b

以上步骤创建了我们保存在变量模型中的第一个CNN模型:

model = layer4_out

我们鼓励读者探索 TensorFlow 提供的不同卷积和池化运算符,并尝试不同的超参数。

为了定义损失,我们使用 tf.nn.softmax_cross_entropy_with_logits 函数,对于优化器,我们使用 AdamOptimizer 函数。您应该尝试探索 TensorFlow 中提供的不同优化器函数。

entropy = tf.nn.softmax_cross_entropy_with_logits(logits=model, labels=y)
loss = tf.reduce_mean(entropy)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)

最后,我们通过迭代 n_epochs 次训练模型,每次训练 n_batches 个批次,每个批次大小为 batch_size:

with tf.Session() as tfs:
    tf.global_variables_initializer().run()
    for epoch in range(n_epochs):
        total_loss = 0.0
        for batch in range(n_batches):
            batch_x,batch_y = mnist.train.next_batch(batch_size)
            feed_dict={x:batch_x, y: batch_y}
            batch_loss,_ = tfs.run([loss, optimizer],feed_dict=feed_dict)
            total_loss += batch_loss
        average_loss = total_loss / n_batches
        print("Epoch: {0:04d} loss = {1:0.6f}".format(epoch,average_loss))
    print("Model Trained.")

    predictions_check = tf.equal(tf.argmax(model,1),tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(predictions_check, tf.float32))
    feed_dict = {x:mnist.test.images, y:mnist.test.labels}
    print("Accuracy:", accuracy.eval(feed_dict=feed_dict))

我们得到以下输出:

Epoch: 0000 loss = 1.418295
Epoch: 0001 loss = 0.088259
Epoch: 0002 loss = 0.055410
Epoch: 0003 loss = 0.042798
Epoch: 0004 loss = 0.030471
Epoch: 0005 loss = 0.023837
Epoch: 0006 loss = 0.019800
Epoch: 0007 loss = 0.015900
Epoch: 0008 loss = 0.012918
Epoch: 0009 loss = 0.010322
Model Trained.
Accuracy: 0.9884

现在,与我们在前几篇文章中看到的方法相比准确性非常好。从图像数据中学习CNN模型是不是很神奇?

使用 Keras 编写用于 MNIST 的 LeNet 卷积神经网络

让我们重新审视具有相同数据集的相同 LeNet 架构,以在Keras中构建和训练CNN模型:

  1. 导入所需的Keras模块:
import keras
from keras.models import Sequential
from keras.layers import Conv2D,MaxPooling2D, Dense, Flatten, Reshape
from keras.optimizers import SGD
  1. 定义每个图层的过滤器数量:
n_filters=[32,64]
  1. 定义其他超参数:
learning_rate = 0.01
n_epochs = 10
batch_size = 100
  1. 定义顺序模型并添加图层以将输入数据重新整形为形状(n_width,n_height,n_depth):
model = Sequential()
model.add(Reshape(target_shape=(n_width,n_height,n_depth), input_shape=(n_inputs,)))
  1. 添加第一个卷积层,4 x 4 卷积核,SAME 填充和 ReLU 激活函数:
model.add(Conv2D(filters=n_filters[0],kernel_size=4,  padding='SAME',activation='relu'))
  1. 添加区域大小为 2 x 2 且步幅为 2 x 2 的池化层:
model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2)))
  1. 以与添加第一层相同的方式添加第二个卷积和池化层:
model.add(Conv2D(filters=n_filters[1],kernel_size=4, padding='SAME',activation='relu') )
model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2)))
  1. 添加一个层,用来展平第二个池化层的输出,并且添加一个1024个神经元的完全连接层,以处理展平的输出:
model.add(Flatten())
model.add(Dense(units=1024, activation='relu'))
  1. 给最终输出层添加 softmax 激活函数:
model.add(Dense(units=n_outputs, activation='softmax'))
  1. 使用以下代码查看模型摘要:
model.summary()

该模型描述如下:

层(类型)输出形状参数 #
reshape_1 (Reshape)(None, 28, 28, 1)0
conv2d_1 (Conv2D)(None, 28, 28, 32)544
max_pooling2d_1(MaxPooling2D)(None, 14, 14, 32)0
conv2d_2 (Conv2D)(None, 14, 14, 64)32832
max_pooling2d_2(MaxPooling2D)(None, 7, 7, 64)0
flatten_1 (Flatten)(None, 3136)0
dense_1 (Dense)(None, 1024)0
dense_2 (Dense)(None, 10)0
Total params: 3,255,914
Trainable params: 3,255,914
Non-trainable params: 0
  1. 编译、训练和评估模型:
model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=learning_rate), metrics=['accuracy'])
model.fit(X_train, Y_train,batch_size=batch_size, epochs=n_epochs)
score = model.evaluate(X_test, Y_test)
print('\nTest loss:', score[0])
print('Test accuracy:', score[1])

我们得到以下输出:

Epoch 1/10
55000/55000 [===================] - 267s - loss: 0.8854 - acc: 0.7631
Epoch 2/10
55000/55000 [===================] - 272s - loss: 0.2406 - acc: 0.9272
Epoch 3/10
55000/55000 [===================] - 267s - loss: 0.1712 - acc: 0.9488
Epoch 4/10
55000/55000 [===================] - 295s - loss: 0.1339 - acc: 0.9604
Epoch 5/10
55000/55000 [===================] - 278s - loss: 0.1112 - acc: 0.9667
Epoch 6/10
55000/55000 [===================] - 279s - loss: 0.0957 - acc: 0.9714
Epoch 7/10
55000/55000 [===================] - 316s - loss: 0.0842 - acc: 0.9744
Epoch 8/10
55000/55000 [===================] - 317s - loss: 0.0758 - acc: 0.9773
Epoch 9/10
55000/55000 [===================] - 285s - loss: 0.0693 - acc: 0.9790
Epoch 10/10
55000/55000 [===================] - 217s - loss: 0.0630 - acc: 0.9804
Test loss: 0.0628845927377
Test accuracy: 0.9785

准确性的差异可归因于我们在这里使用SGD优化器这一事实,它没有实现我们用于TensorFlow模型的AdamOptimizer提供的一些高级功能。

用于 CIFAR 10 数据的 LeNet

现在我们已经学会了使用 TensorFlow 和 Keras 的 MNIST 数据集来构建和训练 CNN 模型,让我们用CIFAR10数据集重复练习。

CIFAR-10数据集由60,000个形状为32×32像素的RGB彩色图像组成。图像被平均分为10个不同的类别或类别:飞机,汽车,鸟,猫,鹿,狗,青蛙,马,船和卡车。CIFAR-10和CIFAR-100是包含8000万个图像的大图像数据集的子集。CIFAR数据集由Alex Krizhevsky,Vinod Nair和Geoffrey Hinton收集和标记。数字10和100表示图像类别的数量。

有关CIFAR数据集的更多详细信息,请访问以下链接:

http://www.cs.toronto.edu/~kriz/cifar.html

http://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf

我们选择了CIFAR 10,因为它有3个通道,即图像的深度为3,而MNIST数据集只有一个通道。为简洁起见,我们省略了下载详细信息并将数据拆分为训练和测试集,并在本文的代码包中的datasetslib包中提供代码。

您可以按照 Jupyter 笔记本 ch-09b_CNN_CIFAR10_TF_and_Keras 中的代码进行操作。

我们使用以下代码加载和预处理CIFAR10数据:

from datasetslib.cifar import cifar10
from datasetslib import imutil
dataset = cifar10()
dataset.x_layout=imutil.LAYOUT_NHWC
dataset.load_data()
dataset.scaleX()

数据加载后,图像采用“NHWC”格式表示,这会使数据变形为(number_of_samples,image_height,image_width,image_channels)。我们将图像通道称为图像深度。图像中的每个像素是0到255之间的数字。使用MinMax缩放来缩放数据集,这么做的目的是使所有像素值除以255来标准化图像。

加载和预处理的数据变量为:dataset.X_train、dataset.Y_train、dataset.X_test 和 dataset.Y_test。

使用 TensorFlow 编写卷积神经网络用于 CIFAR 10

我们保持层、滤波器及其大小与之前的MNIST示例相同,增加了一个正则化层。 由于此数据集与 MNIST 相比更复杂,因此我们为了实现正则化儿添加了额外的退出)(Dropout)层:

tf.nn.dropout(layer1_pool, keep_prob)

在预测和评估期间,占位符keep_prob设置为1。这样我们就可以重复使用相同的模型进行训练以及预测和评估。

笔记本ch-09b_CNN_CIFAR10_TF_and_Keras中提供了CIFAR10数据的LeNet模型的完整代码。

在运行模型时,我们得到以下输出:

Epoch: 0000 loss = 2.115784
Epoch: 0001 loss = 1.620117
Epoch: 0002 loss = 1.417657
Epoch: 0003 loss = 1.284346
Epoch: 0004 loss = 1.164068
Epoch: 0005 loss = 1.058837
Epoch: 0006 loss = 0.953583
Epoch: 0007 loss = 0.853759
Epoch: 0008 loss = 0.758431
Epoch: 0009 loss = 0.663844
Epoch: 0010 loss = 0.574547
Epoch: 0011 loss = 0.489902
Epoch: 0012 loss = 0.410211
Epoch: 0013 loss = 0.342640
Epoch: 0014 loss = 0.280877
Epoch: 0015 loss = 0.234057
Epoch: 0016 loss = 0.195667
Epoch: 0017 loss = 0.161439
Epoch: 0018 loss = 0.140618
Epoch: 0019 loss = 0.126363
Model Trained.
Accuracy: 0.6361

与我们在 MNIST 数据上获得的准确度相比,此处的准确性比较糟糕。通过调整不同的超参数并改变卷积和池化层的组合,可以实现更好的准确性。我们将阅读和尝试LeNet架构和超参数的不同变体的挑战留给读者,以实现更高的准确性。

使用 Keras 编写卷积神经网络用于 CIFAR 10

让我们使用 Keras 重复 LeNet CNN 模型构建和训练 CIFAR10 数据。我们保持架构与前面的示例相同,以便轻松解释概念。 在Keras中,添加退出层,如下所示:

model.add(Dropout(0.2))

笔记本ch-09b_CNN_CIFAR10_TF_and_Keras中提供了Keras for CIFAR10 CNN模型的完整代码。

在运行模型时,我们得到以下模型描述:

层(类型)输出形状参数 #
conv2d_1(None, 32, 32, 32)1568
max_pooling2d_1 (MaxPooling2D)(None, 16, 16, 32)0
dropout_1 (Dropout)(None, 16, 16, 32)0
conv2d_2 (Conv2D)(None, 16, 16, 64)32832
max_pooling2d_2 (MaxPooling2D)(None, 8, 8, 64)0
dropout_2 (Dropout)(None, 8, 8, 64)0
flatten_1 (Flatten)(None, 4096)0
dense_1 (Dense)(None, 1024)4195328
dropout_3 (Dropout)(None, 1024)0
dense_2 (Dense)(None, 10)10250
Total params: 4,239,978
Trainable params: 4,239,978
Non-trainable params: 0

我们获得以下训练和评估结果:

Epoch 1/10
50000/50000 [====================] - 191s - loss: 1.5847 - acc: 0.4364
Epoch 2/10
50000/50000 [====================] - 202s - loss: 1.1491 - acc: 0.5973
Epoch 3/10
50000/50000 [====================] - 223s - loss: 0.9838 - acc: 0.6582
Epoch 4/10
50000/50000 [====================] - 223s - loss: 0.8612 - acc: 0.7009
Epoch 5/10
50000/50000 [====================] - 224s - loss: 0.7564 - acc: 0.7394
Epoch 6/10
50000/50000 [====================] - 217s - loss: 0.6690 - acc: 0.7710
Epoch 7/10
50000/50000 [====================] - 222s - loss: 0.5925 - acc: 0.7945
Epoch 8/10
50000/50000 [====================] - 221s - loss: 0.5263 - acc: 0.8191
Epoch 9/10
50000/50000 [====================] - 237s - loss: 0.4692 - acc: 0.8387
Epoch 10/10
50000/50000 [====================] - 230s - loss: 0.4320 - acc: 0.8528
Test loss: 0.849927025414
Test accuracy: 0.7414

我们再次将其作为挑战,让读者探索并尝试不同的LeNet架构和超参数变体,以获得更高的准确性。

总结

在本文中,我们学习了如何使用TensorFlow和Keras创建卷积神经网络。我们学习了卷积和汇集的核心概念,这是CNN的基础。我们学习了LeNet系列架构,并为MNIST和CIFAR数据集创建、训练和评估了LeNet族模型。TensorFlow和Keras提供了许多卷积和池化层以及运算。我们鼓励读者探索本文未涉及的层和运算。

在下一篇文章中,我们将继续学习如何使用自动编码器(AutoEncoder)架构将 TensorFlow 应用于图像数据。

发表评论

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据