作业9-1

首先使用固定学习率查看效果

opt = fluid.optimizer.Momentum(learning_rate=0.001, momentum=0.9)

得到的loss图像为：

看图像发现，训练过程中第一次是在第50次时有较大波动，因此尝试在50次时缩减学习率。

再次训练发现loss值的变化在50次之后逐渐变小

作业9-2：

对原来的实例代码中做修改：

训练过程的loss计算更改

第四个模块的代码修改，由于第四个模块有两个输出，其中还要加上几个全连接层

对应的前向计算的过程也要修改

最后的训练结果，模型训练变慢：

作业9-1：在第二章中学习过如何设置学习率衰减，这里建议使用分段衰减的方式，衰减系数为0.1， 根据ResNet目前的训练情况，应该在训练到多少步的时候设置衰减合适？请设置好学习率衰减方式，在眼疾识别数据集iChallenge-PM上重新训练ResNet模型

 # 定义优化器
        boundaries = [120, 240]
        values = [0.01, 0.0001]
        opt = fluid.optimizer.Momentum(learning_rate= fluid.dygraph.PiecewiseDecay(boundaries=boundaries, values=values, begin=0), momentum=0.9)

学习率衰减能够让准确率和loss进一步改进

作业7-1：

乘法：867041280 加法：867041280

作业7-2：

作业7-1:

乘法：(224+2-3+1) * (224+2-3+1) * 10 * 3 *64 * 9 = 867041280

加法：(224+2-3+1) * (224+2-3+1) * 10 * 3 * 64 * 9 + 224 * 224 *  10 * 64 *3（这一步是RGB三通道和各个卷积核卷积操作后得到的三通道再融合时需要的加法次数） = 963379200

作业7-2：

作业3-1（1） 使用numpy计算tanh激活函数

（2）统计随机生成矩阵中有多少个元素大于0

作业9-1：

运行后观察loss发现在80的时候波动很大，设置为学习率变化阈值

调整以后的loss趋于稳定

9-2：修改网络

作业9-1：在第二章中学习过如何设置学习率衰减，这里建议使用分段衰减的方式，衰减系数为0.1， 根据ResNet目前的训练情况，应该在训练到多少步的时候设置衰减合适？请设置好学习率衰减方式，在眼疾识别数据集iChallenge-PM上重新训练ResNet模型。
过程1：开始试验发现loss波动太大，动态调整学习率效果不好。分析是batch_size过小导致loss波动大。

过程2：将batch_size从10调整为40后，波动率下降，但仍然存在（并突出了）一个现象：训练集loss的波动竟然比验证集更大。

过程3：分析是不是程序出错了。试验采用adam优化器自动调整学习率发现，训练集波动和数值都小于验证集。
过程4：另一思路分析是动量设置过大，导致加剧了loss在最优解附近的震荡。
过程5：网上查资料得知有种说法，0.9的momentum就能使模型收敛比SDG块10倍。试验momentum动量参数从0.9调整到0.5发现，果然训练集的波动率受到了有效抑制。
过程6：试验将动量从0.9降低至0.5后，Momentum优化器学习率在100次迭代后decay。结果显示，其不但降低了loss和accuracy的波动，还提高了accuracy。

结论1：batch_size太小会导致loss的波动会比较大，当batch_size太小时，调节学习率的作用有限。10这么小的batch_size,后面用adam这种自动衰减学习率的优化方法时效果也有限。
结论2：使用Momentum优化器在loss波动较大的情况下，动量不能设置太大。开始试验时，由于波动量设置过大竟然导致训练组比验证组loss波动还厉害。
结论3：使用Momentum优化器时，decay学习率的同时也decay动量效果更好。其他优化器同理。
结论4：即使小batch_size会导致loss波动增大，但能够加快训练速度，尤其是在硬件资源有限的情况下。所以，资源有限时，小batch_size还是性价比更高的，但对学习率优化的要求也更高，不熟悉最好用adam。

作业9-2：补全GoogLeNet的三个分类器
googLeNet有两处需要修改：
1.前向计算forward（）方法要返回Inception4a，Inception4d和Inception5b三个块输出的softmax分类值，本例中用sigmoid的二分类特性代替。返回前要加上各个inception块算分类值需要的平均池化、全连接和dropout层。
2.训练方法train（）中将forward（）返回的三个值分别求得交叉商损失，再按照2：2：6的比重求得最终预测值与loss值。
p1, p2, p3 = model.forward(x)
p1 = fluid.layers.sigmoid(p1)
p2 = fluid.layers.sigmoid(p2)
p3 = fluid.layers.sigmoid(p3)
predict = p1 * 0.2 + p2 * 0.2 + p3 * 0.6
l1 = fluid.layers.sigmoid_cross_entropy_with_logits(p1, label)
l2 = fluid.layers.sigmoid_cross_entropy_with_logits(p2, label)
l3 = fluid.layers.sigmoid_cross_entropy_with_logits(p2, label)
loss = l1 * 0.2 + l2 * 0.2 + l3 * 0.6

作业9-2:

以下3个地方需要修改:

class GoogLeNet(fluid.dygraph.Layer):
    def __init__(self, name_scope):
        super(GoogLeNet, self).__init__(name_scope)
        # GoogLeNet包含五个模块，每个模块后面紧跟一个池化层
        # 第一个模块包含1个卷积层
        self.conv1 = Conv2D(self.full_name(), num_filters=64, filter_size=7, 
                            padding=3, act='relu')
        # 3x3最大池化
        self.pool1 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  
                            pool_padding=1, pool_type='max')
        # 第二个模块包含2个卷积层
        self.conv2_1 = Conv2D(self.full_name(), num_filters=64, 
                              filter_size=1, act='relu')
        self.conv2_2 = Conv2D(self.full_name(), num_filters=192, 
                              filter_size=3, padding=1, act='relu')
        # 3x3最大池化
        self.pool2 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  
                            pool_padding=1, pool_type='max')
        # 第三个模块包含2个Inception块
        self.block3_1 = Inception(self.full_name(), 64, (96, 128), (16, 32), 32)
        self.block3_2 = Inception(self.full_name(), 128, (128, 192), (32, 96), 64)
        # 3x3最大池化
        self.pool3 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  
                               pool_padding=1, pool_type='max')
        # 第四个模块包含5个Inception块
        self.block4_1 = Inception(self.full_name(), 192, (96, 208), (16, 48), 64)
        # 添加第一个softmax
        self.pool4_1 = Pool2D(self.full_name(), pool_size=1, pool_type='avg', global_pooling=True)
        self.fc4_11 = FC(self.full_name(), size=128, act='relu')
        self.fc4_12 = FC(self.full_name(), size=1024, act='relu')
        self.dropout_ratio_41 = 0.7
        self.fc41 = FC(self.full_name(), size=1)
        
        self.block4_2 = Inception(self.full_name(), 160, (112, 224), (24, 64), 64)
        self.block4_3 = Inception(self.full_name(), 128, (128, 256), (24, 64), 64)
        self.block4_4 = Inception(self.full_name(), 112, (144, 288), (32, 64), 64)
        # 添加第二个softmax
        self.pool4_2 = Pool2D(self.full_name(), pool_size=1, pool_type='avg', global_pooling=True)
        self.fc4_21 = FC(self.full_name(), size=128, act='relu')
        self.fc4_22 = FC(self.full_name(), size=1024, act='relu')
        self.dropout_ratio_42 = 0.7
        self.fc42 = FC(self.full_name(), size=1)
        
        self.block4_5 = Inception(self.full_name(), 256, (160, 320), (32, 128), 128)
        # 3x3最大池化
        self.pool4 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  
                               pool_padding=1, pool_type='max')
        # 第五个模块包含2个Inception块
        self.block5_1 = Inception(self.full_name(), 256, (160, 320), (32, 128), 128)
        self.block5_2 = Inception(self.full_name(), 384, (192, 384), (48, 128), 128)
        # 全局池化，尺寸用的是global_pooling，pool_stride不起作用
        self.pool5 = Pool2D(self.full_name(), pool_stride=1, 
                               global_pooling=True, pool_type='avg')
        self.fc = FC(self.full_name(),  size=1)

    def forward(self, x):
        x = self.pool1(self.conv1(x))
        x = self.pool2(self.conv2_2(self.conv2_1(x)))
        x = self.pool3(self.block3_2(self.block3_1(x)))
        # 添加第一个softmax
        out1 = self.fc4_12(self.fc4_11(self.pool4_1(self.block4_1(x))))
        out1 = fluid.layers.dropout(out1, self.dropout_ratio_41)
        out1 = self.fc41(out1)
        
        x = self.block4_3(self.block4_2(self.block4_1(x)))
        # 添加第二个softmax
        out2 = self.fc4_22(self.fc4_21(self.pool4_2(self.block4_4(x))))
        out2 = fluid.layers.dropout(out2, self.dropout_ratio_42)
        out2 = self.fc42(out2)
        
        x = self.pool4(self.block4_5(self.block4_4(x)))
        x = self.pool5(self.block5_2(self.block5_1(x)))
        x = self.fc(x)
        return out1, out2, x

logits1, logits2, logitsx = model(img)
# 进行loss计算
loss1 = fluid.layers.sigmoid_cross_entropy_with_logits(logits1, label)
loss2 = fluid.layers.sigmoid_cross_entropy_with_logits(logits2, label)
loss3 = fluid.layers.sigmoid_cross_entropy_with_logits(logitsx, label)
avg_loss = fluid.layers.mean(0.2*loss1+0.2*loss2+0.6*loss3)

# 运行模型前向计算，得到预测值
_,_,logits = model(img)

结果：

start training ...
epoch: 0, batch_id: 0, loss is: [0.6741834]
epoch: 0, batch_id: 10, loss is: [0.6695887]
[validation] accuracy/loss: 0.4725000262260437/0.675366222858429
epoch: 1, batch_id: 0, loss is: [0.570052]
epoch: 1, batch_id: 10, loss is: [0.6330353]
[validation] accuracy/loss: 0.9100000262260437/0.6231394410133362
epoch: 2, batch_id: 0, loss is: [0.6673101]
epoch: 2, batch_id: 10, loss is: [0.72236514]
[validation] accuracy/loss: 0.8574999570846558/0.5590617656707764
epoch: 3, batch_id: 0, loss is: [0.63359785]
epoch: 3, batch_id: 10, loss is: [0.5377601]
[validation] accuracy/loss: 0.6324999928474426/0.5132871866226196
epoch: 4, batch_id: 0, loss is: [0.6085617]
epoch: 4, batch_id: 10, loss is: [0.5289607]
[validation] accuracy/loss: 0.9149999618530273/0.32958561182022095
epoch: 5, batch_id: 0, loss is: [0.52167547]
epoch: 5, batch_id: 10, loss is: [0.5545877]
[validation] accuracy/loss: 0.8299999237060547/0.3667006194591522
epoch: 6, batch_id: 0, loss is: [0.4408757]
epoch: 6, batch_id: 10, loss is: [0.3657415]
[validation] accuracy/loss: 0.9550000429153442/0.2204791009426117
epoch: 7, batch_id: 0, loss is: [0.3958261]
epoch: 7, batch_id: 10, loss is: [0.42100492]
[validation] accuracy/loss: 0.9424999952316284/0.21202610433101654
epoch: 8, batch_id: 0, loss is: [0.5467679]
epoch: 8, batch_id: 10, loss is: [0.3406551]
[validation] accuracy/loss: 0.9350000619888306/0.20788440108299255
epoch: 9, batch_id: 0, loss is: [0.4761749]
epoch: 9, batch_id: 10, loss is: [0.56333125]
[validation] accuracy/loss: 0.9675000309944153/0.14981447160243988

您好，能不能传授一下loss 曲线的画法呢？按照老师发布的记事本，我不知道为什么我loss数据总是取不出来，画不出图像

作业7-1

乘法次数867041280, 加法次数 834928640

乘法 N*ic*oc*kw*kh*((H+2ph-kh)/sh +1)*((W+2pw-kw)/sw+1)

如果pad的是0，加法N*oc*ic*(kw*kh-1)*((H+2ph-kh)/sh +1)*((W+2pw-kw)/sw+1)+N*oc*(ic-1)*((H+2ph-kh)/sh +1)*((W+2pw-kw)/sw+1)=834928640

作业4-2：通过Python、深度学习框架，不同方法写房价预测，Python编写的模型 和 基于飞桨编写的模型在哪些方面存在异同？例如程序结构，编写难易度，模型的预测效果，训练的耗时等等？

相同：

1 python编写的模型跟飞桨编写的模型具有深度学习中构建模型的基本步骤，数据预处理 网络结构 模型配置等步骤都是一样的

不同：

1 飞桨的结构更加简洁，清晰，因为损失函数以及数据生成等步骤可以直接通过调用函数实现，不需要实现对底层的实现过程深入了解，而python编写的结构对每一个步骤都详细进行了编写，因此模型更加复杂，结构更加庞大

2 飞桨的编写更加容易，python的编写复杂

3 python编写的模型预测效果没有飞桨编写的模型的预测效果好，python编写的模型在数据处理，损失函数以及优化器等方面都是比较粗糙的，而飞桨中的模型的许多函数经过了优化，能够让模型取得比较好的预测效果

作业5

5-1：从原始数据集中随机抽取100张图片，测试模型的准确率，

做法，从测试数据集中，将所有图片读取出来，然后构造从1-10000张图片中随机抽取一百张进行验证

准确率为21%

作业5-2：了解下对于计算机视觉，有哪些常见的卷积神经网络？

LeNet，1989年，LeCun提出的卷积神经网络的鼻祖，

AlexNet，2012年提出的5卷积层+2 全连接层的卷积神经网络

GoogleNet，2015年提出的深度卷积神经网络中的一个重要的结构，层数推进到了22层，跳出AlexNet的基本结构，提出了inception单元

ResNet，2015年何凯明提出的更深的网络。

作业5-3：在手写数字识别任务上，哪种优化算法的效果最好，多大的学习率最优？ 通过loss的下降趋势来判断

我在这里测试了四种优化算法，分别是SGD、Momentum、Adagrad和Adam，每种算法分别设置三种学习率，0.1 、0.01、和0.001，

其中训练参数为 batch-num = 5, batch-num = 100,其中loss下降最快且数值最小的是Adam算法学习率在0.001的时候。

作业3-1（1）使用numpy计算tanh激活函数（请用numpy写出计算程序，并画出tanh函数曲线图，x的取值范围设置为[-10., 10.]）

程序：

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
import numpy as np
import matplotlib.pyplot as plt
#设置图片大小
plt.figure(figsize=(8, 3))
x = np.arange(-10, 10, 0.1)
# 计算 Sigmoid函数
s =(np.exp(x) - np.exp(- x)) / (np.exp(x) + np.exp(- x))
# 设置一个子图窗口，将Sigmoid的函数图像画在左边
f = plt.subplot(111)
# 画出函数曲线
plt.plot(x, s, color='r')
# 添加文字说明
plt.text(-5., 0.9, r'$y=\tanh(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

作业：3-2 统计随机生成矩阵中有多少个元素大于0

程序：

import numpy as np
#生成随机数构成的矩阵
p = np.random.randn(10,10)
#在10*10矩阵中筛选出大于0的元素
q = p[p>0]
#输出符合条件的结果
#print(q)
#统计符合条件的个数
print(q.shape)

作业8：如果将LeNet模型中的中间层的激活函数Sigmoid换成ReLU，在眼底筛查数据集上将会得到什么样的结果？Loss是否能收敛，ReLU和Sigmoid之间的区别是引起结果不同的原因吗？请发表你的观点

使用激活函数Sigmoid， Loss难以收敛。原因是多层sigmoid叠加会出现梯度消失。

作业9-1:

使用分段衰减的方式，衰减系数为0.1

boundaries =[160,180]
values = [0.001,0.0001,0.0001]
opt = fluid.optimizer.Momentum(learning_rate=fluid.layers.piecewise_decay(boundaries, values), momentum=0.9)

start training ...
epoch: 0, batch_id: 0, loss is: [0.6900862]
epoch: 0, batch_id: 10, loss is: [0.7834173]
epoch: 0, batch_id: 20, loss is: [0.6089426]
epoch: 0, batch_id: 30, loss is: [0.44614416]
[validation] accuracy/loss: 0.7675000429154332/0.4995689392086477
epoch: 1, batch_id: 0, loss is: [0.62597416]
epoch: 1, batch_id: 10, loss is: [0.37226442]
epoch: 1, batch_id: 20, loss is: [0.56305483]
epoch: 1, batch_id: 30, loss is: [0.5852426]
[validation] accuracy/loss: 0.8700000643732244/0.31707146763804465
epoch: 2, batch_id: 0, loss is: [0.34716362]
epoch: 2, batch_id: 10, loss is: [0.29987423]
epoch: 2, batch_id: 20, loss is: [0.40632883]
epoch: 2, batch_id: 30, loss is: [0.23577423]
[validation] accuracy/loss: 0.8725000619888042/0.3043900728224676
epoch: 3, batch_id: 0, loss is: [0.6481099]
epoch: 3, batch_id: 10, loss is: [0.3430357]
epoch: 3, batch_id: 20, loss is: [0.5004776]
epoch: 3, batch_id: 30, loss is: [0.46621162]
[validation] accuracy/loss: 0.925000011924293/0.22478042542934418
epoch: 4, batch_id: 0, loss is: [0.05665208]
epoch: 4, batch_id: 10, loss is: [0.08026776]
epoch: 4, batch_id: 20, loss is: [0.10686707]
epoch: 4, batch_id: 30, loss is: [0.0466433]
[validation] accuracy/loss: 0.9524999856949982/0.17152376472945694

作业7-1：

输出一个像素点需要：

9次乘法

8次加法+1次偏置项加法=9次加法

单层数据[224, 224]卷积不填充输出数据[222, 222]，输出像素点为222*222

因此：

一次卷积需要的乘法=9*222*222*3*64*10=851，627，520次

一次卷积需要的加法=9*222*222*3*64*10=851，627，520次

作业7-2：

①F=n*μ
通过增加正压力N，求得一个值F，通过组数据可以求得μ。假设是呈线性关系，参数是模型中的变量μ。优化目标是寻找使得数据拟合较好的参数。

②

       曾经在听一次讲座时，主讲嘉宾讲未来的职业有两种，制作人工智能的程序员，和使用人工智能完成一定目的的使用者。在机器学习特别是深度学习的出现后，使得人们在解决某些领域的问题时不需要掌握那么多该领域的知识，并对系统的输入数据依据该领域的深厚知识进行精妙的变化和处理，这提高了行业的自动化程度，加快了业务的迭代速度。

       因为现在这个阶段的深度学习的概念从2010年左右又变得火热，目前各大高校培养的机器学习方面的人才对于现在市场的需求来说还是相对滞后的，相关从业人员不但需要丰富的工程经验，对业务数据有准确的把握，同时也要能紧跟机器学习当下最前沿的理论并尝试加以应用，这个要求还是比较高的，市场上满足这些要求的人并不算多，整体高素质的机器学习从业者是供少于求。所以说机器学习的前景很好。