学习笔记TF030:实现AlexNet

软件设计 2017-07-25

ILSVRC(ImageNet Large Scale Visual Recognition Challenge)分类比赛。AlexNet 2012年冠军(top-5错误率16.4%,额外数据15.3%,8层神经网络)。VGGNet 2014年亚军(top-5错误率7.3%,19层神经网络)。Google Inception 2014年冠军(top-5错误率6.7%,22层神经网络)。ResNet 2015年冠军(top-5错误率3.57%,152层神经网络)。人眼错误率5.1%。卷积神经网络基本解决ImageNet数据集图片分类问题。

ImageNet,2007年斯坦福大学李飞飞教授创办,收集大量带标注信息图片数据供计算机视觉模型训练。1500万张标注高清图片,22000类,100万张标注图片主要物体定位边框。眼睛生物照相机,每200ms拍一张,3岁已经上亿张。ImageNet下载互联网10亿张图片,亚马逊土耳其机器人平台众包标注过程,167个国家5万名工作者筛选标注。每年ILSVRC比赛数据120万张图片,1000类标注。top-5、top-1分类错误率模型性能评测指标。

2012年,Hinton学生Alex Krizhevsky提出LeNet更深更宽版深度神经网络模型AlexNet。首次在CNN用ReLU、Dropout、LRN等Trick。GPU运算加速。开源GPU训红卷积神经网络CUDA代码。6亿3000万连接,6000万参数,65万神经元,5个卷积层,3个卷积层后连最大池化层,3个全连接层。top-5错误率16.4%。第二名26.2%。神经网络低谷期后第一次发声,确立深度学习(深度卷积网络)计算机视觉统治地位,推动深度学习语音识别、自然语言处理、强化学习领域拓展。

成功使用ReLU CNN激活函数,验证较深网络效果超过Sigmoid,解决梯度弥散问题。训练用Dropout随机忽略部分神经元,避免模型过拟合。CNN用重叠最大池化,避免平均池化模糊化效果,步长比池化核尺寸小,池化层输出重叠覆盖,提升特征丰富性。LRN层,创建局部神经元活动竞争机制,响应较大值变更大,抑制其他反馈较小神经元,增强模型泛化能力。CUDA加速深度卷积网络训练,并行计算大量矩阵,GPU通信方便,互相访问显存,只在网络某些层进行,控制通信性能损耗。数据增强,随机从256x256原始图像截取224x224区域,水平翻转镜像,增加(256-224)^2x2=2048倍数据量,减轻过拟合,提升泛化能力,预测取图片四角加中间5个位置,左右翻转,10张图片,10次预测结果求均值,图像RGB数据PCA处理,主成分标准差0.1高斯扰动,增加噪声,错误率下降1%。

8个参数训练层(不包括池化层、LRN层),前5卷积层,后3全连接层。最后一层1000类输出Softmax层分类。LRN层在第1、2卷积层后,最大池化层在LRN层、最后卷积层后。ReLU激活函数在每个参数层后。

AlexNet超参数:params AlexNext FLOPs4M FC1000 4M16M FC4096/ReLU 4M37M FC4096/ReLU 37M Max Pool 3x3s2 442K Conv 3x3s1,256/ReLU 74M1.3M Conv 3x3s1,384/ReLU 112M884K Conv 3x3s1,384/ReLU 149M Max Pool 3x3s2 Local Response Norm 307K Conv 5x5s1,256/ReLU 223M Max Pool 3x3s2 Local Response Norm 35K Conv 11x11s4,96/ReLU 105M

输入图片尺寸224x224,第一卷积层卷积核尺寸11x11,步长4,96个卷积核。LRN层。3x3 最大池化层,步长2。后续卷积核5x5或3x3,步长2。通过较小参数提取有效特征。

导入系统库datetime、math、time,载入TensorFlow。

batch_size 32,num_batches 100,共测试100个batch数据。

定义网络结构显示函数print_actications,卷积层或池化层输出tensor尺寸。接受tensor输入,显示名称(t.op.name)、tensor尺寸(t.get_shape.as_list())。

网络结构。定义inference函数,接受images输入,返回最后一层pool5(第5个池化层)及parameters(模型参数)。多个卷积层、池化层。

第一卷积层conv1,TensorFlow name_scope,with tf.name_scope('conv1') as scope,scope内生成Variable自动命名为conv1/xxx,区分不同卷积层组件。定义第一卷积层,tf.truncated_normal截断正态分布函数(标准差0.1),初始化卷积核参数kernel。卷积核尺寸11x11,颜色通道3,卷积核64。tf.nn.conv2d卷积images,strides步长4x4(图片每4x4区域只取样一次,横向间隔4,纵向间隔4,取样卷积核尺寸11x11),padding模式SAME。卷积层biases全初始化0。tf.nn.bias_add,conv、biases加。用激活函数tf.nn.relu结果非线性。print_activations 打印最后输出tensor conv1结构。可训练参数kernel、biases添加parameters。

第一卷积层后添加LRN层、最大池化层。tf.nn.lrn LRN处理前面输出tensor conv1,depth_radius 4,bias 1,alpha 0.001/9,beta 0.75。其他经典卷积神经网络放充LRN。LRN让前馈、反馈速度下降到1/3。tf.nn.max_pool 最大池化处理前面输出lrn1,尺寸 3x3,3x3像素块降为1x1像素,取样步长2x2,padding模式VALID,取样不超过边框,不填充边界外点(SAME)。打印输出结果pool1结构。

第二卷积层,卷积核尺寸5x5,输入通道数 64(上一层输出通道数,上一层卷积核数量),卷积核192,步长1,扫描全图像素。

处理第二卷积层输出conv2,先LRN处理,再最大池化。

第三卷积层,卷积核尺寸3x3,输入通道数 192,卷积核 384,步长1。

第四卷积层,卷积核尺寸3x3,输入通道数 384,卷积核 256,步长1。

第五卷积层,卷积核尺寸3x3,输入通道数 256,卷积核 256,步长1。

最大池化层,返回池化层输出pool5。卷积结束。

3个全连接层,隐含节点4096、4096、1000,计算量很小。

评估AlexNet每轮计算时间函数time_tensorflow_run。第一输入TensorFlow Session,第二变量评测运算算子,第三变量测试名称。定义预热轮数num_steps_burn_in=10,给程序热身,头几轮迭代显存加载、cache命中问题跳过,10轮迭代后计算时间。记录总时间total_duration、平方和total_duration_squared,计算方差。

num_batches+num_steps_burn_in次迭代计算,time.time()记录时间,session.run(target)执行每次迭代。初始热身num_steps_burn_in次迭代后,每10轮迭代显示当前迭代时间。每轮total_duration、total_duration_squared累加。

循环结束,计算每轮耗时均值mn、标准差sd,显示结果。

主函数run_benchmark。with tf.Graph().as_default()定义默认Graph。tf.random_nomal函数构造正态颁上(标准差 0.1)随机tensor,第一维度batch_size,每轮迭代样本数,第二、三维度图片尺寸image_size 224,第四维度图片颜色通道数。inference函数构建整个AlexNet网络,最后池化层输出pool5,训练参数集合parameters。tf.Session()创建新Session,tf.global_variables_initializer()初始化所有参数。

AlexNet forward计算评测,time_tensorflow_run 统计运算时间,传入target pool5,卷积网络最后池化层输出。backward 训练过程评测,最后输出pool5设置优化目标loss。tf.nn.l2_loss计算,tf.gradients求loss所有模型参数梯度,模拟训练过程,根据梯度更新参数。time_tensorflow_run统计backward运算时间,target求整个网络梯度gard。

执行主函数。

程序显示三段结果。AlexNet网络结构、输出tensor尺寸。forward计算时间,有LRN层每轮迭代时间0.026s,去除LRN层0.007s,对最终准确率影响不大。backward运算时间,有LRN层每轮迭代时间0.078s,去除LRN层0.025s。backward运算耗时约forward三倍。

CNN训练过程(backward计算)比较耗时,过很多遍数据,大量迭代。CNN瓶劲在训练。TensorFlow已经支持iOS、Android,手机CPU做人脸识别、图片分类非常方便、响应速度很快。

传统机器学习模型适合学习小型数据集,大型数据集需要更大学习容量(Learning Capacity)模型,深度学习模型。卷积层参数量少,抽取特征能力非常强。

from datetime import datetime
    import math
    import time
    import tensorflow as tf
    batch_size=32
    num_batches=100
    def print_activations(t):
        print(t.op.name, ' ', t.get_shape().as_list())
    def inference(images):
        parameters = []
        # conv1
        with tf.name_scope('conv1') as scope:
            kernel = tf.Variable(tf.truncated_normal([11, 11, 3, 64], dtype=tf.float32,
                                                 stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(images, kernel, [1, 4, 4, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
                             trainable=True, name='biases')
            bias = tf.nn.bias_add(conv, biases)
            conv1 = tf.nn.relu(bias, name=scope)
            print_activations(conv1)
            parameters += [kernel, biases]
      # pool1
        lrn1 = tf.nn.lrn(conv1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='lrn1')
        pool1 = tf.nn.max_pool(lrn1,
                           ksize=[1, 3, 3, 1],
                           strides=[1, 2, 2, 1],
                           padding='VALID',
                           name='pool1')
        print_activations(pool1)
      # conv2
        with tf.name_scope('conv2') as scope:
            kernel = tf.Variable(tf.truncated_normal([5, 5, 64, 192], dtype=tf.float32,
                                                 stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(pool1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[192], dtype=tf.float32),
                             trainable=True, name='biases')
            bias = tf.nn.bias_add(conv, biases)
            conv2 = tf.nn.relu(bias, name=scope)
            parameters += [kernel, biases]
        print_activations(conv2)
      # pool2
        lrn2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='lrn2')
        pool2 = tf.nn.max_pool(lrn2,
                           ksize=[1, 3, 3, 1],
                           strides=[1, 2, 2, 1],
                           padding='VALID',
                           name='pool2')
        print_activations(pool2)
      # conv3
        with tf.name_scope('conv3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 192, 384],
                                                 dtype=tf.float32,
                                                 stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(pool2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[384], dtype=tf.float32),
                             trainable=True, name='biases')
            bias = tf.nn.bias_add(conv, biases)
            conv3 = tf.nn.relu(bias, name=scope)
            parameters += [kernel, biases]
            print_activations(conv3)
      # conv4
        with tf.name_scope('conv4') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 384, 256],
                                                 dtype=tf.float32,
                                                 stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(conv3, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                             trainable=True, name='biases')
            bias = tf.nn.bias_add(conv, biases)
            conv4 = tf.nn.relu(bias, name=scope)
            parameters += [kernel, biases]
            print_activations(conv4)
      # conv5
        with tf.name_scope('conv5') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256],
                                                 dtype=tf.float32,
                                                 stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(conv4, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                             trainable=True, name='biases')
            bias = tf.nn.bias_add(conv, biases)
            conv5 = tf.nn.relu(bias, name=scope)
            parameters += [kernel, biases]
            print_activations(conv5)
      # pool5
        pool5 = tf.nn.max_pool(conv5,
                           ksize=[1, 3, 3, 1],
                           strides=[1, 2, 2, 1],
                           padding='VALID',
                           name='pool5')
        print_activations(pool5)
        return pool5, parameters
    def time_tensorflow_run(session, target, info_string):
        num_steps_burn_in = 10
        total_duration = 0.0
        total_duration_squared = 0.0
        for i in range(num_batches + num_steps_burn_in):
            start_time = time.time()
            _ = session.run(target)
            duration = time.time() - start_time
            if i >= num_steps_burn_in:
                if not i % 10:
                    print ('%s: step %d, duration = %.3f' %
                       (datetime.now(), i - num_steps_burn_in, duration))
                total_duration += duration
                total_duration_squared += duration * duration
        mn = total_duration / num_batches
        vr = total_duration_squared / num_batches - mn * mn
        sd = math.sqrt(vr)
        print ('%s: %s across %d steps, %.3f +/- %.3f sec / batch' %
           (datetime.now(), info_string, num_batches, mn, sd))
    def run_benchmark():
        with tf.Graph().as_default():
            image_size = 224
            images = tf.Variable(tf.random_normal([batch_size,
                                           image_size,
                                           image_size, 3],
                                          dtype=tf.float32,
                                          stddev=1e-1))
            pool5, parameters = inference(images)
            init = tf.global_variables_initializer()
            config = tf.ConfigProto()
            config.gpu_options.allocator_type = 'BFC'
            sess = tf.Session(config=config)
            sess.run(init)
            time_tensorflow_run(sess, pool5, "Forward")
            objective = tf.nn.l2_loss(pool5)
            grad = tf.gradients(objective, parameters)
            time_tensorflow_run(sess, grad, "Forward-backward")
    run_benchmark()

参考资料:《TensorFlow实践》

欢迎付费咨询(150元每小时),我的微信:qingxingfengzi

相关推荐