【百度技术学院机器学习训练营第二期】-实验作业
liushuo008 发布于2019-11 浏览:13058 回复:65
15
收藏
最后编辑于2019-11

【学习有礼】百度技术学院机器学习训练营第二期作业:

进入训练营实验班级,完成班级作业:猫狗分类实验,并在评论区回答以下问题:

1、网络结构:计算每层网络结构和输入输出尺寸和参数个数。不加BN?更深?每层的尺寸变化?更多结构?

2、尝试不同的Loss函数和优化算法(SGD、Momentum、Adagrad、Adam),观察效果的变化,最好的选择是什么?为什么?

3、尝试不同的样本数量:随着每个类别样本数量由少变多,模型准确率变化的曲线是怎样的?每个类别至少有多少张图片可支撑一个准确率尚可的模型? 使用图像分类模型识别世界的万事万物是否可行?(自己编写数据读取程序,而不用默认函数;先完成同学可以在班级群内推送代码,供同学们参考)

4、使用模型实践:拍一些身边宠物狗的照片(或网上找),处理成32*32尺寸后试试模型效果,准或不准的原因是什么?

5、【挑战题,可选】VGGNet,ResNet如何搭建?在预测效果和训练时间上有怎样的差异?原因是什么? (飞桨官网上有参考代码,但不建议马上看)

 

作业提交截止时间及形式:

截止11月18日中午12点前,跟帖回答作业问题。在跟帖开头请注明:训练营班级+群内昵称(或姓名)以便发送奖励。

 

奖励:

截止11月18日中午12点前,参加【百度技术学院机器学习训练营第二期】并回答作业的同学

1、评论点赞前3名的同学分别获得训练营礼包一份(小度音箱Play1个+机械键盘1个)

2、评论点赞第4-5名同学分别获得机械键盘1个

3、老师点评作业,获得优秀作业同学分别获得双肩背包1个

4、评论有奖:按照评论时间从早到晚的顺序,将抽取第5、10、15、20、25、30、35、40、45、50层同学分别获得招财熊1个。

 

注意:

1、评论点赞前5名要求是回答作业的问题,无关话语不做点赞奖励的计算。

2、如果点赞排名有并列情况,则按照发布时间先后顺序为准,时间早的优先。

3、此奖励仅限训练营同学享有。

收藏
点赞
15
个赞
共65条回复 最后由anfangfei回复于2019-11
#46windly4548回复于2019-11

0
#45windly4548回复于2019-11

0
#44windly4548回复于2019-11

0
#43windly4548回复于2019-11

0
#42wuweisn回复于2019-11

01班-wuweisn

1 网络结构

第一卷积池化层:输入 [3,32,32],  卷积输出[20, 28, 28], 池化层输出[20, 14, 14]

第二卷积池化层:输入 [20, 14, 14],  卷积输出[50, 10, 10], 池化层输出[50, 5, 5]

第三卷积池化层:输入 [50, 5, 5],  卷积输出[50, 1, 1], 池化层输出[50, 1, 1]

全连接输出层:输入[]50, 1, 1], 输出[10]

BN:加快收敛,避免过拟合

复杂合理的结构可以提高准确率,但是不要太复杂,以免过拟合

2 分类采用交叉熵(cross entropy,回归采用平方误差损失(squared error loss)

李老师推荐的模型

SGD                    cost:0.88786                          acc:0.69473               learning rate: 0.001

Momentum         cost:1.41415                         acc:0.72275               learning rate: 0.001

Adagrad               cost:0.85922                         acc:0.72979               learning rate: 0.001

Adam                   cost:1.47042                          acc:0.78799               learning rate: 0.001

                            cost:1.43113                          acc:0.73320               learning rate: 0.0001

原来的模型

Adam                   cost:1.02159                         acc:0.67334               learning rate: 0.001

                            cost:1.02350                          acc:0.65439               learning rate: 0.0001

 

模型对准确率的影响是最主要的,学习率,优化算法对模型都有影响。该例子中,最好的选择是Adam

3 随着样本的增加,模型准确率随之提高。每个分类至少有500+样本,可以获取不错的准确值。

4 测试的结果不满意,原因可能是测试图片样本尺寸太小,图片中特征量缺失。而拍摄的图片或下载的图片缩小后失真,造成预测失败。

 

 

 

0
#41187******93回复于2019-11
#40 zyxxxxyyfusb回复
01班-郑杨 1、网络结构:计算每层网络结构和输入输出尺寸和参数个数。不加BN?更深?每层的尺寸变化?更多结构? 1)输入层:imag 输出尺寸:(-1,3,32,32),-1是占位符,用于处理动态的samlpe数量,(3,32,32)是每个sample的size,3表示输入图像的通道数是3,32分别是图片的weight size和hight size。 2)第一个卷积池化层:conv_pool_1 网络结构:在卷积阶段,filter采用size是5*5,计算的时候跟图片的w(weight size)和h(hight size)对应;filter数量20,表示采用了20个通道;在池化阶段,池化核size是2*2,同样在计算的时候跟图片的w(weight size)和h(hight size)对应;池化步长为2,表示每个池化操作像w和h方向分别移动2个单位;最后激活函数采用输入relu。 输入尺寸:(128,3,32,32),128表示sample数(在BATCH_SIZE中设置),(3,32,32)是每个sample的size。 输出尺寸:(128,20,14,14) 参数个数:20 * 3 * 5 *5 3)第二个卷积池化层: 网络结构:在卷积阶段,filter采用size是5*5,计算的时候跟图片的w(weight size)和h(hight size)对应;filter数量50,表示采用了50个通道;在池化阶段,池化核size是2*2,同样在计算的时候跟图片的w(weight size)和h(hight size)对应;池化步长为2,表示每个池化操作像w和h方向分别移动2个单位;最后激活函数采用输入relu。 输入尺寸:(128,20,14,14),含义同第一层。 输出尺寸:(128,50,5,5) 参数个数:50 * 20 * 5 *5 4)第三个卷积池化层: 网络结构:同第二层。 输入尺寸:(128,50,5,5),含义同第二层 输出尺寸:(128,50,1,1) 参数个数:50 * 50 * 5 *5 4)全连接输出层: 网络结果:全链接网络 输入尺寸:(128,50,1,1),含义同第三层 输出尺寸:(128,10) 参数个数:50 * 10 2、尝试不同的Loss函数和优化算法(SGD、Momentum、Adagrad、Adam),观察效果的变化,最好的选择是什么?为什么? 1)不同优化算法在学习率设置一样(0.001)的情况下: SGD:loss收敛到1.2-1.5,acc到0.5 Moment:loss收敛到1.2-1.5,acc到0.5 Adagrad:loss收敛到1.4-1.5,acc到0.5 Adam:loss收敛到1.2-1.3,acc到0.5+ 在猫狗分类实验中,Adam效果最好。Adam中和了其他几种优化算法的优点,在训练过程中,每个参数有不同的学习率和Momentum,提升了模型训练的稳定性。 不同的场景下(学习任务、数据分布等)可能适应不同优化算法,在工程中选择哪种优化算法,可以经过调参进行实验。 2)不同的loss函数:分类问题一般使用cross_entropy 3、尝试不同的样本数量:随着每个类别样本数量由少变多,模型准确率变化的曲线是怎样的?每个类别至少有多少张图片可支撑一个准确率尚可的模型? 使用图像分类模型识别世界的万事万物是否可行?(自己编写数据读取程序,而不用默认函数;先完成同学可以在班级群内推送代码,供同学们参考) 1) 随着每个类别样本数量由少变多,模型准确率一般会更高。 每个类别至少有多少张图片可支撑一个准确率尚可的模型:数据量、数据质量、数据的分布、对真实场景的模拟程度等都是影响模型准确率的重要因素。对于比较简单的场景,比如图片中已经有比较清楚的动物脸部,所需数据量不用太大就能达到较好的效果;对应复杂的场景,比如图片中融入了大量的干扰信息,所需数据则需要较多。 2) 简单的读取自定义的数据的示例程序:   def data_generator(image_files_list, batch_size, shuffle=True):     """     数据生成器,生成batch数据     image_files_list:列表,每个元素包含图片文本的地址以及图片的类型     batch_size:batch大小     shuffle:是否shuffle,默认True     """     def reader():         if shuffle:             np.random.shuffle(image_files_list)         batch_out = []         for item in image_files_list:             image_file_path = item[0]  #图片所在地址             image_label = item[1]  #图片类别                      image = load_images(image_file_path)  #调用load_images,从image_file_path中加载图片             batch_out.append([image, image_label])             if len(batch_out) == batch_size:                 yield batch_out                 batch_out = []     return reader #训练数据示例 train_image_files_list = [     ["/home/aistudio/Cat1.jpg", 0],     ["/home/aistudio/Cat2.jpg", 0],     ["/home/aistudio/dog1.jpg", 1],     ["/home/aistudio/dog2.jpg", 1],     ["/home/aistudio/dog3.jpg", 1],     ["/home/aistudio/car.jpeg", 2] ] #用于训练的数据提供器 train_reader = data_generator(train_image_files_list, BATCH_SIZE, shuffle=True) #测试数据示例 test_image_files_list = [     ["/home/aistudio/Cat3.jpg", 0],     ["/home/aistudio/keji.jpeg", 1] ] #用于测试的数据提供器 test_reader = data_generator(test_image_files_list, BATCH_SIZE, shuffle=False) 4、使用模型实践:拍一些身边宠物狗的照片(或网上找),处理成32*32尺寸后试试模型效果,准或不准的原因是什么? 具有明显特征的图片,识别准确率较高,但是如果整体特征有一定的模糊度,准确率就下降了。 比如大丹犬,与普通dog相比,它的体型高大,更接近horse,再加上人来进行干扰,此时很容易误识别为horse了。可以在训练集中增加此类样本来提高识别准确率,也需要设计更好的网络来捕捉深层特征。
展开

good

0
#40zyxxxxyyfusb回复于2019-11

01班-郑杨

1、网络结构:计算每层网络结构和输入输出尺寸和参数个数。不加BN?更深?每层的尺寸变化?更多结构?
1)输入层:imag
输出尺寸:(-1,3,32,32),-1是占位符,用于处理动态的samlpe数量,(3,32,32)是每个sample的size,3表示输入图像的通道数是3,32分别是图片的weight size和hight size。

2)第一个卷积池化层:conv_pool_1
网络结构:在卷积阶段,filter采用size是5*5,计算的时候跟图片的w(weight size)和h(hight size)对应;filter数量20,表示采用了20个通道;在池化阶段,池化核size是2*2,同样在计算的时候跟图片的w(weight size)和h(hight size)对应;池化步长为2,表示每个池化操作像w和h方向分别移动2个单位;最后激活函数采用输入relu。
输入尺寸:(128,3,32,32),128表示sample数(在BATCH_SIZE中设置),(3,32,32)是每个sample的size。
输出尺寸:(128,20,14,14)
参数个数:20 * 3 * 5 *5

3)第二个卷积池化层:
网络结构:在卷积阶段,filter采用size是5*5,计算的时候跟图片的w(weight size)和h(hight size)对应;filter数量50,表示采用了50个通道;在池化阶段,池化核size是2*2,同样在计算的时候跟图片的w(weight size)和h(hight size)对应;池化步长为2,表示每个池化操作像w和h方向分别移动2个单位;最后激活函数采用输入relu。
输入尺寸:(128,20,14,14),含义同第一层。
输出尺寸:(128,50,5,5)
参数个数:50 * 20 * 5 *5

4)第三个卷积池化层:
网络结构:同第二层。
输入尺寸:(128,50,5,5),含义同第二层
输出尺寸:(128,50,1,1)
参数个数:50 * 50 * 5 *5

4)全连接输出层:
网络结果:全链接网络
输入尺寸:(128,50,1,1),含义同第三层
输出尺寸:(128,10)
参数个数:50 * 10


2、尝试不同的Loss函数和优化算法(SGD、Momentum、Adagrad、Adam),观察效果的变化,最好的选择是什么?为什么?
1)不同优化算法在学习率设置一样(0.001)的情况下:
SGD:loss收敛到1.2-1.5,acc到0.5
Moment:loss收敛到1.2-1.5,acc到0.5
Adagrad:loss收敛到1.4-1.5,acc到0.5
Adam:loss收敛到1.2-1.3,acc到0.5+
在猫狗分类实验中,Adam效果最好。Adam中和了其他几种优化算法的优点,在训练过程中,每个参数有不同的学习率和Momentum,提升了模型训练的稳定性。
不同的场景下(学习任务、数据分布等)可能适应不同优化算法,在工程中选择哪种优化算法,可以经过调参进行实验。

2)不同的loss函数:分类问题一般使用cross_entropy


3、尝试不同的样本数量:随着每个类别样本数量由少变多,模型准确率变化的曲线是怎样的?每个类别至少有多少张图片可支撑一个准确率尚可的模型? 使用图像分类模型识别世界的万事万物是否可行?(自己编写数据读取程序,而不用默认函数;先完成同学可以在班级群内推送代码,供同学们参考)

1)

随着每个类别样本数量由少变多,模型准确率一般会更高。
每个类别至少有多少张图片可支撑一个准确率尚可的模型:数据量、数据质量、数据的分布、对真实场景的模拟程度等都是影响模型准确率的重要因素。对于比较简单的场景,比如图片中已经有比较清楚的动物脸部,所需数据量不用太大就能达到较好的效果;对应复杂的场景,比如图片中融入了大量的干扰信息,所需数据则需要较多。

2)

简单的读取自定义的数据的示例程序:

 

def data_generator(image_files_list, batch_size, shuffle=True):
    """
    数据生成器,生成batch数据
    image_files_list:列表,每个元素包含图片文本的地址以及图片的类型
    batch_size:batch大小
    shuffle:是否shuffle,默认True
    """
    def reader():
        if shuffle:
            np.random.shuffle(image_files_list)
        batch_out = []
        for item in image_files_list:

            image_file_path = item[0]  #图片所在地址
            image_label = item[1]  #图片类别         
            image = load_images(image_file_path)  #调用load_images,从image_file_path中加载图片
            batch_out.append([image, image_label])
            if len(batch_out) == batch_size:
                yield batch_out
                batch_out = []
    return reader

#训练数据示例
train_image_files_list = [
    ["/home/aistudio/Cat1.jpg", 0],
    ["/home/aistudio/Cat2.jpg", 0],
    ["/home/aistudio/dog1.jpg", 1],
    ["/home/aistudio/dog2.jpg", 1],
    ["/home/aistudio/dog3.jpg", 1],
    ["/home/aistudio/car.jpeg", 2]
]

#用于训练的数据提供器
train_reader = data_generator(train_image_files_list, BATCH_SIZE, shuffle=True)

#测试数据示例
test_image_files_list = [
    ["/home/aistudio/Cat3.jpg", 0],
    ["/home/aistudio/keji.jpeg", 1]
]
#用于测试的数据提供器
test_reader = data_generator(test_image_files_list, BATCH_SIZE, shuffle=False)


4、使用模型实践:拍一些身边宠物狗的照片(或网上找),处理成32*32尺寸后试试模型效果,准或不准的原因是什么?
具有明显特征的图片,识别准确率较高,但是如果整体特征有一定的模糊度,准确率就下降了。
比如大丹犬,与普通dog相比,它的体型高大,更接近horse,再加上人来进行干扰,此时很容易误识别为horse了。可以在训练集中增加此类样本来提高识别准确率,也需要设计更好的网络来捕捉深层特征。

11
#39188*****018回复于2019-11

这类训练模型结合自己的业务场景该如何调整?比如我有一个通过手机背面照片识别手机型号的需求,我该如何创建数据集用于适合自身业务场景的模型。对创建的数据集有哪些具体要求吗?

1
#38你还说不想我吗回复于2019-11

训练营3班-新壮

A1:

​ ​

(1)第一层

params: filter_size=5,num_filters=20,pool_size=2,pool_stride=2,

defulat params: padding =0,stride =1,dilation = 1

【卷积】

输入shape: =(-1,3,32,32)

输出shape: =(-1,20,28,28)

滤波器shape:=(20,3,5,5),参数大小= 1500

计算方式:((32-5)/1)+1=28

【池化】

输入shape:=(-1,20,28,28)

输出shape: =(-1,20,14,14)

kernal shape:(1,1,2,2)

计算方式:(28-2)/2+1=14

(2)第二层

params: filter_size=5,num_filters=50,pool_size=2,pool_stride=2,

defulat params: padding =0,stride =1,dilation = 1

输入shape: =(-1,20,14,14)

输出shape:=(-1,50,10,10)

滤波器shape:=(50,20,5,5),参数大小=25000

计算方式:((14-5)/1)+1=10

【池化】

输入shape:=(-1,50,10,10) 输出shape: =(-1,50,5,5)

kernal shape:(1,1,2,2)

计算方式:(10-2)/2+1=5

(3)第三层

输入shape: =(-1,50,5,5)

输出shape:=(-1,50,1,1)

滤波器shape:​=(50,50,5,5),参数大小=62500

计算方式:((5-5)/1+1)=1

【池化】

输入shape:=(-1,50,1,1)

输出shape: =(-1,50,1,1)

kernal shape:(1,1,2,2)

计算方式:(1-2)/2+1=1

(4)全连接层

输入shape:(-1,50,1,1)

输出shape=(-1,10)

参数大小= 50*10=500

总参数大小 = 1500+25000+62500+500=89500

0
#37189******30回复于2019-11

1.不加BN对简单网络影响有限,三层网络梯度没那么容易消失吧。增加卷积层数能够提升模型学习更多不同“粒度”下图片特征的能力,增加全连接层能够提升模型分类的“非线性能力”以提升分类精确度 。
2.(1)SGD随机抽取数据收敛较慢;Momentum通过累加梯度加速,比SGD收敛快;Adagrad除以历史梯度的平方叠加,使收敛开始加速,逐渐减速;Adam通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率,结合了Adagrad和RMSProp的长处,是入门使用的最佳选择。这些优化算法本质上都是对SGD收敛速度的优化,主要优化模型的学习速度,而非分类能力。(2)交叉熵不但能反应模型分类的准确与否,还能反应其分类匹配的程度用作梯度下降的依据。如果用分类准确率作为损失函数的话,模型可能会优先选择分类准确率更高的参数,而非匹配度更高的。而模型应当通过匹配度来学习图片数据中的分类特征。那些恰好准确率高而匹配度低的参数是没有学习价值的,是干扰。
3.学习充分的模型的准确率在增加数据量的过程中应该呈对数增长吧,增加数据对准确率的提升应当是逐渐减小的。如果是类似于线性的增长,说明当前的数据量对于此能力的模型来说还不够。当然,能力强的模型对数据量的要求更小。我觉得对一个系统来说,性能的上限是数据决定的。好的模型只能更近更快逼地近这个上限。而且只要每天有新的事物产生,就会产生新的数据。所以理论上分类万事万物是不可能的,就像尺子的刻度永远不能超过尺子本身的长度一样吧。但是对实际应用来说,“人工智能”的性能只要超过“人工”的性能或性价比就有应用价值了吧。
4.自己手机拍*-的照片识别率较低。考虑可能是由于拍摄设备的色差,光线等导致。解决思路:对训练模型的数据和预测数据进行相同的灰度化,自动色阶这样的“归一化”处理,使模型更专注的学习图片的轮廓和纹理特征。

2
#36Seasoulj回复于2019-11

01班+叶思风吟

猫狗分类实验初始的网络结构为:

  1. 卷积池化层1:卷积核大小为5,通道数为20,池化层大小为2,步幅为2,激活函数为Relu  (图像原先大小为3*32*32,输出图像大小变为:20*14*14)
  2. BN层
  3. 卷积池化层2:卷积核大小为5,通道数为50,池化层大小为2,步幅为2,激活函数为Relu(输入图像大小为20*14*14,输出图像大小变为:50*5*5)
  4. BN层
  5. 卷积池化层3:卷积核大小为5,通道数为50,池化层大小为2,步幅为2,激活函数为Relu(输入图像大小为50*5*5,输出图像大小变为:50*1*1)
  6. 全连接层:包含10个神经元,激活函数为Softmax

其它参数为:

  • 学习率:0.001 
  • 损失函数:交叉熵
  • 优化算法:Adam
  • 训练轮数:20
  • 训练集批量:128

最终在最后一轮测试集上得到的结果为:Cost:1.62261, ACC:0.65744

调整网络结构,对原先网络结构进行加深

  1. 卷积池化层1:卷积核大小为2,通道数为20,池化层大小为2,步幅为2,激活函数为Relu
  2. BN层
  3. 卷积池化层2:卷积核大小为2,通道数为50,池化层大小为2,步幅为2,激活函数为Relu
  4. BN层
  5. 卷积池化层3:卷积核大小为2,通道数为50,池化层大小为2,步幅为2,激活函数为Relu
  6. BN层
  7. 卷积池化层4:卷积核大小为2,通道数为50,池化层大小为2,步幅为2,激活函数为Relu
  8. 全连接层:包含10个神经元,激活函数为Softmax

并对原先的参数不予修改,最终在最后一轮测试集上得到的结果为:Cost:1.00559, ACC:0.67791

可以发现加深网络后,准确率略有提升。

去掉上面网络中的三个BN层后得到的结果为:Cost:0.95633, ACC:0.67326,似乎去掉BN层并没有产生太大影响

若将优化算法由Adam调整为SGD而其他参数不变,得到的结果为:Cost:1.55199, ACC:0.42959,可以发现此数据集下训练相同的轮数,Adam算法得到的模型性能要好于SGD

若将训练轮数从原本的20调高到30,发现模型在第30轮时的预测表现反而不佳,似乎已经出现了过拟合现象

最后随手找了几张图测了下模型,感觉准确率还可以接受的样子(测了三张图,对了两张)

预测错的这张图长这样:

还有两张没通过百度的图像审核。以上还请各位大佬指正。

4
#35wudenggang0回复于2019-11

4、使用模型实践:拍一些身边宠物狗的照片(或网上找),处理成32*32尺寸后试试模型效果,准或不准的原因是什么?

随手拍了附近的小猫和小狗,默认的参数下,test集准确率只有65%,预测时均不准。模型尚需优化才行。

0
#34wudenggang0回复于2019-11
#33 wudenggang0回复
二班+追云戏月 3、尝试不同的样本数量:随着每个类别样本数量由少变多,模型准确率变化的曲线是怎样的?每个类别至少有多少张图片可支撑一个准确率尚可的模型? 使用图像分类模型识别世界的万事万物是否可行? 不修改参数的前提下,分别采用不同的样本数量(10000,20000,30000,40000和50000),test集的准确率逐渐上升。10000张图片每个分类大概1000张,不优化模型的前提下,准确率大致可达55%。 [图片] 数据集读取方式修改paddle.dataset.cifar模块(略微变动,红色框)。cifar10数据集中训练集包括5个pickle文件,每个pickle文件10000张图片,可以设定不同的样本数量。调用train10函数,通过sub_names设定包括的训练集,默认情况下使用所有训练集。 [图片] [图片]
展开

使用图像分类模型识别世界的万事万物是否可行?

每天都会有新的事物诞生,图像分类模型识别 世界万事万物存在困难。

0
#33wudenggang0回复于2019-11

二班+追云戏月

3、尝试不同的样本数量:随着每个类别样本数量由少变多,模型准确率变化的曲线是怎样的?每个类别至少有多少张图片可支撑一个准确率尚可的模型? 使用图像分类模型识别世界的万事万物是否可行?

不修改参数的前提下,分别采用不同的样本数量(10000,20000,30000,40000和50000),test集的准确率逐渐上升。10000张图片每个分类大概1000张,不优化模型的前提下,准确率大致可达55%。

数据集读取方式修改paddle.dataset.cifar模块(略微变动,红色框)。cifar10数据集中训练集包括5个pickle文件,每个pickle文件10000张图片,可以设定不同的样本数量。调用train10函数,通过sub_names设定包括的训练集,默认情况下使用所有训练集。

5
#32wudenggang0回复于2019-11

二班+追云戏月

 尝试不同的Loss函数和优化算法(SGD、Momentum、Adagrad、Adam),观察效果的变化,最好的选择是什么?为什么?

分类问题的Loss函数一般用cross_entropy。默认的学习率和EPOCH_NUM下,各优化算法下cost随着iter的变化趋势(其中momentum优化算法动量因子为0.9),可以看到Adam下降最快,其次为Momentum和Adagrad,cost下降最慢为SGD。从下降速度角度来看,优先选择Adam。另外比赛过程中,一般采用SGD,会获得更好的成绩。

6
#31wudenggang0回复于2019-11
#4 wudenggang0回复
网络结构:计算每层网络结构和输入输出尺寸和参数个数。不加BN?更深?每层的尺寸变化?更多结构? 不考虑BATCH_SIZE且只考虑前向过程的情况下,输入images尺寸为[3,32,32],因为图片为RGB三通道,宽和高均为32。第一卷积池化层参数包括w:[20,3,5,5],b:[20],其中20为当层卷积核个数(通道数),3为输入images通道个数(前层通道数),5×5为卷积核大小,第一卷积池化层后的Batchnorm参数包括w:[20],b:[20],因为第一卷积池化层有20个通道。Batchnorm会把按通道计算均值和方差来进行正则化。类似,第二卷积池化层参数包括w:[50,20,5,5],b:[50],第二卷积池化层后的Batchnorm参数包括w:[50],b:[50],第三卷积池化层参数包括w:[50,50,5,5],b:[50],全连接层w:[50,10],b:[10]。因为是10分类,输出层尺寸为[10]。optimizer.minimize(avg_cost)函数输出为元组(optimize_ops, params_grads),其中params_grads是一个由(param, grad)变量对组成的列表,param是Parameter,即参数,grad是该Parameter对应的梯度值。
展开

2班+追云戏月

0
#30jack1998l回复于2019-11

第二期02班+李维民

2 尝试不同的Loss函数和优化算法(SGD、Momentum、Adagrad、Adam),观察效果的变化,最好的选择是什么?为什么?

Adam。比SGD、Momentum、Adagrad观察效果好,其收敛速度更快,学习效果更为有效。

0
#29rose20135188回复于2019-11

赶紧来做作业

0
#28liguanghui2588回复于2019-11
#26 星光ld1回复
其他问题上不知道,这个问题上目前我做出来的结果还是与sample的10对数基本线性的
展开

那可以

0
#27星光ld1回复于2019-11

下面是问题5的VGG net构建:

def build_block_2(input_tensor, filter_num):
    conv_1 = fluid.layers.conv2d(
        input=input_tensor, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )

    conv_2 = fluid.layers.conv2d(
        input=conv_1, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )

    pool = fluid.layers.pool2d(
        input=conv_2, 
        pool_size=2, 
        pool_type='max', 
        pool_stride=2
    )
    return pool

def build_block_3(input_tensor, filter_num):
    conv_1 = fluid.layers.conv2d(
        input=input_tensor, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )

    conv_2 = fluid.layers.conv2d(
        input=conv_1, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )
    
    conv_3 = fluid.layers.conv2d(
        input=conv_2, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )

    pool = fluid.layers.pool2d(
        input=conv_3, 
        pool_size=2, 
        pool_type='max', 
        pool_stride=2
    )
    return pool
    
def build_block_4(input_tensor, filter_num):
    conv_1 = fluid.layers.conv2d(
        input=input_tensor, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )

    conv_2 = fluid.layers.conv2d(
        input=conv_1, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )
    
    conv_3 = fluid.layers.conv2d(
        input=conv_2, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )
    
    conv_4 = fluid.layers.conv2d(
        input=conv_3, 
        num_filters=filter_num, 
        filter_size=3, 
        stride=1, 
        padding=1, 
        act='relu'
    )

    pool = fluid.layers.pool2d(
        input=conv_4, 
        pool_size=2, 
        pool_type='max', 
        pool_stride=2
    )
    return pool

def VGG16(img):
    print(img)
    block1 = build_block_2(img, 64)
    block2 = build_block_2(block1, 128)
    block3 = build_block_3(block2, 256)
    block4 = build_block_3(block3, 512)
    block5 = build_block_3(block4, 512)
    fc1 = fluid.layers.fc(
        input=block5, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    fc2 = fluid.layers.fc(
        input=fc1, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    prediction = fluid.layers.fc(
        input=fc2, 
        size=10, 
        num_flatten_dims=1,
        act='softmax'
    )
    return prediction
    
def VGG16_bn(img):
    print(img)
    block1 = build_block_2(img, 64)
    block1 = fluid.layers.batch_norm(block1)
    block2 = build_block_2(block1, 128)
    block2 = fluid.layers.batch_norm(block2)
    block3 = build_block_3(block2, 256)
    block3 = fluid.layers.batch_norm(block3)
    block4 = build_block_3(block3, 512)
    block4 = fluid.layers.batch_norm(block4)
    block5 = build_block_3(block4, 512)
    block5 = fluid.layers.batch_norm(block5)
    fc1 = fluid.layers.fc(
        input=block5, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )

    fc2 = fluid.layers.fc(
        input=fc1, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    
    prediction = fluid.layers.fc(
        input=fc2, 
        size=10, 
        num_flatten_dims=1,
        act='softmax'
    )
    return prediction
    
def VGG19(img):
    print(img)
    block1 = build_block_2(img, 64)
    block2 = build_block_2(block1, 128)
    block3 = build_block_4(block2, 256)
    block4 = build_block_4(block3, 512)
    block5 = build_block_4(block4, 512)
    fc1 = fluid.layers.fc(
        input=block5, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    fc2 = fluid.layers.fc(
        input=fc1, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    prediction = fluid.layers.fc(
        input=fc2, 
        size=10, 
        num_flatten_dims=1,
        act='softmax'
    )
    return prediction
    
def VGG19_bn(img):
    print(img)
    block1 = build_block_2(img, 64)
    block1 = fluid.layers.batch_norm(block1)
    block2 = build_block_2(block1, 128)
    block2 = fluid.layers.batch_norm(block2)
    block3 = build_block_4(block2, 256)
    block3 = fluid.layers.batch_norm(block3)
    block4 = build_block_4(block3, 512)
    block4 = fluid.layers.batch_norm(block4)
    block5 = build_block_4(block4, 512)
    block5 = fluid.layers.batch_norm(block5)
    fc1 = fluid.layers.fc(
        input=block5, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    fc2 = fluid.layers.fc(
        input=fc1, 
        size=4096, 
        num_flatten_dims=1,
        act='relu'
    )
    prediction = fluid.layers.fc(
        input=fc2, 
        size=10, 
        num_flatten_dims=1,
        act='softmax'
    )
    return prediction

VGG16,VGG19为原始的VGG版本,VGG16_bn,VGG19_bn为增加了batch-norm的VGG版本。VGG16,VGG19,VGG16_bn,VGG19_bn的计算准确率分别为0.0977,0.1021,0.8156,0.8177.

2
快速回复
TOP
切换版块