作业7-1：

乘法：（（224+2-3）/1+1）*10*3*64*9=867041280次

加法：（（224+2-3）/1+1）*10*3*64*(8+1)=867041280次

作业7-2：

将激活函数改成relu后，准确度有了很大程度的提高，模型训练效果显著。

原因分析：由于sigmoid函数两端倒数为0，容易导致后面的隐藏层激活后反向传播值为0，起不到更新网络参数的作用

     而relu激活函数就不存在这个问题，relu激活函数在大于0的部分的倒数全部为1，小于0的部分为0

sigmoid：

relu：

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

将卷积层的Sigmoid换成ReLU能够使模型的loss下降更快，也减少了同样其他参数情况下的训练用时。因为relu激活函数解决了深层网络的梯度消散现象，使模型更快收敛，而且其只将输入大于1的神经元传入下一层，使模型集中学习重要的图像特征，并减少了运算量。

但试验得出：后面分类的全连接层还是sigmoid激活函数效果更好。

作业8-1：sigmoid 换成relu，loss收敛，准确度提升，运行结果如下图

从纵坐标及曲线可以看出，sigmoid的loss下降到0.7附近不再下降，而relu则下降到0.1一下还有下降趋势，

在此项目中relu优势比sigmoid大

分析

sigmoid和relu的函数图像如下

可以看出，

sigmoid非常容易达到平缓区域，其梯度接近0，导致loss收敛缓慢。

relu在大于0的部分，梯度始终是一个常数，

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

换成Relu激活函数以后，可以发现loss会收敛，而且收敛更快，根据这两个函数的特性可以发现，sigmoid函数只有在中间小范围内梯度较大，而在两端很大的范围内梯度几乎为0，反向传播时会出现梯度消失的现象，Relu函数则不同，在大于0时梯度一直为1，不会有梯度消失的现象。

作业8-1：

变更为relu后能够收敛，收敛速度加快。可能原因是relu计算更为简单，计算量更少。

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

1. 针对眼底筛查数据集

1） 若在LeNet模型中的中间层的激活函数使用Sigmoid函数，在5次epoch后，在验证集上的准确率在57.25%左右，loss几乎不再改变；在10次epoch后，在验证集上的准确率也在57.25%左右，Loss也几乎不再改变。

2） 若在LeNet模型中的中间层的激活函数使用Relu函数，在5次epoch后，在验证集上的准确率在90.75%左右，loss仍在变化；在10次epoch后，在验证集上的准确率也在92.50%左右，Loss仍在改变。

具体结果如下图1-图4所示。

                      图1 Sigmoid函数 Epoch = 5                                                  图2 Relu函数 Epoch = 5

                  图3  Sigmoid函数 Epoch = 10                                            图4  Relu函数 Epoch = 10

2. 分析产生二者区别的原因

在实验中，由于只改变了激活函数这一项，因此激活函数是引起结果不同的根本原因，同时，Relu函数相比于Sigmoid函数，促使结果的分类精度更高，训练收敛速度也更快，进一步分析，大体有三点原因：

1）采用sigmoid作为激活函数时，指数级别的运算，运算量大，同时，在反向传播求误差梯度时，求导涉及到除法，计算量相对较大，而采用Relu激活函数，整个过程的计算量会小很多；

2）Relu激活函数会使一部分神经元的输出为0，这样就造成了神经网络的稀疏性，并且减少了各个参数之间的相互依存关系，缓解了过拟合问题的发生，也就是大家常说的：在生物上的合理性，它是单边的，相比sigmoid激活函数，更符合生物神经元的特征；

3）对于深层的神经网络，sigmoid函数在反向传播的过程中，很容易就会出现梯度消失的情况，即在sigmoid接近饱和区时，变换太缓慢，导数趋于0，这种情况会造成信息丢失，从而无法完成深层神经网络的训练。

使用relu激活函数，Loss可以收敛。

Sigmoid函数一旦进入饱和区，则梯度变化将很小，即Loss基本不再下降

作业8：

使用relu激活函数，Loss可以收敛。

Sigmoid函数一旦进入饱和区，则梯度变化将很小，即Loss基本不再下降

2.理论作业：
①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？

答：焦耳定律中热量Q，电流I,电阻R，时间t的关系，可以使用监督。参数I,R,t，假设：Q=K*I*I*R*t，优化目标：不同t，I,R,下产生热量Q,与系数K的关系，确定K.,使得K的误差方均值最小

②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

答：AI工程师从事于AI行业，这个市场并没有发展到完全成熟的阶段，技术在不断增长，需求也在培育中增长，属于行业发展周期的扩张期，AI工程师需求不断扩大，可以与行业共同走向繁荣成熟期。

作业8-1：

使用Sigmoid激活函数的输出：

使用Relu激活函数的输出：

在相同的训练次数和网络结构下，后者明显优于前者，这主要是由于Relu能有效减缓过拟合的发生的概率，同时，计算量也比Sigmoid小很多。

作业8：

LeNet模型中的中间层的激活函数为Sigmoid，用在眼底筛查数据集上进行训练，Loss并不能很好的收敛，准确率也不好。

将LeNet模型中的中间层的激活函数Sigmoid换成ReLU，在眼底筛查数据集上Loss是能够收敛，并且准确率也极大的提高。

Sigmoid可以造成梯度消失，而Relu可以很好的将梯度传播下去不会造成梯度消失。Relu的这个特性可以让模型更好的收敛。

作业6-1：

（1）

（2）

（3）对比这种不同的损失函数，我们发现cross entropy准确率能快速达到很高，收敛的快；

（4）采用cross entropy损失函数，训练集以及测试集的loss和accuracy同步变化，且能很快达到收敛

（5）我们发现随着正则化权重的增大，最终收敛的准确率降低，loss变大。造成这样的原因可能是，正则化系数为0时，此时基本没有过拟合现象（如（4）种图所示），随着系数的增大，模型的泛化能力变的更强，所以收敛后的损失有所增加，准确率下降

作业6-1：

（1）

（2）

（3）对比这种不同的损失函数，我们发现cross entropy准确率能快速达到很高，收敛的快；

（4）采用cross entropy损失函数，训练集以及测试集的loss和accuracy同步变化，且能很快达到收敛

（5）我们发现随着正则化权重的增大，最终收敛的准确率降低，loss变大。造成这样的原因可能是，正则化系数为0时，此时基本没有过拟合现象（如（4）种图所示），随着系数的增大，模型的泛化能力变的更强，所以收敛后的损失有所增加，准确率下降

作业8：

使用sigmoid函数：

使用relu函数：

对于relu函数来说，当x大于0时，其梯度恒为1，有利于反向传播的计算，不会像sigmoid函数那样出现梯度消失现象。

作业8：

激活函数为relu时损失可以收敛，relu使用分段线性产生非线性函数，因此造成了网络的稀疏性，减少了参数的相互依存关系，能缓解了过拟合

作业9-1：

下图为学习率为0.001时的训练结果

学习率为0.1时：

每10个batch Id变化时，改变学习率，步距为-0.0045

最终，得到的测试结果：

最后两个Batch，发现loss有增大的趋势，不知什么原因。

作业8

将LeNet模型中的中间层的激活函数Sigmoid换成ReLU，在眼底筛查数据集上Loss可以收敛。

ReLU 在训练过程中收敛更快

作业5-3：

可以发现，当学习率相同为0.01时，可以发现Adam优化算法的优化效果最佳。

当学习率不同时，Adam优化算法的训练结果如下：

可以发现当学习率为0.015时，效果最佳。

作业5-1：

adam算法，准确率0.99

use_gpu = True
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()

with fluid.dygraph.guard():
    print('start evaluation .......')
    #加载模型参数
    model = MNIST("mnist")
    model_state_dict, _ = fluid.load_dygraph('mnist')
    model.load_dict(model_state_dict)

    model.eval()
    eval_loader = load_data('eval')

    acc_set = []
    avg_loss_set = []
    for batch_id, data in enumerate(eval_loader()):
        x_data, y_data = data
        img = fluid.dygraph.to_variable(x_data)
        label = fluid.dygraph.to_variable(y_data)
        prediction, acc = model(img, label)
        loss = fluid.layers.cross_entropy(input=prediction, label=label)
        avg_loss = fluid.layers.mean(loss)
        acc_set.append(float(acc.numpy()))
        avg_loss_set.append(float(avg_loss.numpy()))
        break
    
    #计算多个batch的平均损失和准确率
    acc_val_mean = np.array(acc_set).mean()
    avg_loss_val_mean = np.array(avg_loss_set).mean()

    print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

作业5-2： 常见的卷积神经网络包括：VGGnet, Googlenet, Alexnet, yolo, ssd, fastrcnn, fasterrcnn等等
作业5-3： Adam算法效果最好，lr在0.01-0.001之间最优，0.1震荡

use_gpu = True
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()

with fluid.dygraph.guard(place):
    model = MNIST("mnist")
    model.train() 
    #调用加载数据的函数
    train_loader = load_data('train')
    EPOCH_NUM = 5
    BATCH_SIZE = 100
    
    iters=[]
    l_losses=[]
    f_losses=[]
    all_losses=[]
    lrs = [0.1, 0.01, 0.001, 0.0001]
    for i in range(4):
        f_losses=[]
        for lr in lrs:
            if i == 0:
                optimizer = fluid.optimizer.AdamOptimizer(learning_rate=lr)
            elif i == 1:
                optimizer = fluid.optimizer.SGDOptimizer(learning_rate=lr)
            elif i == 2:
                optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=lr, momentum = 0.1)
            else:
                optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=lr)
            iters=[]
            iter=0
            l_losses=[]
            for epoch_id in range(EPOCH_NUM):
                for batch_id, data in enumerate(train_loader()):
                    #准备数据，变得更加简洁
                    image_data, label_data = data
                    image = fluid.dygraph.to_variable(image_data)
                    label = fluid.dygraph.to_variable(label_data)
                    #前向计算的过程，同时拿到模型输出值和分类准确率
                    predict, acc = model(image, label)
                    avg_acc = fluid.layers.mean(acc)
                    
                    #计算损失，取一个批次样本损失的平均值
                    loss = fluid.layers.cross_entropy(predict, label)
                    avg_loss = fluid.layers.mean(loss)
                    
                    #每训练了200批次的数据，打印下当前Loss的情况
                    if batch_id % 200 == 0:
                        print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(),avg_acc.numpy()))
                        iters.append(iter)
                        l_losses.append(avg_loss.numpy())
                        iter = iter + 200
                        
                    #后向传播，更新参数的过程
                    avg_loss.backward()
                    optimizer.minimize(avg_loss)
                    model.clear_gradients()
            f_losses.append(l_losses)
        all_losses.append(f_losses)
    # fluid.save_dygraph(model.state_dict(), 'mnist')
    
    #画出训练过程中Loss的变化曲线
titles = ['AdamOptimizer', 'SGDOptimizer', 'MomentumOptimizer', 'AdagradOptimize']
colors = ['yellow', 'green', 'blue', 'red']
markers = ['o', 'v', 'x', '+']
legends = ['lr_0.1', 'lr_0.01', 'lr_0.001', 'lr_0.0001']
for i, losses in enumerate(all_losses):
    # plt.figure()
    plt.title(titles[i], fontsize=24)
    plt.xlabel("iter", fontsize=14)
    plt.ylabel("loss", fontsize=14)
    for i, ls in enumerate(losses):
        plt.plot(iters, ls, color=colors[i], marker=markers[i]) 
    plt.legend(legends, loc='upper right')
    plt.grid()
    plt.show()