用TensorFlow和TensorBoard从零开始构建ConvNet(CNN)-阿里云开发者社区

开发者社区> 【方向】> 正文

用TensorFlow和TensorBoard从零开始构建ConvNet(CNN)

简介: Tensorflow作为当下最流行的深度学习框架,实现ConvNet(CNN)自然是轻而易举,但是本文创造性的使用的TensorBoard来图形化展示CNN实现过程,极大的提高了研究者的对自己模型的管理能力。
+关注继续查看

更多深度文章,请关注:https://yq.aliyun.com/cloud


首先了解TensorBoard是什么?解开你心中的疑惑!

在本教程中,我将介绍如何使用TensorFlow,从头开始构建卷积神经网络,并使用TensorBoard可视化我们的图形及神经网络性能。如果您不了解完全神经网络的一些基础知识,我强烈建议您首先看另一个教程关于TensorFlow。在这篇文章中,我也把卷积神经网络的每个步骤讲的都很仔细,所以你可以在文章中完全了解每个步骤发生了什么。未来您可以看到每一层的卷积,并使用它们进行自己的网络模型构建,所以我从头开始构建该模型。我只会强调主要的代码,不过你可以GitHub下载源码。

1.选择数据集

一开始,我先要选择图像数据集。我决定用牛津大学的宠物数据集。我选择了这个数据集的原因很简单:标签非常简单,训练数据也不错,而且还有一些边框。另一个我认为对于创建第一个模型是非常好的数据集是Kaggle上发现的辛普森数据集

2.选择一个模型

第二步,必须决定我们的卷积神经网络的模型。一些非常受欢迎的型号例如:GoogLeNetVGG16,它们都具有多个卷积,可以用于检测1000种数据集imagenet中的图像。我决定一个更简单的卷积网络:

8bc7067b2414679aab060ae228ae5c461bae5a5f

我们先简要的分解这个模型,它以一个224x224x3的图像开始,它根据前三个通道卷积到32个特征图(Feature Map)。我们将这组32个特征图集合到另外32个特征中。然后将其汇总到112x112x32图像中,我们将卷入64个特征图,然后再次进行二次,最后汇总为56x56x64。然后将这个最终合并的层的每个单元完全连接到一个512个的神经元中,然后基于类的数​​量最后放入softmax层。整个过程就是如此,如果你对上述有一些疑问,可以进一步与我交流。

3.处理和构建数据集:

首先,我们要加载我们的依赖项,其中包括我所调用的功能函数imFunctions来处理图像数据。

import imFunctions as imf
import tensorflow as tf
import scipy.ndimage
from scipy.misc import imsave
import matplotlib.pyplot as plt
import numpy as np

我们可以使用imFunctions提供的下载的方式提取图像。

imf.downloadImages('annotations.tar.gz', 19173078)
imf.downloadImages('images.tar.gz', 791918971)
imf.maybeExtract('annotations.tar.gz')
imf.maybeExtract('images.tar.gz')

然后我们可以将图像分成不同的文件夹,其中包括训练文件夹和测试文件夹。sortImages函数中的数字表示的是您想从训练数据中分离出测试数据的百分比。

imf.sortImages(0.15)

然后,我们可以使用相应的一个热矢量(one-hot)将我们的数据集构建成一个numpy数组,以表示我们的类。该函数将会表现您要让神经网络做那些事,由于我有限的GPU RAM3GB),我选择了一个非常小的数据集,仅仅试图区分两种狗:来自萨摩耶ShibaInu

train_x, train_y, test_x, test_y, classes, classLabels = imf.buildDataset()

4.如何卷积实现功能

现在我们有一个数据集可以使用,其次就是了解卷积如何工作。在跳入彩色卷积滤波器之前,让我们来看一下灰度图。让我们制作一个应用四个不同特征图的7x7滤镜。TensorFlowconv2d功能相当简单,它包含四个变量:输入,过滤器,步幅和填充。在TensorFlow官方网站上,他们描述的conv2d功能如下:

1.计算给定4-D输入和滤波张量的2-D卷积。

2.给定一个形状为[batchin_heightin_widthin_channels]的输入张量以及形状为[filter_heightfilter_widthin_channelsout_channels]的过滤器/内核张量。

由于我们正在使用灰度图,所以in_channels1,因为我们使用了四个过滤器,所以我们的out_channels将是4。我们将以下四个过滤器/内核应用到我们的一个图像中:

e735a76c8ddcae68bde2ece4b626a642a9677c44

让我们看看这个过滤器如何处理我们的灰度图像输入:

gray = np.mean(image,-1)
X = tf.placeholder(tf.float32, shape=(None, 224, 224, 1))
conv = tf.nn.conv2d(X, filters, [1,1,1,1], padding="SAME")
test = tf.Session()
test.run(tf.global_variables_initializer())
filteredImage = test.run(conv, feed_dict={X: gray.reshape(1,224,224,1)})
tf.reset_default_graph()

这将返回一个4d张量(1,224,224,4),我们可以使用它来可视化四个过滤器:

6536817c978115dac241a34fbc5392e799024bb3

我们可以看到过滤器的内核卷积非常强大。为了打破它,我们的7x7内核一次跨越图像像素的49个步长,然后将每个像素的值乘以内核值,然后将所有49个值加在一起,生成一个像素。

现在,本质上,大多数卷积神经网络只包括卷积和池化(pooling)。最常见的是3x3内核过滤器用于卷积。特别是步长为2×2,内核大小为2×2只是基于内核中最大像素值来减少图像大小的一种有效的方法。这是一个2x2内核的基本示例,在两个维度上都具有步长2

ab9cb5aeb835ff6b7d0c4134677021658cb219c9

现在,对于两个conv2d和最大池化,有两个选项可用于填充:“VALID”:这将缩小输入和“SAME”:这将通过在输入边缘添加来保持输入大小。这是一个具有3x3内核的最大池的示例,步长为1x1以比较填充选项:

19dfd8ede9b365bfcb488443a418e74ba3575d93

5.创建ConvNet

我们已经介绍了基础知识,那么让我们开始构建我们的卷积神经网络模型。我们可以从占位符开始。X将是我们的输入占位符,我们将把图像提供给XY_将成为一组图像的类。

X = tf.placeholder(tf.float32, shape=(None, 224, 224, 3))
Y_ = tf.placeholder(tf.float32, [None, classes])
keepRate1 = tf.placeholder(tf.float32)
keepRate2 = tf.placeholder(tf.float32)

范围(scope)对于在TensorBoard中的图形可视化非常有用,因为它们将所有内容分组成一个可扩展对象。我们创建了第一套内核大小为3x3的过滤器,它采用三个通道并输出32个过滤器。这意味着对于32个滤波器中的每一个,RGB通道将有3x3的内核权重。另外非常重要的一点是,我们的过滤器的权重值是使用截断的正常值进行初始化的,所以我们有多个随机过滤器,这意味着TensorFlow将适应我们的模型。

# CONVOLUTION 1 - 1
with tf.name_scope('conv1_1'):
    filter1_1 = tf.Variable(tf.truncated_normal([3, 3, 3, 32], dtype=tf.float32,stddev=1e-1), name='weights1_1')
    stride = [1,1,1,1]
    conv = tf.nn.conv2d(X, filter1_1, stride, padding='SAME')
    biases = tf.Variable(tf.constant(0.0, shape=[32], dtype=tf.float32),trainable=True, name='biases1_1')
    out = tf.nn.bias_add(conv, biases)
    conv1_1 = tf.nn.relu(out)

在我们第一次卷积conv1_1结束时,我们通过应用relu完成,通过将每个负数分配给零来作为阈值。然后我们将这32个特征集合到另外32个特征中。您可以看到第一个卷积层的输出将作为conv2d的输入。

# CONVOLUTION 1 - 2
with tf.name_scope('conv1_2'):
    filter1_2 = tf.Variable(tf.truncated_normal([3, 3, 32, 32], dtype=tf.float32,stddev=1e-1), name='weights1_2')
    conv = tf.nn.conv2d(conv1_1, filter1_2, [1,1,1,1], padding='SAME')
    biases = tf.Variable(tf.constant(0.0, shape=[32], dtype=tf.float32),trainable=True, name='biases1_2')
    out = tf.nn.bias_add(conv, biases)
    conv1_2 = tf.nn.relu(out)

然后我们将图像缩小一半。

# POOL 1
with tf.name_scope('pool1'):
    pool1_1 = tf.nn.max_pool(conv1_2,
                             ksize=[1, 2, 2, 1],
                             strides=[1, 2, 2, 1],
                             padding='SAME',
                             name='pool1_1')
    pool1_1_drop = tf.nn.dropout(pool1_1, keepRate1)

最后一部分涉及在池化层上使用dropout(稍后会详细介绍)。然后我们再进行两次卷积,共有64个特征和另一个池。请注意,第一次卷积必须将先前的32个特征通道转换为64

# CONVOLUTION 2 - 1
with tf.name_scope('conv2_1'):
    filter2_1 = tf.Variable(tf.truncated_normal([3, 3, 32, 64], dtype=tf.float32,stddev=1e-1), name='weights2_1')
    conv = tf.nn.conv2d(pool1_1_drop, filter2_1, [1, 1, 1, 1], padding='SAME')
    biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),trainable=True, name='biases2_1')
    out = tf.nn.bias_add(conv, biases)
    conv2_1 = tf.nn.relu(out)
# CONVOLUTION 2 - 2
with tf.name_scope('conv2_2'):
    filter2_2 = tf.Variable(tf.truncated_normal([3, 3, 64, 64], dtype=tf.float32,stddev=1e-1), name='weights2_2')
    conv = tf.nn.conv2d(conv2_1, filter2_2, [1, 1, 1, 1], padding='SAME')
    biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),trainable=True, name='biases2_2')
    out = tf.nn.bias_add(conv, biases)
    conv2_2 = tf.nn.relu(out)  
# POOL 2
with tf.name_scope('pool2'):
    pool2_1 = tf.nn.max_pool(conv2_2,
                             ksize=[1, 2, 2, 1],
                             strides=[1, 2, 2, 1],
                             padding='SAME',
                             name='pool2_1')
    pool2_1_drop = tf.nn.dropout(pool2_1, keepRate1)

接下来,我们创建一个512个神经元完全连接的神经网络层,它将为56x56x64 pool2_1层的每个像素设置一个权重连接。这将是超过1亿不同的权重值!为了计算我们的完全连接的网络,我们必须将输入转化一维,然后我们可以乘以我们的权重并加上我们的偏差(Bias)。

with tf.name_scope('fc1') as scope:
    shape = int(np.prod(pool2_1_drop.get_shape()[1:]))
    fc1w = tf.Variable(tf.truncated_normal([shape, 512], dtype=tf.float32,stddev=1e-1), name='weights3_1')
    fc1b = tf.Variable(tf.constant(1.0, shape=[512], dtype=tf.float32),trainable=True, name='biases3_1')
    pool2_flat = tf.reshape(pool2_1_drop, [-1, shape])
    out = tf.nn.bias_add(tf.matmul(pool2_flat, fc1w), fc1b)
    fc1 = tf.nn.relu(out)
    fc1_drop = tf.nn.dropout(fc1, keepRate2)

最后,我们的softmax与其相关的权重和偏差,最后是我们的输出Y。

#FULLY CONNECTED 3 & SOFTMAX OUTPUT
with tf.name_scope('softmax') as scope:
    fc2w = tf.Variable(tf.truncated_normal([512, classes], dtype=tf.float32,stddev=1e-1), name='weights3_2')
    fc2b = tf.Variable(tf.constant(1.0, shape=[classes], dtype=tf.float32),trainable=True, name='biases3_2')
    Ylogits = tf.nn.bias_add(tf.matmul(fc1_drop, fc2w), fc2b)
    Y = tf.nn.softmax(Ylogits)

6.创建损失函数和优化器:

现在,我们可以开始开发我们的模型的训练部分。首先,我们必须决定训练批量大小;我自己的情况是不能使用超过10,因为GPU内存的缘故。那么我们必须决定训练次数,算法将分批地遍历所有训练数据的次数,最后是我们的学习速率α

numEpochs = 400
batchSize = 10
alpha = 1e-5

然后,我们为我们的交叉熵,精度检查器和反向传播优化器创建了一些范围。

with tf.name_scope('cross_entropy'):
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=Ylogits, labels=Y_)
    loss = tf.reduce_mean(cross_entropy)
with tf.name_scope('accuracy'):
    correct_prediction = tf.equal(tf.argmax(Y, 1), tf.argmax(Y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
with tf.name_scope('train'):
    train_step = tf.train.AdamOptimizer(learning_rate=alpha).minimize(loss)

然后,我们可以创建我们的会话(session)并初始化所有的变量。

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

7. 准备TensorBoard

现在,我们想使用TensorBoard,这样我们可以看到我们的分类器在做什么。我们将创建plot模块:一个用于我们的训练集,一个用于我们的测试集。我们可以通过使用add_graph功能可视化我们的图形网络。我们将使用汇总标量(scalar)来衡量我们的损失值和准确度,并将我们的汇总合并在一起,所以我们只需要调用write_op记录我们的标量。

writer_1 = tf.summary.FileWriter("/tmp/cnn/train")
writer_2 = tf.summary.FileWriter("/tmp/cnn/test")
writer_1.add_graph(sess.graph)
tf.summary.scalar('Loss', loss)
tf.summary.scalar('Accuracy', accuracy)
tf.summary.histogram("weights1_1", filter1_1)
write_op = tf.summary.merge_all()

8.训练模型

然后我们可以对我们的模型进行评估和训练。我们不想在每个时间步骤中总结损失和准确性,因为这将大大减慢分类器的速度。所以相反,我们每五个步骤记录一次。

steps = int(train_x.shape[0]/batchSize)
for i in range(numEpochs):
    accHist = []
    accHist2 = []
    train_x, train_y = imf.shuffle(train_x, train_y)
    for ii in range(steps):
        #Calculate our current step
        step = i * steps + ii
        acc = sess.run([accuracy], feed_dict={X: train_x[(ii*batchSize):((ii+1)*batchSize),:,:,:], Y_: train_y[(ii*batchSize):((ii+1)*batchSize)], keepRate1: 1, keepRate2: 1})
        accHist.append(acc)        
        if step % 5 == 0:
            # Get Train Summary for one batch and add summary to TensorBoard
            summary = sess.run(write_op, feed_dict={X: train_x[(ii*batchSize):((ii+1)*batchSize),:,:,:], Y_: train_y[(ii*batchSize):((ii+1)*batchSize)], keepRate1: 1, keepRate2: 1})
            writer_1.add_summary(summary, step)
            writer_1.flush()
            
            # Get Test Summary on random 10 test images and add summary to TensorBoard
            test_x, test_y = imf.shuffle(test_x, test_y)
            summary = sess.run(write_op, feed_dict={X: test_x[0:10,:,:,:], Y_: test_y[0:10], keepRate1: 1, keepRate2: 1})
            writer_2.add_summary(summary, step)
            writer_2.flush()
 sess.run(train_step, feed_dict={X: train_x[(ii*batchSize):((ii+1)*batchSize),:,:,:], Y_: train_y[(ii*batchSize):((ii+1)*batchSize)], keepRate1: 0.2, keepRate2: 0.5})

9.可视化

当训练的时候,我们来看看TensorBoard的结果,在终端上激活TensorBoard

tensorboard --logdir="/tmp/cnn/"

然后我们可以将我们的网页浏览器指向默认的TensorBoard地址http://0.0.0.0/6006。我们先看看我们的图形化模型。正如你所看到的,通过使用范围(scope),我们可视化了一个漂亮的干净版本的图形。

f98c40eb4aa253a4c2125ed1842fcf6a5740bc78

10.性能测量

我们来看看我们准确度和损失的标量历史:

27d47652fcf9fc3a102397f14597fba49e2da299

你可能说我们有一个很严峻的问题。对于我们的培训数据,分类器获得了100%的准确性和0损失,但是我们的测试数据最多只能达到80%,并且会有很大的损失。这是一个常见的现象原,因包括训练数据不足或神经元太多。

我们可以通过调整、缩放和旋转训练数据以此来获得更多的训练数据,但是我认为更容易的方法是添加dropout功能到我们的池化层和完全连接层的输出。这将使每个训练步骤在每一层中随机地完全删除或退出一部分神经元。这将使我们的分类器一次只训练一小组的神经元,而全部的神经元。这使得专门神经元从事特定任务,而不是将所有神经元泛化在一起,同时进行某项工作。减少80%的卷积层和50%的完全连接的层可能会产生一些惊人的结果。

通过drop-out神经元,我们可以在测试数据上实现90%以下的性能,几乎提高了10%!但也有一个缺点,分类器花了大约6倍的时间来训练。

4.可视化进化过滤器

为了增加一些乐趣,每50个训练步骤,我通过一个过滤器传递了一个图像,并将过滤器的权重变化gif化。这出现了一些非常酷的效果和一些非常好的洞察例如:观察如何卷积网络的工作。以下是两个过滤器conv1_2

b0dedf4cbcaa4fd6361c4f9b9e12bf6bf18aa995

您可以看到加权初始化显示了大量图像,但权重随着时间的推移而变化,他们更加专注于检测某些边缘。令我吃惊的是,我发现第一个卷积内核filter1_1几乎没有改变。为了进一步了解网络,这里是conv2_2,您可以看到它开始检测更多的抽象的泛化功能。

abda88fea07daa2c060685d61f46fa21da3f6b5e

总而言之,让我印象深刻的是,我能够使用少于400个训练图像训练几乎90%精度的模型。我相信有更多的训练数据及更多的调整超参数,我可以取得更好的结果。

最后,重要的是要记住,在制作具有少量数据的分类器时,更容易的方法是采用已经在具有多个GPU(例如GoogLeNetVGG16的巨大数据集上进行训练的模型和权重,并在最后一层用自己的类替换它们的类。那么,这就要求所有的分类器都要做的是学习最后一层的权重,并使用预先存在的训练过的权重。最后希望你能在本文中学到一些知识,have fun

本文由北邮@爱可可-爱生活老师推荐,@阿里云云栖社区组织翻译。

文章原标题《Visualizing convolutional neural networks

作者:Justin Francis

Justin Francis目前是加拿大阿尔伯塔大学的本科生。贾斯汀还在大学工程俱乐部自主机器人车辆项目arvp.org)的软件团队中帮助实施和实验了深入学习和强化学习算法

译者:袁虎 审阅:坯子

文章为简译,更为详细的内容,请查看原文


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
阿里云服务器怎么设置密码?怎么停机?怎么重启服务器?
如果在创建实例时没有设置密码,或者密码丢失,您可以在控制台上重新设置实例的登录密码。本文仅描述如何在 ECS 管理控制台上修改实例登录密码。
4054 0
OneAlert携手钉钉快速构建IT运维on-call机制
摘要:OneAlert 是北京蓝海讯通科技股份有限公司旗下产品,中国第一个 SaaS 模式的免费的云告警平台,集成国内外主流监控/支撑系统,实现一个平台上集中处理所有IT事件,提升IT可靠性。并且能够帮助中小企业快速构建 IT 运维 7x24 小时的 on-call 机制,随时响应解决故障/问题。
4030 0
ASP.NET Core MVC中构建Web API
在ASP.NET CORE MVC中,Web API是其中一个功能子集,可以直接使用MVC的特性及路由等功能。 在成功构建 ASP.NET CORE MVC项目之后,选中解决方案,先填加一个API的文件夹,填加后,选中API文件夹, 选择新建项,选择填加Web API控制器,要注意控制器在命名时,是以Controller结尾的,这个不能改,前面的随意,比如,此处以NoteController.cs为例 填加后,打开NoteController.cs,系统已经帮我们构建好了一些基础的功能,我们需要在其基础上进行一些个性化修改使其成为我们自己的代码。
888 0
阿里云EDAS 3.0重磅发布,无侵入构建云原生应用
近日,阿里云EDAS重磅发布3.0版本,全面支撑云原生技术体系,旨在帮助各行业的企业客户以更经济的方式、更高效的路径在云上构建一套云原生应用。
908 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
4397 0
通过阿里云ECS从零开始构建网站
为帮助大家基于ECS构建自己的网站,本文将逐步介绍如何在ECS上架设自己的网站。现在网站主流的技术一般都采用Nginx+Mongodb+NodeJS,本教程将就此技术进行介绍,具体所涉及到的技术栈如下表所示:
2862 0
+关注
【方向】
欢迎各位对内容方向及质量提需求,我们尽量满足,将国外优质的内容呈现给大家!
696
文章
5
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载