精华内容
下载资源
问答
  • 一 实例描述使用全局平均池化层来代替传统的全连接层,使用了3个卷积层的同卷积操作,滤波器为5*5,每个卷积层后面都会跟个步长为2*2的池化层,滤波器为2*2。2层的卷积加池后是输出为10个通道卷积层,然后对这10个...
    一 实例描述
    使用全局平均池化层来代替传统的全连接层,使用了3个卷积层的同卷积操作,滤波器为5*5,每个卷积层后面都会跟个步长为2*2的池化层,滤波器为2*2。2层的卷积加池后是输出为10个通道卷积层,然后对这10个feature map进行全局平均池化,得到10个特征,再对这10个特征进行softmax计算,其结果来代表最终分类。
    通过一个带有全局平均池化层的卷积神经网络对CIFAR数据集分类。

    二 代码
    '''
    导入头文件引入数据集
    导入被切割后的24*24尺寸图片,每次取128个图片进行运算。
    '''
    import cifar10_input
    import tensorflow as tf
    import numpy as np
    batch_size = 128
    data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'
    print("begin")
    images_train, labels_train = cifar10_input.inputs(eval_data = False,data_dir = data_dir, batch_size = batch_size)
    images_test, labels_test = cifar10_input.inputs(eval_data = True, data_dir = data_dir, batch_size = batch_size)
    print("begin data")
    '''
    定义网络结构
    对于权重w的定义,统一使用函数truncated_normal生成标准差为0.1的随机数为其初始化。
    对于权重b的定义,统一初始化为0.1。
    '''
    def weight_variable(shape):
      initial = tf.truncated_normal(shape, stddev=0.1)
      return tf.Variable(initial)
    def bias_variable(shape):
      initial = tf.constant(0.1, shape=shape)
      return tf.Variable(initial)
    '''
    卷积操作的函数中,统一进行同卷积操作,即步长为1,padding='SAME'.
    '''
    def conv2d(x, W):
      return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
    '''
    池化层有两个函数
    一个是放在卷积后面,取最大值的方法,步长为2,padding='SAME',即将原尺寸的长和宽各除以2
    另外一个是用来放在最后一层,取均值的方法,步长为最终生成的特征尺寸6*6(24*24经过两次池化变成了6*6),filter也为6*6.
    倒数第二层没有最大池化的卷积层,因为共有10类,所有卷积输出的是10个通道,并使其全局平均池化为10个节点。
    '''
    def max_pool_2x2(x):
      return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                            strides=[1, 2, 2, 1], padding='SAME')  
                            
    def avg_pool_6x6(x):
      return tf.nn.avg_pool(x, ksize=[1, 6, 6, 1],
                            strides=[1, 6, 6, 1], padding='SAME')
    # tf Graph Input
    x = tf.placeholder(tf.float32, [None, 24,24,3]) # cifar data image of shape 24*24*3
    y = tf.placeholder(tf.float32, [None, 10]) # 0-9 数字=> 10 classes
    W_conv1 = weight_variable([5, 5, 3, 64])
    b_conv1 = bias_variable([64])
    x_image = tf.reshape(x, [-1,24,24,3])
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)
    W_conv2 = weight_variable([5, 5, 64, 64])
    b_conv2 = bias_variable([64])
    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)
    W_conv3 = weight_variable([5, 5, 64, 10])
    b_conv3 = bias_variable([10])
    h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3)
    nt_hpool3=avg_pool_6x6(h_conv3)#10
    nt_hpool3_flat = tf.reshape(nt_hpool3, [-1, 10])
    y_conv=tf.nn.softmax(nt_hpool3_flat)
    cross_entropy = -tf.reduce_sum(y*tf.log(y_conv))
    '''
    对于梯度优化算法,还是和多分类问题一样,使用AdamOptimizer函数,学习率为0.0001
    '''
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    '''
    运行session进行训练,启动session,迭代15000次数据集,这里记得要启动队列,同时读出来的label还要转成onehot编码
    '''
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    tf.train.start_queue_runners(sess=sess)
    for i in range(15000):#20000
      image_batch, label_batch = sess.run([images_train, labels_train])
      label_b = np.eye(10,dtype=float)[label_batch] #one hot
      
      train_step.run(feed_dict={x:image_batch, y: label_b},session=sess)
      
      if i%200 == 0:
        train_accuracy = accuracy.eval(feed_dict={
            x:image_batch, y: label_b},session=sess)
        print( "step %d, training accuracy %g"%(i, train_accuracy))
    '''
    评估结果
    从测试数据集里将数据取出,放到模型里运行,查看模型的正确率。
    '''
    image_batch, label_batch = sess.run([images_test, labels_test])
    label_b = np.eye(10,dtype=float)[label_batch]#one hot
    print ("finished! test accuracy %g"%accuracy.eval(feed_dict={
         x:image_batch, y: label_b},session=sess))
    三 运行结果
    begin
    begin data
    step 0, training accuracy 0.09375
    step 200, training accuracy 0.367188
    step 400, training accuracy 0.367188
    step 600, training accuracy 0.382812
    step 800, training accuracy 0.460938
    step 1000, training accuracy 0.492188
    step 1200, training accuracy 0.578125
    step 1400, training accuracy 0.53125
    step 1600, training accuracy 0.515625
    step 1800, training accuracy 0.445312
    step 2000, training accuracy 0.5625
    step 2200, training accuracy 0.570312
    step 2400, training accuracy 0.515625
    step 2600, training accuracy 0.554688
    step 2800, training accuracy 0.515625
    step 3000, training accuracy 0.539062
    step 3200, training accuracy 0.5
    step 3400, training accuracy 0.515625
    step 3600, training accuracy 0.539062
    step 3800, training accuracy 0.445312
    step 4000, training accuracy 0.554688
    step 4200, training accuracy 0.507812
    step 4400, training accuracy 0.5625
    step 4600, training accuracy 0.617188
    step 4800, training accuracy 0.65625
    step 5000, training accuracy 0.65625
    step 5200, training accuracy 0.578125
    step 5400, training accuracy 0.625
    step 5600, training accuracy 0.484375
    step 5800, training accuracy 0.59375
    step 6000, training accuracy 0.578125
    step 6200, training accuracy 0.6875
    step 6400, training accuracy 0.539062
    step 6600, training accuracy 0.609375
    step 6800, training accuracy 0.523438
    step 7000, training accuracy 0.640625
    step 7200, training accuracy 0.578125
    step 7400, training accuracy 0.640625
    step 7600, training accuracy 0.625
    step 7800, training accuracy 0.625
    step 8000, training accuracy 0.617188
    step 8200, training accuracy 0.570312
    step 8400, training accuracy 0.648438
    step 8600, training accuracy 0.601562
    step 8800, training accuracy 0.617188
    step 9000, training accuracy 0.609375
    step 9200, training accuracy 0.65625
    step 9400, training accuracy 0.625
    step 9600, training accuracy 0.703125
    step 9800, training accuracy 0.5625
    step 10000, training accuracy 0.617188
    step 10200, training accuracy 0.625
    step 10400, training accuracy 0.703125
    step 10600, training accuracy 0.625
    step 10800, training accuracy 0.617188
    step 11000, training accuracy 0.703125
    step 11200, training accuracy 0.648438
    step 11400, training accuracy 0.601562
    step 11600, training accuracy 0.585938
    step 11800, training accuracy 0.601562
    step 12000, training accuracy 0.65625
    step 12200, training accuracy 0.648438
    step 12400, training accuracy 0.648438
    step 12600, training accuracy 0.75
    step 12800, training accuracy 0.585938
    step 13000, training accuracy 0.703125
    step 13200, training accuracy 0.609375
    step 13400, training accuracy 0.671875
    step 13600, training accuracy 0.703125
    step 13800, training accuracy 0.648438
    step 14000, training accuracy 0.671875
    step 14200, training accuracy 0.640625
    step 14400, training accuracy 0.632812
    step 14600, training accuracy 0.679688
    step 14800, training accuracy 0.625
    finished! test accuracy 0.640625
    四 运行说明
    可以看出,识别效果得到了收敛,正确率在0.6左右,这个正确率不算很高,因为模型相对简单,只是用了两层的卷积操作。
    实例中对于卷积核池化的使用也表明了一种习惯,一般在卷积过程中都会设为步长为1的same卷积,即大小不变,需要降维时则是全部通过池化来完成的。

    展开全文
  • GAP全局平均池化层替代全连接

    千次阅读 2019-07-20 11:27:40
    下面的文章研究了GAP和全连接的区别,以及能否做到真正的全连接的研究 截取一部分说明下GAP的作用:  简单来说,就是在卷积层之后,用GAP替代FC全连接。有两个有点:一是GAP在特征图与最终的分类间转换更加...

    下面的文章研究了GAP和全连接层的区别,以及能否做到真正的全连接层的研究

    截取一部分说明下GAP的作用:
     简单来说,就是在卷积层之后,用GAP替代FC全连接层。有两个有点:一是GAP在特征图与最终的分类间转换更加简单自然;二是不像FC层需要大量训练调优的参数,降低了空间参数会使模型更加健壮,抗过拟合效果更佳。

    我们再用更直观的图像来看GAP的工作原理:

    在这里插入图片描述  假设卷积层的最后输出是h × w × d 的三维特征图,具体大小为6 × 6 × 3,经过GAP转换后,变成了大小为 1 × 1 × 3 的输出值,也就是每一层 h × w 会被平均化成一个值。

    https://www.cnblogs.com/hutao722/p/10008581.html

    展开全文
  • 全局平均池化,全局最大池化

    千次阅读 2018-12-24 17:51:22
    深度学习: global pooling (全局池化) Global average Pooling 论文出处:Network In Network 举个例子 假如,最后的一的数据是10个6*6的特征图,global average pooling是将每一张特征图计算所有像素点的...

    参考文献:

    深度学习: global pooling (全局池化)

    Global average Pooling

    论文出处:Network In Network

     

    举个例子

    假如,最后的一层的数据是10个6*6的特征图,global average pooling是将每一张特征图计算所有像素点的均值输出一个数据值

    这样10 个特征图就会输出10个数据点,将这些数据点组成一个1*10的向量的话,就成为一个特征向量,就可以送入到softmax的分类中计算了
     

    展开全文
  • 这里使用的数据集仍然是CIFAR-10,由于之前写过一篇使用AlexNet对CIFAR数据集进行分类的文章,已经详细介绍了这个数据集,...与MNIST类似,TensorFlow中也有一个下载和导入CIFAR数据集的代码文件,不同的是,自从...

    这里使用的数据集仍然是CIFAR-10,由于之前写过一篇使用AlexNet对CIFAR数据集进行分类的文章,已经详细介绍了这个数据集,当时我们是直接把这些图片的数据文件下载下来,然后使用pickle进行反序列化获取数据的,具体内容可以参考这里:第十六节,卷积神经网络之AlexNet网络实现(六)

    与MNIST类似,TensorFlow中也有一个下载和导入CIFAR数据集的代码文件,不同的是,自从TensorFlow1.0之后,将里面的Models模块分离了出来,分离和导入CIFAR数据集的代码在models中,所以要先去TensorFlow的GitHub网站将其下载下来。点击下载地址开始下载

    一 描述

    在该例子中,使用了全局平均池化层来代替传统的全连接层,使用了3个卷积层的同卷积网络,滤波器为5x5,每个卷积层后面跟有一个步长2x2的池化层,滤波器大小为2x2,最后一个池化层为全局平均池化层,输出后为batch_sizex1x1x10,我们对其进行形状变换为batch_sizex10,得到10个特征,再对这10个特征进行softmax计算,其结果代表最终分类。

    • 输入图片大小为24x24x3
    • 经过5x5的同卷积操作(步长为1),输出64个通道,得到24x24x64的输出
    • 经过f=2,s=2的池化层,得到大小为12x12x24的输出
    • 经过5x5的同卷积操作(步长为1),输出64个通道,得到12x12x64的输出
    • 经过f=2,s=2的池化层,得到大小为6x6x64的输出
    • 经过5x5的同卷积操作(步长为1),输出10个通道,得到6x6x10的输出
    • 经过一个全局平均池化层f=6,s=6,得到1x1x10的输出
    • 展开成1x10的形状,经过softmax函数计算,进行分类

    二 导入数据集

    '''
    一 引入数据集
    '''
    batch_size = 128
    learning_rate = 1e-4
    training_step = 15000
    display_step = 200
    #数据集目录
    data_dir = './cifar10_data/cifar-10-batches-bin'
    print('begin')
    #获取训练集数据
    images_train,labels_train = cifar10_input.inputs(eval_data=False,data_dir = data_dir,batch_size=batch_size)
    print('begin data')

    注意这里调用了cifar10_input.inputs()函数,这个函数是专门获取数据的函数,返回数据集合对应的标签,但是这个函数会将图片裁切好,由原来的32x32x3变成24x24x3,该函数默认使用测试数据集,如果使用训练数据集,可以将第一个参数传入eval_data=False。另外再将batch_size和dir传入,就可以得到dir下面的batch_size个数据了。我们可以查看一下这个函数的实现:

    def inputs(eval_data, data_dir, batch_size):
      """Construct input for CIFAR evaluation using the Reader ops.
    
      Args:
        eval_data: bool, indicating if one should use the train or eval data set.
        data_dir: Path to the CIFAR-10 data directory.
        batch_size: Number of images per batch.
    
      Returns:
        images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3] size.
        labels: Labels. 1D tensor of [batch_size] size.
      """
      if not eval_data:
        filenames = [os.path.join(data_dir, 'data_batch_%d.bin' % i)
                     for i in xrange(1, 6)]
        num_examples_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN
      else:
        filenames = [os.path.join(data_dir, 'test_batch.bin')]
        num_examples_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_EVAL
    
      for f in filenames:
        if not tf.gfile.Exists(f):
          raise ValueError('Failed to find file: ' + f)
    
      with tf.name_scope('input'):
        # Create a queue that produces the filenames to read.
        filename_queue = tf.train.string_input_producer(filenames)
    
        # Read examples from files in the filename queue.
        read_input = read_cifar10(filename_queue)
        reshaped_image = tf.cast(read_input.uint8image, tf.float32)
    
        height = IMAGE_SIZE
        width = IMAGE_SIZE
    
        # Image processing for evaluation.
        # Crop the central [height, width] of the image.
        resized_image = tf.image.resize_image_with_crop_or_pad(reshaped_image,
                                                               height, width)
    
        # Subtract off the mean and divide by the variance of the pixels.
        float_image = tf.image.per_image_standardization(resized_image)
    
        # Set the shapes of tensors.
        float_image.set_shape([height, width, 3])
        read_input.label.set_shape([1])
    
        # Ensure that the random shuffling has good mixing properties.
        min_fraction_of_examples_in_queue = 0.4
        min_queue_examples = int(num_examples_per_epoch *
                                 min_fraction_of_examples_in_queue)
    
      # Generate a batch of images and labels by building up a queue of examples.
      return _generate_image_and_label_batch(float_image, read_input.label,
                                             min_queue_examples, batch_size,
                                             shuffle=False)

     这个函数主要包含以下几步:

    • 读取测试集文件名或者训练集文件名,并创建文件名队列。
    • 使用文件读取器读取一张图像的数据和标签,并返回一个存放这些张量数据的类对象。
    • 对图像进行裁切处理。
    • 归一化输入。
    • 读取batch_size个图像和标签。(返回的是一个张量,必须要在会话中执行才能得到数据)

    三 定义网络结构

    '''
    二 定义网络结构
    '''
    def weight_variable(shape):
        '''
        初始化权重
        
        args:
            shape:权重shape
        '''
        initial = tf.truncated_normal(shape=shape,mean=0.0,stddev=0.1)
        return tf.Variable(initial)
    
    def bias_variable(shape):
        '''
        初始化偏置
        
        args:
            shape:偏置shape
        '''
        initial =tf.constant(0.1,shape=shape)
        return tf.Variable(initial)
    
    
    def conv2d(x,W):
        '''
        卷积运算 ,使用SAME填充方式   卷积层后
             out_height = in_hight / strides_height(向上取整)
             out_width = in_width / strides_width(向上取整)
        
        args:
            x:输入图像 形状为[batch,in_height,in_width,in_channels] 
            W:权重 形状为[filter_height,filter_width,in_channels,out_channels]        
        '''
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
    
    
    def max_pool_2x2(x):
        '''
        最大池化层,滤波器大小为2x2,'SAME'填充方式  池化层后
             out_height = in_hight / strides_height(向上取整)
             out_width = in_width / strides_width(向上取整)
        
        args:
            x:输入图像 形状为[batch,in_height,in_width,in_channels] 
        '''
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
        
    
    def avg_pool_6x6(x):
        '''
        全局平均池化层,使用一个与原有输入同样尺寸的filter进行池化,'SAME'填充方式  池化层后
             out_height = in_hight / strides_height(向上取整)
             out_width = in_width / strides_width(向上取整)
        
        args;
            x:输入图像 形状为[batch,in_height,in_width,in_channels] 
        '''
        return tf.nn.avg_pool(x,ksize=[1,6,6,1],strides=[1,6,6,1],padding='SAME')
    
    def print_op_shape(t):
        '''
        输出一个操作op节点的形状
        '''
        print(t.op.name,'',t.get_shape().as_list())
    
    
    #定义占位符
    input_x = tf.placeholder(dtype=tf.float32,shape=[None,24,24,3])   #图像大小24x24x
    input_y = tf.placeholder(dtype=tf.float32,shape=[None,10])        #0-9类别 
    
    x_image = tf.reshape(input_x,[-1,24,24,3])
    
    #1.卷积层 ->池化层
    W_conv1 = weight_variable([5,5,3,64])
    b_conv1 = bias_variable([64])
    
    
    h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)    #输出为[-1,24,24,64]
    print_op_shape(h_conv1)
    h_pool1 = max_pool_2x2(h_conv1)                            #输出为[-1,12,12,64]
    print_op_shape(h_pool1)
    
    
    #2.卷积层 ->池化层
    W_conv2 = weight_variable([5,5,64,64])
    b_conv2 = bias_variable([64])
    
    
    h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2) + b_conv2)    #输出为[-1,12,12,64]
    print_op_shape(h_conv2)
    h_pool2 = max_pool_2x2(h_conv2)                            #输出为[-1,6,6,64]
    print_op_shape(h_pool2)
    
    
    
    #3.卷积层 ->全局平均池化层
    W_conv3 = weight_variable([5,5,64,10])
    b_conv3 = bias_variable([10])
    
    h_conv3 = tf.nn.relu(conv2d(h_pool2,W_conv3) + b_conv3)   #输出为[-1,6,6,10]
    print_op_shape(h_conv3)
    
    nt_hpool3 = avg_pool_6x6(h_conv3)                         #输出为[-1,1,1,10]
    print_op_shape(nt_hpool3)
    nt_hpool3_flat = tf.reshape(nt_hpool3,[-1,10])            
    
    y_conv = tf.nn.softmax(nt_hpool3_flat)

     

    四 定义求解器

    '''
    三 定义求解器
    '''
    
    #softmax交叉熵代价函数
    cost = tf.reduce_mean(-tf.reduce_sum(input_y * tf.log(y_conv),axis=1))
    
    #求解器
    train = tf.train.AdamOptimizer(learning_rate).minimize(cost)
    
    #返回一个准确度的数据
    correct_prediction = tf.equal(tf.arg_max(y_conv,1),tf.arg_max(input_y,1))
    #准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,dtype=tf.float32))

    五 开始测试

    '''
    四 开始训练
    '''
    sess = tf.Session();
    sess.run(tf.global_variables_initializer())
    # 启动计算图中所有的队列线程 调用tf.train.start_queue_runners来将文件名填充到队列,否则read操作会被阻塞到文件名队列中有值为止。
    tf.train.start_queue_runners(sess=sess)
    
    for step in range(training_step):
        #获取batch_size大小数据集
        image_batch,label_batch = sess.run([images_train,labels_train])
        
        #one hot编码
        label_b = np.eye(10,dtype=np.float32)[label_batch]
        
        #开始训练
        train.run(feed_dict={input_x:image_batch,input_y:label_b},session=sess)
        
        if step % display_step == 0:
            train_accuracy = accuracy.eval(feed_dict={input_x:image_batch,input_y:label_b},session=sess)
            print('Step {0} tranining accuracy {1}'.format(step,train_accuracy))

     

     

    我们可以看到这个模型准确率接近70%,这主要是因为我们在图像预处理是进行了输入归一化处理,导致比我们在第十六节,卷积神经网络之AlexNet网络实现(六)文章中使用传统神经网络训练准确度52%要提高了不少,并且比AlexNet的60%高了一些(AlexNet我迭代的轮数比较少,因为太耗时)。 

    完整代码:

    # -*- coding: utf-8 -*-
    """
    Created on Thu May  3 12:29:16 2018
    
    @author: zy
    """
    
    '''
    建立一个带有全局平均池化层的卷积神经网络  并对CIFAR-10数据集进行分类
    1.使用3个卷积层的同卷积操作,滤波器大小为5x5,每个卷积层后面都会跟一个步长为2x2的池化层,滤波器大小为2x2
    2.对输出的10个feature map进行全局平均池化,得到10个特征
    3.对得到的10个特征进行softmax计算,得到分类
    '''
    
    import cifar10_input
    import tensorflow as tf
    import numpy as np
    
    
    '''
    一 引入数据集
    '''
    batch_size = 128
    learning_rate = 1e-4
    training_step = 15000
    display_step = 200
    #数据集目录
    data_dir = './cifar10_data/cifar-10-batches-bin'
    print('begin')
    #获取训练集数据
    images_train,labels_train = cifar10_input.inputs(eval_data=False,data_dir = data_dir,batch_size=batch_size)
    print('begin data')
    
    
    '''
    二 定义网络结构
    '''
    def weight_variable(shape):
        '''
        初始化权重
        
        args:
            shape:权重shape
        '''
        initial = tf.truncated_normal(shape=shape,mean=0.0,stddev=0.1)
        return tf.Variable(initial)
    
    def bias_variable(shape):
        '''
        初始化偏置
        
        args:
            shape:偏置shape
        '''
        initial =tf.constant(0.1,shape=shape)
        return tf.Variable(initial)
    
    
    def conv2d(x,W):
        '''
        卷积运算 ,使用SAME填充方式   池化层后
             out_height = in_hight / strides_height(向上取整)
             out_width = in_width / strides_width(向上取整)
        
        args:
            x:输入图像 形状为[batch,in_height,in_width,in_channels] 
            W:权重 形状为[filter_height,filter_width,in_channels,out_channels]        
        '''
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
    
    
    def max_pool_2x2(x):
        '''
        最大池化层,滤波器大小为2x2,'SAME'填充方式  池化层后
             out_height = in_hight / strides_height(向上取整)
             out_width = in_width / strides_width(向上取整)
        
        args:
            x:输入图像 形状为[batch,in_height,in_width,in_channels] 
        '''
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
        
    
    def avg_pool_6x6(x):
        '''
        全局平均池化层,使用一个与原有输入同样尺寸的filter进行池化,'SAME'填充方式  池化层后
             out_height = in_hight / strides_height(向上取整)
             out_width = in_width / strides_width(向上取整)
        
        args;
            x:输入图像 形状为[batch,in_height,in_width,in_channels] 
        '''
        return tf.nn.avg_pool(x,ksize=[1,6,6,1],strides=[1,6,6,1],padding='SAME')
    
    def print_op_shape(t):
        '''
        输出一个操作op节点的形状
        '''
        print(t.op.name,'',t.get_shape().as_list())
    
    
    #定义占位符
    input_x = tf.placeholder(dtype=tf.float32,shape=[None,24,24,3])   #图像大小24x24x
    input_y = tf.placeholder(dtype=tf.float32,shape=[None,10])        #0-9类别 
    
    x_image = tf.reshape(input_x,[-1,24,24,3])
    
    #1.卷积层 ->池化层
    W_conv1 = weight_variable([5,5,3,64])
    b_conv1 = bias_variable([64])
    
    
    h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)    #输出为[-1,24,24,64]
    print_op_shape(h_conv1)
    h_pool1 = max_pool_2x2(h_conv1)                            #输出为[-1,12,12,64]
    print_op_shape(h_pool1)
    
    
    #2.卷积层 ->池化层
    W_conv2 = weight_variable([5,5,64,64])
    b_conv2 = bias_variable([64])
    
    
    h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2) + b_conv2)    #输出为[-1,12,12,64]
    print_op_shape(h_conv2)
    h_pool2 = max_pool_2x2(h_conv2)                            #输出为[-1,6,6,64]
    print_op_shape(h_pool2)
    
    
    
    #3.卷积层 ->全局平均池化层
    W_conv3 = weight_variable([5,5,64,10])
    b_conv3 = bias_variable([10])
    
    h_conv3 = tf.nn.relu(conv2d(h_pool2,W_conv3) + b_conv3)   #输出为[-1,6,6,10]
    print_op_shape(h_conv3)
    
    nt_hpool3 = avg_pool_6x6(h_conv3)                         #输出为[-1,1,1,10]
    print_op_shape(nt_hpool3)
    nt_hpool3_flat = tf.reshape(nt_hpool3,[-1,10])            
    
    y_conv = tf.nn.softmax(nt_hpool3_flat)
    
    '''
    三 定义求解器
    '''
    
    #softmax交叉熵代价函数
    cost = tf.reduce_mean(-tf.reduce_sum(input_y * tf.log(y_conv),axis=1))
    
    #求解器
    train = tf.train.AdamOptimizer(learning_rate).minimize(cost)
    
    #返回一个准确度的数据
    correct_prediction = tf.equal(tf.arg_max(y_conv,1),tf.arg_max(input_y,1))
    #准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,dtype=tf.float32))
    
    
    '''
    四 开始训练
    '''
    sess = tf.Session();
    sess.run(tf.global_variables_initializer())
    tf.train.start_queue_runners(sess=sess)
    
    for step in range(training_step):
        image_batch,label_batch = sess.run([images_train,labels_train])
        label_b = np.eye(10,dtype=np.float32)[label_batch]
        
        train.run(feed_dict={input_x:image_batch,input_y:label_b},session=sess)
        
        if step % display_step == 0:
            train_accuracy = accuracy.eval(feed_dict={input_x:image_batch,input_y:label_b},session=sess)
            print('Step {0} tranining accuracy {1}'.format(step,train_accuracy))
    View Code

    转载于:https://www.cnblogs.com/zyly/p/8990125.html

    展开全文
  • 全局平均池化英文名为:global average pooling简称为GAP 其具体实现过程在原文 << Network In Network >> 中为: 可以看出其是将矩阵中的 [w,h] ,进行平均池化变为一个单元。也即进行Flattrn和FC。其...
  • 全局平均池化能否完美代替全连接? 参考链接:https://www.cnblogs.com/hutao722/p/10008581.html 一.什么是全局平均池化?    全局平均池化(GAP)通过池化操作把多维矩阵转化为特征向量,以顶替全连接(FC)。 ...
  • tensorflow 实现全局平均池化

    千次阅读 2020-09-18 22:50:29
    有两种方法 一方法,这里用的tf.nn。可以用tf.layers代替。 p05 = tf.nn.avg_pool2d(conv10,ksize=[1,conv10.get_shape().as_list()[1],conv10.get_shape().as_list()[1],1],strides=[1,1,1,1],padding=VALID',...
  • 参考博文: https://blog.csdn.net/u012426298/article/details/81813963 https://blog.csdn.net/oppo62258801/article/details/77930246
  • 假设最终分成10类,则最后卷积层应该包含10个滤波器(即输出10个特征图),然后按照全局池化平均定义,分别对每个特征图,累加所有像素值并求平均,最后得到10个数值,将这10个数值输入到softmax中,得到10个概率值...
  • If you want a global average pooling layer, you can usenn.AdaptiveAvgPool2d(1). In Keras you can just useGlobalAveragePooling2D. Pytorch官方文档: torch.nn.AdaptiveAvgPool2d(output_size)[SOURCE] ...
  • 1.ResNet直接使用stride=2的卷积做下采样,并且用global average pool替换了全连接。 GAP的真正意义是:对整个网路在结构上做正则化防止过拟合。但是值得我们注意的是,使用gap可能会造成收敛速度减慢。用一个...
  • AlexNet和VGG模型最后都是有三个全连接(FC),而Inception_v1用全局平均池化的方法代替全连接融合学到的深度特征,这种方法可以显著提升在小样本情况下模型的预测分类能力!只有一个分类的全连接(我是二...
  • 新人刚学神经网络没多久……还处于木工乱搞阶段 啥都想搞来试一试 最近因为新型肺炎在家没啥事做 第一次使用全局平均以及用1x1卷积代替全连接 在这里做个记录 重新实现了一下AlexNet,就当复习一遍了 顺便在AlexNet...
  • TensofFlow学习记录:全局均值池化

    千次阅读 2019-06-29 15:05:21
    全局均值池化就是在平均池化层中使用同等大小的过滤器将其特征保存下来。这种结构用来代替深层网络结构最后的全连接输出层。这个方法也是《Network In Network》论文中所论述的。 以下为《Network In Network》论文...
  • 1、全局平均池化 平均池化...
  • 然而,在复现经典网络架构的时候,比如Googlenet这种动不动几十上百的网络,这么写的话,代码量会很大,冗余。为此,tensorflow提供了tensorflow-slim实现卷积层。通过tensorflow-slim可以在一行中实现一个卷...
  • Caffe源代码池化层

    2018-08-02 16:20:15
    Caffe源代码池化层 池化层(PoolingLayer)在深度学习的结构中占很重要的一部分,其功能是缩小输入特征图的尺度,增大输出特征图的感受野,在有的网络中,通过全局池化层,将二维特征图变成一维特征向量。池化层...
  • 卷积层与池化层

    万次阅读 多人点赞 2018-08-04 16:08:16
    卷积神经网络(Convolutional Neural Layer, CNN),除了全连接层以外(有时候也不含全连接层,因为出现了Global average pooling),还包含了卷积层和池化层。卷积层用来提取特征,而池化层可以减少参数数量。 卷...
  • caffe详解之池化层

    千次阅读 2018-06-10 10:58:54
    池化层参数说明layer { name: "pool1" type: "Pooling" bottom: "conv1" top: "pool1" pooling_param { pool: MAX #池化方法,默认为MAX。目前可用的方法有MAX, AVE kernel...
  • Pytorch没有对全局平均(最大)池化单独封装为一。需要自己实现。下面有两种简单的实现方式。 使用torch.max_pool1d()定义一个网络。 使用nn.AdaptiveMaxPool1d(1)并设置输出维度是1 import torch import ...
  • 这篇文章主要介绍了 PyTorch 中的池化层、线性层和激活函数层。 池化层 池化的作用则体现在降采样:保留显著特征、降低特征维度,增大 kernel 的感受野。 另外一点值得注意:pooling 也可以提供一些旋转不变性。 ...
  • 池化层中的两种padding

    2020-04-16 20:15:00
    这里主要分析最大池化和平均池化两个函数,函数中padding参数设置和矩阵形状计算都与卷积一样,但需要注意的是: 当padding=‘SAME’,计算avg_pool时,每次的计算是除以图像被filter框出的非零元素的个数,而不是...
  • 本文主要为深度之眼pytorch训练营二期学习笔记,详细课程内容移步:深度之眼https://ai.deepshare.net/index 目录 背景知识 一:卷积及其运算 二:池化及其运算 ...池化层--nn.MaxPool2d Keras实现 One mo...
  • 池化层的目的主要是为了降低维度 1.池化层  结构框架 1.1max-pooling(最大池化层) 图中输入为卷积层1的输出,大小为4*24,对每个不重叠的2*2的区域进行降采样,步长为2。对于max-pooling,选出每个区域...
  • 池化层往往在卷积层后面,通过降采样来降低卷积层输出的特征向量,同时改善结果,不易出现过拟合。最常用的降采样方法有均值采样(取区域平均值作为降采样值)、最大值采样(取区域最大值作为降采样值)和随机采样...
  • 池化层(pooling)的反向传播是怎么实现的

    万次阅读 多人点赞 2018-04-19 12:56:04
    参考博客:https://blog.csdn.net/qq_21190081/article/details/72871704在看卷积神经网络的时候,突然想起来池化是会改变特征...Pooling池化操作的反向梯度传播CNN网络中另外一个不可导的环节就是Pooling池化操作,...
  • 代码以及图片均参考此书 目录CNN网络整体结构卷积层 CNN网络整体结构 CNN 的的连接顺序是“Convolution - ReLU - (Pooling)”(Pooling 有时会被省略)。还需要注意的是,在上的CNN中,靠近输出的中使用了...
  • 官方文档: ... ... VGG16架构 ...pooling池化层 ...通过“全局平均值global average pooling”的方法减少全连接的参数 )做加权和,将学到的“分布式特征表示”( 高度提纯的特征 )映射到样本标记空间。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,102
精华内容 2,040
关键字:

全局平均池化层代码