精华内容
下载资源
问答
  • 一、任务简介斯坦福CS231n关于卷积和池化课程2017CS231n 斯坦福李飞飞...三、任务作业 1、卷积与全连接的区别卷积层可以保全空间结构,对于32*32*3的输入图像,不是把它展成一个长的向量,而是三维数据输入,可以...

    一、任务简介

    斯坦福CS231n关于卷积和池化课程

    2017CS231n 斯坦福李飞飞计算机视觉识别_哔哩哔哩 (゜-゜)つロ 干杯~-bilibiliwww.bilibili.com
    bb64dbfa7f9ae9e9d6871902d7ef7364.png

    二、任务详情

    学习卷积核和池化,掌握特征图与参数量的计算方法,掌握卷积的计算方式。

    三、任务作业

    1、卷积与全连接的区别

    卷积层可以保全空间结构,对于32*32*3的输入图像,不是把它展成一个长的向量,而是三维数据输入,可以保持图片的结构

    2、Input =224X224X3 filter=5X5 pad=0 strides=2 卷积核深度是多少, 使用1个filter卷积得到特征图尺寸

    卷积核深度为3,要和输入图像的深度保持一致;

    得到的特征图尺寸:(224+0*2-5)/2+1 = 110.5,取110,

    最后尺寸大小为110*110*1

    3、使用10个filter 卷积得到特征图尺寸,并求此时的参数量是多少(不包含偏置)

    尺寸大小为:110*110*10.

    参数量大小为:5*5*3*10=750

    如果包含偏置的话:每一层5*5*3+1=76

    总共参数量:76*10 = 760

    4、1*1卷积的作用有哪些

    可以改变通道数的大小

    5、网络不同层学到的分别是什么特征(大概)

    浅层卷积学习到的是一些低阶的图像特征(比如边缘特征),中间层学习到一些更加复杂的图像特征(比如边角和斑点),后边层是更加丰富的特征 。

    6、池化层中最大池化和均值池化

    最大池化保留了纹理特征,平均池化保留整体的数据特征

    全局信息都有贡献时可以选择平均池化,在网络中一般在浅层使用最大池化过滤一些无用信息,在网络最后一般使用的是平均池化,因为网络深层的高级语义信息可以有助于分类器对类别进行分类。

    一般不在池化层做padding操作

    7、总结:

    (1)卷积之后输出图像尺寸:

    equation?tex=I_%7Bout%7D+%3D+%28I_%7Bin%7D%2B2%2AP-F%29%2FS%2B1

    equation?tex=I_%7Bin%7D : 输入图像大小

    P:padding的设置(即是否用0填充图像边界)

    F:卷积核大小

    S:步长

    若最后计算结果不为整数,比如9.5,卷积层向下取整(取9),池化层向上取整(取10)

    (2)参数量和计算量:

    计算量对应时间复杂度,参数量对应空间复杂度,计算量要看网络执行时间的长短,参数量要看占用显存的量

    1)卷积层参数量计算(带偏置):

    equation?tex=%EF%BC%88F%2AF%2AC_%7Bin%7D%EF%BC%89%2AC_%7Bout%7D%2BC_%7Bout%7D

    2)卷积层参数量计算(不带偏置):

    equation?tex=%EF%BC%88F%2AF%2AC_%7Bin%7D%EF%BC%89%2AC_%7Bout%7D

    equation?tex=C_%7Bin%7D 表示输入通道数量

    equation?tex=C_%7Bout%7D 表示输出通道数量

    3)卷积层的计算量(带偏置):

    equation?tex=%28C_%7Bin%7D%2AF%2AF%2B1%29%2A%28C_%7Bout%7D%2AI_%7Bout%7D%2AI_%7Bout%7D%29

    4)卷积层的计算量(不带偏置):

    equation?tex=%28C_%7Bin%7D%2AF%2AF%29%2A%28C_%7Bout%7D%2AI_%7Bout%7D%2AI_%7Bout%7D%29

    5)卷积层参数量和计算量的关系:

    计算量=参数量*(

    equation?tex=I_%7Bout%7D%2AI_%7Bout%7D

    6)全连接层参数量计算(带偏置):

    equation?tex=C_%7Bin%7D%2AC_%7Bout%7D%2BC_%7Bout%7D

    7)全连接层参数量计算(不带偏置):

    equation?tex=C_%7Bin%7D%2AC_%7Bout%7D

    全连接层的计算量和参数量相等

    展开全文
  • AlexNet和VGG模型最后都是有三个全连接层(FC),而Inception_v1用全局平均池化的方法代替全连接层融合学到的深度特征,这种方法可以显著提升在小样本情况下模型的预测分类能力!只有一个分类的全连接层(我是二...

    一、引发思考的实验与问题:

    在一个非常小的二分类样本集(样本总数目63,“10-crop”法数据增强10倍,样本为矩阵保存为图片),通过ALexNet模型和VGG模型做分类任务,无论怎么调超参数,留出法重复50次的实验情况大致都如图A所示,而用Inception_v1的效果可以达到如图B所示。我就很奇怪为什么效果会差别这么大?按道理就算inception_v1模型有多尺度(并联卷积层)的设计思想,准确率和AUC的值是会提升,但不会提升这么多,而且在训练集的效果差距也太大了。

                                  

    为了研究这个问题,我首先尝试了自己写的同一个读取数据显示结果的程序,确保自变量因素只有模型本身,而不是一些程序bug导致的。根据图A的结果,训练集的效果也比较差,所以我推断为模型欠拟合了,继而推测是模型不够复杂,无法拟合这种特殊的矩阵图片样本,于是我以VGG模型为基础,开始各种尝试增加模型的复杂度,如增加卷积层的数目、卷积核的个数、甚至卷积核的大小等等,但是收效甚微。

    这时,我不禁问我自己,难道真的就是卷积核并联的思想让模型的效果提升这么显著吗?我不信,于是开始了我的更仔细的对照试验——我把Inception_v1的模型的并联卷积层代码删掉,只保留每个并联卷积层中卷积核个数最多的层,形成串联的卷积层,这句话可能不太好理解,具体可以看下图的代码示例:图A是原始的并联卷积层代码,图B是删改后的卷积层代码,只保留了branch1这个分支,如示意图删除了三个并联的分支结构,只保留了一个分支结构,形成传统卷积神经网络(卷积、池化串联的这种结构)。这样就能看之前实验效果的显著提升是不是由并联卷积层导致的。

    实验结果:修改后模型的效果如下图所示,确实比Inception_v1模型有下降,但整体效果还是好于ALexNet、VGG模型,这说明之前带来显著影响的并不是前面的卷积层,而是后面的分类层

                                                             

    二、分析实验现象与思考

    重点来了!

    AlexNet和VGG模型最后都是有三个全连接层(FC),而Inception_v1用全局平均池化的方法代替全连接层融合学到的深度特征这种方法可以显著提升在小样本情况下模型的预测分类能力!只有一个分类的全连接层(我是二分类问题,所以只有2个神经元)。

    全连接层最大特点是参数爆炸!这里我们来复习一下卷积层和全连接层的参数计算:

    卷积层:假设输入这个卷积层的图像大小是224*224*3,这个卷积层的卷积核大小是3*3,步长为2,个数为64,记住卷积层的参数个数与输入图片的大小无关,计算公式——(卷积核高 * 卷积核宽 * 输入图片的通道数 + 1) * 卷积核个数  (+1是因为bias偏置的存在)

    所以这个卷积层的参数为 (3*3*3+1)* 64 = 1792

    全连接层: 计算公式——(上一层神经元个数 + 1) *  当前层神经元个数(+1同样是因为bias偏置的存在),举例说明,一张图片经过卷积层和池化层处理为7*7*256,输入的全连接层有512个神经元,这个全连接层的参数为:(7*7*256+1)*512=6423040;然后下一个全连接层的神经元个数为1024的话,下一个全连接层的参数为:(512+1)*1024=525312;

    初步思考结论:

    可以看出全连接层存在参数爆炸与冗余的情况,之前实验效果太差很有很可能是因为有3个全连接层的原因,我做了一个补充实验,把Inception_v1改为了3个全连接层,模型效果立刻显著下降,进一步证明了用全局平均池化减少全连接层的使用可以提升CNN的性能

    用全局池化和卷积层方法实现全连接层的好处在我之前的一篇博客有介绍https://blog.csdn.net/Amigo_1997/article/details/104491793

    复习:图像(feature map)经过卷积层的大小变化

    展开全文
  • 参考博文: https://blog.csdn.net/u012426298/article/details/81813963 https://blog.csdn.net/oppo62258801/article/details/77930246

    参考博文:

    https://blog.csdn.net/u012426298/article/details/81813963

    https://blog.csdn.net/oppo62258801/article/details/77930246
    https://www.jianshu.com/p/510072fc9c62

    展开全文
  • 新人刚学神经网络没多久……还处于木工乱搞阶段 啥都想搞来试一试 最近因为新型肺炎在家没啥事做 第一次使用全局平均以及用1x1卷积代替全连接层 在这里做个记录 重新实现了一下AlexNet,就当复习一遍了 顺便在AlexNet...

    新人刚学神经网络没多久……还处于木工乱搞阶段
    啥都想搞来试一试
    最近因为新型肺炎在家没啥事做
    第一次使用全局平均以及用1x1卷积代替全连接层
    在这里做个记录
    重新实现了一下AlexNet,就当复习一遍了
    顺便在AlexNet基础上加上了很多其他技术
    BN,GAP,ExponentialDecay,Warmup
    当然还了解到一切其他的比如可分离卷积,不过没有添加进去(不敢乱用)
    由于现在只能用几年前的笔记本跑,跑不出大网络,所以网络输入为128x128的
    为了节约内存,在数据增强部分再resize为128*128
    由于环境为jupyter,所以整个代码写在一起
    数据读取部分和可视化部分代码:
    代码接口仿照MNIST
    从MNIST测试好移到cifar10只需要mnist替换成cifar10,函数什么的都是一样的
    单线程,很慢,光是在数据处理上一个epoch就要耗费一两百秒
    等这个网络跑完我就去学多线程(间歇性凌云壮志)

    %matplotlib inline
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import os
    import time
    import pickle
    from sklearn.utils import shuffle
    from tensorflow.contrib.layers import xavier_initializer
    trained_model_path='D:\\log\\cifar-10-batches-py\\trained_model_path_AlexNet'
    data_path='D:\\log\\cifar-10-batches-py'
    name=["airplane","automobile","bird","cat","deer","dog","frog","horse","ship","truck"]
    def imshows(images,labels,index,amount):  #显示图片和对应标签,从index开始往后amount张
        fig=plt.gcf()
        fig.set_size_inches(10,20)
        for i in range(amount):
            title=name[np.argmax(labels[index+i])]  #onehot标签
            ax=plt.subplot(5,6,i+1)
            ax.set_title(title)
            ax.imshow(images[index+i])
        plt.show()
    class Batcher():     #数据分batch
        def __init__(self,images,labels,num_examples,is_enhance):
            self.tf_variables_init=False
            self.labels=labels[0:num_examples]
            self.images=images[0:num_examples]
            self.num_examples=num_examples
            self.batch_index=0
            self.enhance_graph=tf.Graph() #单独在另外一个计算图处理,实测不分开跑得巨慢无比)
            with self.enhance_graph.as_default():   #数据增强
                self.image=tf.placeholder(tf.float32)
                self.is_enhance=tf.constant(is_enhance,dtype=tf.bool)
                self.cropped=tf.random_crop(self.image,[24,24,3])
                self.flipped=tf.image.random_flip_left_right(self.cropped)
                self.flipped=tf.image.random_flip_up_down(self.flipped)
                self.brightness=tf.image.random_brightness(self.flipped,max_delta=0.3)
                self.contrast=tf.image.random_contrast(self.brightness,lower=0.7,upper=1.4)
                self.saturation=tf.image.random_saturation(self.contrast,lower=0.7,upper=1.4)
                self.result=tf.cond(self.is_enhance,lambda:self.saturation,lambda:self.cropped)
                self.reshape=tf.image.resize_images(self.result,[128,128])
                self.standardization=tf.image.per_image_standardization(self.reshape)
                
        def next_batch(self,batch_size,extra_original_images=True):
            images_list=np.zeros([batch_size,128,128,3])
            labels_list=np.zeros([batch_size,10])
            with tf.Session(graph=self.enhance_graph) as sess:
                for i in range(batch_size):
                    images_list[i]=sess.run(self.standardization,feed_dict={self.image:self.images[self.batch_index]})
                    labels_list[i][self.labels[self.batch_index]]=1
                    self.batch_index+=1
                    if self.batch_index==self.num_examples:
                        self.batch_index=0
                        self.images,self.labels=shuffle(self.images,self.labels)
            return images_list,labels_list
    class cifar10_reader():
        def __init__(self,data_path,num_examples_for_training=50000,num_examples_for_test=10000):
            self.data_path=data_path
            self.num_examples_for_training=num_examples_for_training
            self.num_examples_for_test=num_examples_for_test
            self.load_cifar10_data(self.data_path)
        def unpickle(self,filename):
            with open(filename,'rb') as file:
                dict=pickle.load(file,encoding="iso-8859-1")
            images=dict.get("data").reshape(10000,3,32,32).transpose(0,2,3,1)
            labels=np.array(dict.get("labels"))
            return images,labels
        def load_cifar10_data(self,data_path):
            images_list=[]
            labels_list=[]
            for i in range(5):
                filename=os.path.join(data_path,"data_batch_%d"%(i+1))
                print("extracting from "+filename)
                images,labels=self.unpickle(filename)
                images_list.append(images)
                labels_list.append(labels)
            xtrain,ytrain=np.concatenate(images_list),np.concatenate(labels_list)
            print("extracting from "+os.path.join(data_path,"test_batch"))
            xtest,ytest=self.unpickle(os.path.join(data_path,"test_batch"))
            self.train=Batcher(xtrain,ytrain,self.num_examples_for_training,is_enhance=True)
            self.test=Batcher(xtest,ytest,self.num_examples_for_test,is_enhance=False)
    cifar10=cifar10_reader(data_path,5000,5000) #可以读入一个子集
    
    

    学习率策略:指数衰减+预热

    tf.reset_default_graph()
    def exponential_decay_with_warmup(warmup_step,learning_rate_base,global_step,learning_rate_step,learning_rate_decay,staircase=False):
        warmup_step=tf.constant(warmup_step)
        linear_increase=learning_rate_base*tf.cast(global_step/warmup_step,tf.float32)
        exponential_decay=tf.train.exponential_decay(learning_rate_base,
                                                                      global_step-warmup_step,
                                                                      learning_rate_step,
                                                                      learning_rate_decay,
                                                                      staircase=staircase)
        learning_rate=tf.cond(global_step<=warmup_step,lambda:linear_increase,lambda:exponential_decay)
        return learning_rate
    

    网络结构:

    class CNN():
        def __init__(self,drop_rate=0.0,is_training=False,regularizer=None,regularizer_name='losses',average_class=None):
            self.layer_index=1
            self.drop_rate=drop_rate
            self.is_training=is_training
            self.Rname=regularizer_name
            if regularizer is None:
                self.regularizer=None
            else:
                self.regularizer=regularizer
            if average_class is None:
                self.ema=None
            else:
                self.ema=average_class.apply
        def Xavier(self): #for Conv
            return tf.contrib.layers.xavier_initializer()
        def MSRA(self,shape): #for FC
            if len(shape)==2:
                return tf.truncated_normal_initializer(stddev=2/shape[1])
            else:
                return tf.truncated_normal_initializer(stddev=2/(shape[0]*shape[1]*shape[2]))
        def Relu(self,tensor):
            with tf.variable_scope("L%d_Relu"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
                return tf.nn.relu(tensor)
        def Conv2d(self,tensor,output_channel,ksize,strides,padding="VALID"):
            with tf.variable_scope("L%d_Conv2d"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
                input_channel=tensor.shape.as_list()[-1]
                kernel_shape=[ksize,ksize,input_channel,output_channel]
                kernel=tf.get_variable("kernel",kernel_shape,initializer=self.Xavier())
                conv2d=tf.nn.conv2d(tensor,kernel,strides=[1,strides,strides,1],padding=padding)
                bias=tf.get_variable("bias",[output_channel],initializer=tf.constant_initializer(0.0))
                bias_add=tf.nn.bias_add(conv2d,bias)
                return bias_add
        def MaxPooling2d(self,tensor,ksize,strides,padding="VALID"):
            with tf.variable_scope("L%d_MaxPooling2d"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
                return tf.nn.max_pool(tensor,ksize=[1,ksize,ksize,1],strides=[1,strides,strides,1],padding=padding)
        def BatchNormalization(self,tensor):
            with tf.variable_scope("L%d_BatchNorm"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
                return tf.layers.batch_normalization(tensor,training=self.is_training)
        def Dropout(self,tensor,drop_rate):
            with tf.variable_scope("L%d_Dropout"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
            return tf.layers.dropout(tensor,drop_rate,training=self.is_training)
        def GlobalAvgPooling2d(self,tensor):
            with tf.variable_scope("L%d_GlobalAvgPooling2d"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
                tensor_shape=tensor.shape.as_list()
                ksize=[1,tensor_shape[1],tensor_shape[2],1]
                gap=tf.nn.avg_pool(tensor,ksize=ksize,strides=[1,1,1,1],padding="VALID")
                return tf.reshape(gap,[-1,tensor_shape[-1]])
        def FullCon(self,tensor,output_dim):
            with tf.variable_scope("L%d_FullCon"%self.layer_index,reuse=tf.AUTO_REUSE):
                self.layer_index+=1
                input_dim=tensor.shape.as_list()[-1]
                weight=tf.get_variable("weight",[input_dim,output_dim],initializer=self.MSRA([input_dim,output_dim]))
                bias=tf.get_variable("bias",[output_dim],initializer=tf.constant_initializer(0.01))
                if self.regularizer:
                    tf.add_to_collection(self.Rname,regularizer(weight))
                if self.ema and self.is_training==0:
    
                    return tf.matnul(tensor,self.ema(weight))+self.ema(bias)
                else:
                    return tf.matmul(tensor,weight)+bias
        def AlexNet(self,tensor):
            conv=self.Conv2d(tensor,output_channel=96,ksize=11,strides=4,padding="VALID")
            BN=self.BatchNormalization(conv)
            relu=self.Relu(BN)
            pool=self.MaxPooling2d(relu,ksize=3,strides=2,padding="VALID")
            
            conv=self.Conv2d(pool,output_channel=256,ksize=5,strides=1,padding="SAME")
            BN=self.BatchNormalization(conv)
            relu=self.Relu(BN)
            pool=self.MaxPooling2d(relu,ksize=3,strides=2,padding="VALID")
            
            conv=self.Conv2d(pool,output_channel=384,ksize=3,strides=1,padding="SAME")
            BN=self.BatchNormalization(conv)
            relu=self.Relu(BN)
            
            conv=self.Conv2d(relu,output_channel=384,ksize=3,strides=1,padding="SAME")
            BN=self.BatchNormalization(conv)
            relu=self.Relu(BN)
            
            conv=self.Conv2d(relu,output_channel=256,ksize=3,strides=1,padding="SAME")
            BN=self.BatchNormalization(conv)
            relu=self.Relu(BN)
            pool=self.MaxPooling2d(relu,ksize=3,strides=2,padding="VALID")
            
            Global_avg_pool=self.GlobalAvgPooling2d(pool)
            
            full=self.FullCon(Global_avg_pool,512)
            BN=self.BatchNormalization(full)
            relu=self.Relu(BN)
            dropout=self.Dropout(relu,drop_rate=self.drop_rate)
            
            full=self.FullCon(dropout,256)
            BN=self.BatchNormalization(full)
            relu=self.Relu(BN)
            dropout=self.Dropout(relu,drop_rate=self.drop_rate)
            
            full=self.FullCon(dropout,10)
            return full
    

    然后是一些超参数,以及优化器,损失函数等等

    x=tf.placeholder(tf.float32,[None,128,128,3])
    y=tf.placeholder(tf.float32,[None,10])
    is_training=tf.placeholder(tf.bool)
    train_epoches=85
    batch_size=64
    batch_num=int(cifar10.train.num_examples/batch_size)
    #预热的指数衰减学习率
    global_step=tf.Variable(0,trainable=False)
    warmup_step=batch_num*3
    learning_rate_base=0.015
    learning_rate_decay=0.95
    learning_rate_step=batch_num
    learning_rate=exponential_decay_with_warmup(warmup_step,learning_rate_base,global_step,learning_rate_step,learning_rate_decay)
    #滑动平均
    ema_decay=0.999
    ema=tf.train.ExponentialMovingAverage(ema_decay,global_step)
    ema_op=ema.apply(tf.trainable_variables())
    #正则化和前向预测
    regularizer=tf.contrib.layers.l2_regularizer(0.004)
    forward=CNN(drop_rate=0.25,is_training=is_training,regularizer=regularizer).AlexNet(x)
    prediction=tf.nn.softmax(forward)
    correct_prediction=tf.equal(tf.argmax(prediction,1),tf.argmax(y,1))
    accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    #损失函数和优化器
    momentum=0.9
    cross_entropy=tf.losses.softmax_cross_entropy(onehot_labels=y,logits=forward,label_smoothing=0.01)
    l2_regularizer_loss=tf.add_n(tf.get_collection("losses"))
    loss_function=cross_entropy+l2_regularizer_loss
    update_ops=tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    with tf.control_dependencies(update_ops):
        optimizer=tf.train.MomentumOptimizer(learning_rate,momentum).minimize(loss_function,global_step=global_step)
    #模型可持久化
    if not os.path.exists(trained_model_path):
        os.makedirs(trained_model_path)
    saver=tf.train.Saver(tf.global_variables())
    

    开始进行训练:

    acc_Xavier_list=[0.0]
    loss_Xavier_list=[0.0]
    step=0
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        trained_model_state=tf.train.get_checkpoint_state(trained_model_path)
        if trained_model_state and trained_model_state.model_checkpoint_path:
            saver.restore(sess,trained_model_state.model_checkpoint_path)
        start_time=time.time()
        print("training start!")
        for epoch in range(0,train_epoches):
            for batch in range(batch_num):
                xs,ys=cifar10.train.next_batch(batch_size)
                sess.run([optimizer,ema_op],feed_dict={x:xs,y:ys,is_training:True})
                if batch %100==0:
                    xs,ys=cifar10.test.next_batch(100)
                    loss,acc=sess.run([loss_function,accuracy],feed_dict={x:xs,y:ys,is_training:False})
                    decay=min(0.96,(1+step)/(10+step))
                    acc_Xavier_list.append(decay*acc_MSRA_list[-1]+(1-decay)*acc)
                    loss_Xavier_list.append(decay*loss_MSRA_list[-1]+(1-decay*loss))
                    step+=1
            print("Epoch:%d Speed:%.2f seconds per epoch -> Accuracy:%.3f  Loss:%.3f"%(epoch+1,(time.time()-start_time)/(1+epoch),acc,loss))
            print("learning rate:%.7f "%(sess.run(learning_rate)))
            saver.save(sess,os.path.join(trained_model_path,"trained_model_%d"%(epoch+1)))
            print("model_%d saved"%(epoch+1))
        print("training finished after %.2f seconds"%(time.time()-start_time))
    

    因为损失和准确率很不稳,为了便于得到平滑曲线直观比较,采用滑动平均来进行计算
    在这里插入图片描述
    之前在卷积自编码器上测试过Xavier MSRA HE三种初始化策略的好坏
    此次实验也用5000+1000的小规模数据测试了MSRA和Xavier两种初始化方式对网络训练的影响
    总共85Epoch,峰值的时候竟然也有68%的准确率
    我刚开始照着书上的写在没有数据增强的情况下也差不多68%(实际上写了,只不过写错了,导致并没有数据增强,我就说书上怎么随便泡泡就73%+了)
    在训练过程中中断,微调参数后继续训练,这样能达到71%
    当然在数据增强后能达到86%了hhh
    这次使用全局平均池化+两个小的全连接层,效果看起来挺好,起码5000的训练集大小都能68%+
    当然……前面也说了,忘了准确率很不稳定,可能和我测试集图片也随机剪裁有关,滑动平均的结果来看也是能突破60%的
    至于结果
    首先是预处理上两种方式(暂时测试两组,有空试试其他组合)
    卷积层Xavier+全连接层MSRA
    卷积层MSRA+全连接层MSRA
    取了前面80个Epoch的数据
    在这里插入图片描述
    显然初始化对网络收敛影响是比较大的,对准确率的影响这里并没有体现
    最终采用Xavier对网络进行初始化
    现在50000+10000进行最终训练
    由于中途电脑过热给关掉了…
    所以运行时间的统计出了点点问题
    不过电脑配置本来也差(7200U+940mx)
    在这里插入图片描述
    最高的时候达到了86.6%
    最后几个epoch数据:
    在这里插入图片描述
    由于波动比较大,所以采用了滑动平均的数据来绘制曲线
    在这里插入图片描述
    从这个趋势上来看似乎没有收敛
    另外
    在测试集上我又运行了一遍

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        trained_model_state=tf.train.get_checkpoint_state(trained_model_path)
        if trained_model_state and trained_model_state.model_checkpoint_path:
            saver.restore(sess,trained_model_state.model_checkpoint_path)
        xs,ys=cifar10.train.next_batch(500)
        print(sess.run(accuracy,feed_dict={x:xs,y:ys,is_training:False}))
    

    在这里插入图片描述
    看起来过拟合了
    这么说通过更加合理的参数,准确率应该是可以进一步提高的
    不过现在限于硬件水平暂时搁置一下了,等开学去机房看看能跑到多少

    展开全文
  • GAP(全局平均池化层)操作

    千次阅读 2020-09-15 22:30:48
    转载的文章链接: 为什么使用全局平均池化层? 关于 global average pooling ... 在卷积神经网络的初期,...之后,有大牛在NIN(Network in Network)论文中提到了使用全局平局池化代替全连接层的思路,以下是摘录的一.
  • 全局平均池化

    千次阅读 2019-07-12 10:15:04
    全局平均池化是在论文Network in Network中提出的,原文中全局平均池化的作用和...作用:代替全连接层,可接受任意尺寸的图像 优点:1)可以更好的将类别与最后一个卷积层的特征图对应起来(每一个通道对应一种...
  • 一 实例描述使用全局平均池化层来代替传统的全连接层,使用了3个卷积层的同卷积操作,滤波器为5*5,每个卷积层后面都会跟个步长为2*2的池化层,滤波器为2*2。2层的卷积加池后是输出为10个通道卷积层,然后对这10个...
  • 关于全局平均池化的理解

    千次阅读 2019-01-16 17:18:43
    1、全局平均池化 平均池化:在feature map上以窗口的形式进行滑动(类似卷积的窗口滑动),操作为取窗口内的最大值作为结果,经过操作...《NIN》:使用全局平均池化代替CNN中传统的全连接层。在使用卷积层的识别任务...
  • TensofFlow学习记录:全局均值池化

    千次阅读 2019-06-29 15:05:21
    全局均值池化就是在平均池化层中使用同等大小的过滤器将其特征保存下来。这种结构用来代替深层网络结构最后的全连接输出层。...对于分类任务,最后一个卷积层得到的特征图被向量化然后送入全连接层,接一个softm...
  • 原本CNN网络的经典结构是: 卷积层——>池化层——>……——>全连接层FCN的出现为什么要把CNN网络最后的全连接层特换为卷积层?或者换句话说这样会带来什么好处呢?...2. 然后,究竟使用卷积层代替全连接层会带来什
  • 理解全连接层与GAP

    2020-10-20 17:24:07
    所以现在会用一种GAP(全局平均池化)来代替全连接层。 GAP就是让一个H×W×C的输入变成一个1×1×C的输出,每个输出都是该层的像素的平均值。 假设卷积层的最后输出是h × w × d 的三维特征图,具体大小为6 × 6 ...
  • 复习笔记

    2018-11-24 16:13:58
    使用全局平均池化代替全连接层: 17年很多论文支出:GAP(Global Average Pooling)代替FC(全连接)。 思想就是:用 feature map 直接表示属于某个类的 confidence map,比如有10个类,就在最后输出10个 feature ...
  • network in network

    2021-01-20 12:07:45
    1、mlp convolution local patch 只采取传统卷积操作,属于线性操作,无法提取出非线性特征。多层感知机可拟合复杂函数。因此,将local patch提取的特征接入到多层感知机中,以提取出该...可以代替全连接层,正是由于l
  • 文章目录1、论文总述2、不加激活函数的CNN如何补偿非线性3、全局平均池化代替全连接层的优势4、dropout很重要5、Global Average Pooling比全连接好么6、feature map可视化参考文献 1、论文总述 笔者最近毕业论文写完...
  • Global Average Pooling

    2019-12-11 22:31:58
    大牛在NIN(Network in Network)论文中提到了使用全局平局池化代替全连接层的思路,以下是摘录的一部分资料: global average poolilng。既然全连接网络可以使feature map的维度减少,进而输入到softmax,但是又...
  • 我的实现中用全局平均池化代替第一层全连接层,第二三层全连接用1x1卷积来代替 每组卷积之后添加BN层,并且卷积通道数量大致为原网络的1/4左右(训练真的太慢了……不相等) 初始化使用Xavier方法 训练时将cif...
  • 代替全连接层。 2.dropout只可能在box分支的两个全连接层那里,这个可以后期finetuning下。全连接网络可以使feature map的维度减少,进而输入到softmax,但是又会造成过拟合,可以用pooling来代替全连接。那就解决...
  • FC和GAP的区别

    2020-04-26 09:48:38
    全连接层有一个非常致命的弱点就是参数量过大,特别是与最后一个卷积层相连的全连接层。比如,第一个全连接层FC1有4096个节点,上一层feature map是7X7X512 = 25088个节点,则该传输需要4096*25088个权值,需要耗很...
  • 对所有的feature map使用global average pooling(全局均值池化代替传统CNN中的全连接层。有助于描述输出类的特征和降低过拟合。 提出问题 1. 传统的卷积神经网络一般来说是由:线性卷积层、池化层、全连接层堆叠...
  • 0.写在前面: ...一切为了速度。纯pyotrch代码干货,无理论,理论自己去查吧一堆堆的,代码可...多说一句,这个所谓比alexnet轻量,去掉全连接层才是参数下降的大头,用了个全局池化。 代码:直接可用,这个代码实...
  • (一)DCGAN实战

    2020-07-17 19:07:44
    取消全连接层,用全局平均池化代替(在判别器的最后一层) 所有层的输出都用BatchNormalization做归一化 生成器使用转置卷积层,激活函数使用ReLU函数,但最后一层输出层使用Tanh激活函数;判别器使用卷积层,激活...
  • Inception 模型

    2018-12-25 11:05:00
    inception v1:去除了最后的全连接层,使用全局平均池化层来代替,因为全连接层的参数很多,基本上占据了百分之九十的参数,而且全连接层会带来过拟合的问题。采用了inception module。Hebbian 原理:神经反射活动的...
  • DCGAN和CGAN的解读和学习1.DCGAN网络结构一些的DCGAN结构指南训练的一些细节:代码实现:...其次是再卷积层特征上消除全连接层的趋势,全局池化就是一个最好的例子。 第三是采用了BatchNormalization,这个通过将输入

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
热门标签
关键字:

全局池化代替全连接层