作业2-1

（1）

(2)

// 前向计算由原先的一次方程变为二次方程 既 y = w2*(x+w1*x^2)+b，第一层先计算z1 = x+ w1*x^2, 第二层计算 z = w2*z1 +b, loss = （z-y)^2  代码如下：

import numpy as np
import matplotlib.pyplot as plt 

class Network(object):

    # 数据预处理
    def load_data(self,Data_Path,Variable_Count):

        # 文件转二维数组
        data = np.fromfile(Data_Path,sep=' ')
        Line_Count = int(data.shape[0]/Variable_Count)
        data = data.reshape([Line_Count,Variable_Count])

        # 数据拆分，80%训练，20%测试
        ratio = 0.8
        offset = int(data.shape[0]*ratio)
        training_data = data[:offset]

        # 归一化
        maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0),training_data.sum(axis=0) / training_data.shape[0]
        D = maximums - minimums
        for i in range(Variable_Count):
            data[:, i] = (data[:, i] - avgs[i]) / D[i]

        # 得到划分后的数据
        training_data = data[:offset]
        test_data = data[offset:]
        
        return training_data, test_data, D, avgs

    # 前向计算方程
    def forward(self,x,w1,w2,b):
        Qx = [[x[i][j]**2 for j in range(len(x[i]))] for i in range(len(x))]
        z1 = x + [[Qx[i][j]*w1[j][0] for j in range(len(Qx[i]))] for i in range(len(Qx))]
        z2 = np.dot(z1,w2) + b
        return z1,z2,Qx

    # 计算loss值
    def loss(self, z2, y):
        error = z2 - y
        num_samples = error.shape[0]
        cost = error * error
        cost = np.sum(cost) / num_samples
        return cost

    # 计算梯度
    def gradient(self, x,w1,w2,b,y):
        z1,z2,Qx = self.forward(x,w1,w2,b)
        N = x.shape[0]
        Qx_w2 = [[Qx[i][j]*w2[j][0] for j in range(len(Qx[i]))] for i in range(len(Qx))]
        gradient_w1 = 1. / N * np.sum((z2-y) * Qx_w2, axis=0)
        gradient_w1 = gradient_w1[:, np.newaxis]
        gradient_w2 = 1. / N * np.sum((z2-y) * z1, axis=0)
        gradient_w2 = gradient_w2[:, np.newaxis]
        gradient_b = 1. / N * np.sum(z2-y)
        return gradient_w1,gradient_w2, gradient_b, z1,z2

    # 更新 w ,b
    def update(self, w1,w2, b, gradient_w1, gradient_w2, gradient_b, eta = 0.01):
        w1 = w1 - eta * gradient_w1
        w2 = w2 - eta * gradient_w2
        b = b - eta * gradient_b
        return w1,w2, b

    def train(self, Data_Path, Variable_Count,epoch_Num, batch_size = 10,eta = 0.01):
        print('Start Train')

        # 开始训练前随机初始化 w, b
        w1 = np.random.randn(Variable_Count-1,1)
        w2 = np.random.randn(Variable_Count-1,1)
        b = np.random.randn()

        loss_list = []

        training_data, test_data, D, avgs = self.load_data(Data_Path, Variable_Count)
        n = len(training_data)

        for epoch_id in range(epoch_Num):
            # 每轮训练前打乱数据顺序
            np.random.shuffle(training_data)

            min_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]

            for iter_id, min_batch in enumerate(min_batches):
                x = min_batch[:,:-1]
                y = min_batch[:,-1:]

                gradient_w1,gradient_w2, gradient_b, z1,z2 = self.gradient(x,w1,w2,b,y)
                w1, w2, b = self.update(w1,w2, b, gradient_w1, gradient_w2, gradient_b, eta = 0.01)

                loss = self.loss(z2,y)
                loss_list.append(loss)

                print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, iter_id, loss))
        b = np.array([[b]])
        print('Finish Train')

        np.savetxt("./work/D.txt", D,fmt='%f',delimiter='')
        np.savetxt("./work/avgs.txt", avgs,fmt='%f',delimiter='')
        np.savetxt("./work/w1.txt", w1,fmt='%f',delimiter='')
        np.savetxt("./work/w2.txt", w2,fmt='%f',delimiter='')
        np.savetxt("./work/b.txt", b,fmt='%f',delimiter='')

        # 画出损失函数的变化趋势
        plot_x = np.arange(len(loss_list))
        plot_y = np.array(loss_list)
        plt.plot(plot_x, plot_y)
        plt.show()

    # 一维数组计算
    def calculate(self,x,w1,w2,b):
        Qx = [x[i]**2 for i in range(len(x))]
        z1 =  [Qx[i]*w1[i] for i in range(len(x))]
        z2 = np.dot(z1,w2) + b
        return z2

    def test(self,Data_Path, w1_Path,w2_Path,b_Path):

        y_list = []
        z_list = []
        t_list = []

        w1 = np.fromfile(w1_Path,sep=' ')
        w2 = np.fromfile(w2_Path,sep=' ')
        b = np.fromfile(b_Path,sep=' ')

        Variable_Count = w1.shape[0] + 1

        training_data, test_data, D, avgs = self.load_data(Data_Path, Variable_Count)

        d = D[-1:]
        avg = avgs[-1:]

        for i in range(test_data.shape[0]):
            test_list = test_data[i]
            x = test_list[:-1]
            y = test_list[-1:]

            z2 = self.calculate(x,w1,w2,b)

            y = y*d + avg
            z = z2*d + avg

            y_list.append(y)
            z_list.append(z)
            t_list.append(i)

        plt.title('Result Analysis')
 
        plt.plot(t_list, y_list, color='skyblue', label='y')
        plt.plot(t_list, z_list, color='blue', label='z')
        plt.legend()
 
        plt.xlabel('x')
        plt.ylabel('y')
        plt.show()

    def run (self,x,w1_Path,w2_Path,b_Path,D_Path,avgs_Path):
        w1 = np.fromfile(w1_Path,sep=' ')
        w2 = np.fromfile(w2_Path,sep=' ')
        b = np.fromfile(b_Path,sep=' ')
        D = np.fromfile(D_Path,sep=' ')
        avgs = np.fromfile(avgs_Path,sep=' ')

        d = D[-1:]
        a = avgs[-1:]

        for i in range(len(x)):
            x[i] = (x[i]-avgs[i])/D[i]

        z = self.calculate(x,w1,w2,b)

        z= z*d + a

        return z

if __name__ == "__main__":

    data_path = './work/housing.data'
    w1_Path = './work/w1.txt'
    w2_Path = './work/w2.txt'
    b_Path = './work/b.txt'

    net = Network()

    net.train(data_path,14,50,100)

    net.test(data_path, w1_Path,w2_Path,b_Path)
    
    D_Path = './work/D.txt' 
    avgs_Path = './work/avgs.txt'
    x= np.array([0.04741, 0.00, 11.930, 0, 0.5730, 6.0300, 80.80, 2.5050, 1, 273.0, 21.00, 396.90, 7.88])
    z = float(net.run(x,w1_Path,w2_Path,b_Path,D_Path,avgs_Path))  
    print(z)

5.2 卷积神经网络：vgg、inception、resnet、densenet、alxnet，这几个都是比较经典的在比赛中胜出的模型结构；下面对每个进行简单介绍：VGG模型是2014年ILSVRC竞赛的第二名，第一名是GoogLeNet。但是VGG模型在多个迁移学习任务中的表现要优于googLeNet。而且，从图像中提取CNN特征，VGG模型是首选算法。它的缺点在于，参数量有140M之多，需要更大的存储空间。但是这个模型很有研究价值。

Inception 网络是 CNN 分类器发展史上一个重要的里程碑。在 Inception 出现之前，大部分流行 CNN 仅仅是把卷积层堆叠得越来越多，使网络越来越深，以此希望能够得到更好的性能。

Inception v1

这是 Inception 网络的第一个版本。我们来分析一下它可以解决什么问题，以及如何解决。

在《Going deeper with convolutions》论文中，作者提出一种深度卷积神经网络 Inception，它在 ILSVRC14 中达到了当时最好的分类和检测性能。该架构的主要特点是更好地利用网络内部的计算资源，这通过一个精心制作的设计来实现，该设计允许增加网络的深度和宽度，同时保持计算预算不变。为了优化质量，架构决策基于赫布原则和多尺度处理。作者向 ILSVRC14 提交使用该架构的模型即 GoogLeNet，这是一个 22 层的深度网络，它的质量是在分类和检测领域进行了评估。

论文：Going deeper with convolutions论文链接：https://arxiv.org/pdf/1409.4842v1.pdf

ResNet:MSRA（微软亚洲研究院）何凯明团队的深度残差网络（Deep Residual Network）在2015年的ImageNet上取得冠军，该网络简称为ResNet（由算法Residual命名），层数达到了152层，top-5错误率降到了3.57，而2014年冠军GoogLeNet的错误率是6.7。（何凯明博士，2007年清华大学毕业之后开始在微软亚洲研究院（MSRA）实习，2011年香港中文大学博士毕业后正式加入MSRA，目前在Facebook AI Research (FAIR)实验室担任研究科学家）。

VGGNet和GoogLeNet都显示了网络有足够的深度是模型表现良好的前提，但是在网络达到一定深度之后，简单的网络堆叠反而效果变差了。ResNet指出，在许多的数据库上都显示出一个普遍的现象：增加网络深度到一定程度时，更深的网络意味着更高的训练误差。
 
 
误差升高的原因是网络越深，梯度消失的现象就越明显，所以在后向传播的时候，无法有效的把梯度更新到前面的网络层，靠前的网络层参数无法更新，导致训练和测试效果变差。所以ResNet面临的问题是怎样在增加网络深度的情况下有可以有效解决梯度消失的问题。
 
ResNet中解决深层网络梯度消失的问题的核心结构是残差网络：

DenseNet:作为另一种拥有较深层数的卷积神经网络,具有如下优点:

(1) 相比ResNet拥有更少的参数数量.

(2) 旁路加强了特征的重用.

(3) 网络更易于训练,并具有一定的正则效果.

(4) 缓解了gradient vanishing和model degradation的问题.

何恺明先生在提出ResNet时做出了这样的假设:若某一较深的网络多出另一较浅网络的若干层有能力学习到恒等映射,那么这一较深网络训练得到的模型性能一定不会弱于该浅层网络.通俗的说就是如果对某一网络中增添一些可以学到恒等映射的层组成新的网路,那么最差的结果也是新网络中的这些层在训练后成为恒等映射而不会影响原网络的性能.同样DenseNet在提出时也做过假设:与其多次学习冗余的特征,特征复用是一种更好的特征提取方式.
Alexnet:  AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后，更多的更深的神经网络被提出，比如优秀的vgg,GoogLeNet。 这对于传统的机器学习分类算法而言，已经相当的出色。AlexNet中包含了几个比较新的技术点，也首次在CNN中成功应用了ReLU、Dropout和LRN等Trick。同时AlexNet也使用了GPU进行运算加速。
AlexNet将LeNet的思想发扬光大，把CNN的基本原理应用到了很深很宽的网络中。AlexNet主要使用到的新技术点如下：
（1）成功使用ReLU作为CNN的激活函数，并验证其效果在较深的网络超过了Sigmoid，成功解决了Sigmoid在网络较深时的梯度弥散问题。虽然ReLU激活函数在很久之前就被提出了，但是直到AlexNet的出现才将其发扬光大。
（2）训练时使用Dropout随机忽略一部分神经元，以避免模型过拟合。Dropout虽有单独的论文论述，但是AlexNet将其实用化，通过实践证实了它的效果。在AlexNet中主要是最后几个全连接层使用了Dropout。
（3）在CNN中使用重叠的最大池化。此前CNN中普遍使用平均池化，AlexNet全部使用最大池化，避免平均池化的模糊化效果。并且AlexNet中提出让步长比池化核的尺寸小，这样池化层的输出之间会有重叠和覆盖，提升了特征的丰富性。
（4）提出了LRN层，对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其他反馈较小的神经元，增强了模型的泛化能力。
（5）使用CUDA加速深度卷积网络的训练，利用GPU强大的并行计算能力，处理神经网络训练时大量的矩阵运算。AlexNet使用了两块GTX 580 GPU进行训练，单个GTX 580只有3GB显存，这限制了可训练的网络的最大规模。因此作者将AlexNet分布在两个GPU上，在每个GPU的显存中储存一半的神经元的参数。因为GPU之间通信方便，可以互相访问显存，而不需要通过主机内存，所以同时使用多块GPU也是非常高效的。同时，AlexNet的设计让GPU之间的通信只在网络的某些层进行，控制了通信的性能损耗。 
（6）数据增强，随机地从256*256的原始图像中截取224*224大小的区域（以及水平翻转的镜像），相当于增加了2*(256-224)^2=2048倍的数据量。如果没有数据增强，仅靠原始的数据量，参数众多的CNN会陷入过拟合中，使用了数据增强后可以大大减轻过拟合，提升泛化能力。进行预测时，则是取图片的四个角加中间共5个位置，并进行左右翻转，一共获得10张图片，对他们进行预测并对10次结果求均值。同时，AlexNet论文中提到了会对图像的RGB数据进行PCA处理，并对主成分做一个标准差为0.1的高斯扰动，增加一些噪声，这个Trick可以让错误率再下降1%。

以上就是比较经典的卷积神经网络模型的介绍，感兴趣的可以去CSDN或者去看一下专门的论文，可以加深自己对设计建立、以及对卷积神经网络的理解；但大部分都是建立在这几个模型的基础之上，冻结部分参数进行不断调试来对自己需要的网络进行建模。

作业3-1：

import numpy as np
import matplotlib.pyplot as plt
x = np.arange(-10,11)
y = (np.e**x-np.e**(-x))/(np.e**x+np.e**(-x))
plt.plot(x,y)
plt.show()

作业：3-2：

import numpy as np

p = np.random.randn(10,10)
c = 0
for i in p:
for t in i:
if t>0:
c = c+1
print(c)

作业4-2：新壮-数据挖掘-北京

通过Python、深度学习框架，不同方法写房价预测的比较

相同：

（1）程序的基本结构一致，都包括数据准备，模型设计，训练配置，训练过程，保存模型等部分；

（2）数据准备，训练配置，训练过程环节内容一致

不同：模型设计，训练配置，训练过程，保存模型部分的具体实现

	基于Python	基于飞浆
模型设计	参数尺寸根据输入特征维度手动定义，并进行初始化；需要手动定义损失函数；需要手动计算梯度并更新参数	无需指定参数尺寸，根据输入维度自动生成，并完成初始化；损失函数可选；参数更新一个函数即实现
保存模型	需要手动实现参数保存功能	使用save接口可实现保存变量和模型
编写难易度	需要关心矩阵底层运算，较难	关心逻辑功能即可，编写较容易；需要对框架有较深理解，熟悉常用接口
预测效果-损失 100 epoch，40 batch_size,lr=0.005
预测效果-准确度
训练时间	0.137s，python更快一些，可能跟数据规模有关。当前数据规模较小	1.953s

5-1:对100张图片进行预测，先读取测试集的image数据和标签数据label，然后根据index打乱顺序，创建两个list列表分别存放image和label，进行for循环读取100次，根据index索引，并且将image数据reshape成28x28的，label标签变成int64的；再将list列表变成array数组形式，然后将数组变成飞桨的数据格式；读取模型的参数，对模型进行测试，再得到概率最大的标签，计算标准和预测一样的数据，与100求商取得到准确率。

5-2：计算机视觉网络的模型有Alexnet：

共有5层卷积，3层全连接。

相比于传统的CNN，重要的改动有：

1. 数据增强：图像裁剪（crop），水平翻转；颜色、光照变换（使用PCA对每个像素点RGB分别加一个数）。

2. Dropout：以一定概率使神经元的输出为0，减少过拟合。

3. ReLU：方便计算，求导容易，使网络变得稀疏（类似L1正则），能够更快的学习。

4. Local Response Normalization：局部响应归一化，利用临近的数据做归一化。贡献了1.2%的Top-5正确率。

5. Overlapping Pooling：即Pooling的步长比Pooling Kernel小。贡献了0.3%的Top-5正确率。

6. 多GPU学习。

VGGNnet：

为了解决初始化（权重初始化）等问题，VGG采用的是一种Pre-training的方式，这种方式在经典的神经网络中经常见得到，就是先训练一部分小网络，然后再确保这部分网络稳定之后，再在这基础上逐渐加深。上表从左到右体现的就是这个过程，并且当网络处于D阶段的时候，效果是最优的，因此D阶段的网络也就是最后的VGGNet啦！

相比于AlexNet最大的改进是用小size的Filter代替大size的Filter。两个3*3的卷积核代替5*5的卷积核，三个3*3代替7*7。多个小尺度的卷积核比大尺度的卷积核非线性更强，同时参数减少，不容易过拟合。

GoogleNet：

1. 采用不同大小的卷积核意味着不同大小的感受野，最后拼接意味着不同尺度特征的融合。 

2. 之所以卷积核大小采用1、3和5，主要是为了方便对齐。设定卷积步长stride=1后，只要分别设定pad=0、1、2，那么卷积后便可以得到相同维度的特征，然后这些特征就可以直接拼接在一起了。

3 . 文章说很多地方都表明pooling挺有效，所以Inception里面也嵌入了。

4 .网络越到后面，特征越抽象，而且每个特征所涉及的感受野也更大了，因此随着层数的增加，3x3和5x5卷积的比例也要增加。

5. 使用5x5的卷积核仍然会带来巨大的计算量。为此，文章借鉴NIN，采用1x1卷积核来进行降维。 例如：假定上一层的输出为100x100x128，经过具有256个5x5卷积核的卷积层处理之后(stride=1，pad=2)，输出数据为100x100x256，其中，卷积层的参数为128x5x5x256。假如上一层输出先经过具有32个1x1卷积核的卷积层，再经过具有256个5x5卷积核的卷积层，那么最终的输出数据仍为为100x100x256，但卷积层参数量已经减少为128x1x1x32 + 32x5x5x256，大约减少了4倍。

ResNet:

Resnet的核心思想就是更改了网络结构的学习目的，原本学习的是直接通过卷积得到的图像特征H(X)，现在学习的是图像与特征的残差H(X)-X,这样更改的原因是因为残差学习相比原始特征的直接学习更加容易。

Resnext:

右侧结构很像Inception，而Inception网络的一个动机就是通过稀疏连接近似成large and dense layers。但是Inception中的参数在新数据集上泛化性能不是特别好，会有一堆超参数需要设计。

而ResNeXt将Inception和ResNet很好的结合，跟同期的Inception-ResNet不同，ResNeXt在每个path都采用相同的设计（相同的参数），泛化性能很好。

大致整理：

图像分类：
GoogLeNet
ResNet
图像检测：
R-CNN
Fast R-CNN
Faster R-CNN
基于深度学习的目标检测技术演进：R-CNN、Fast R-CNN、Faster R-CNN
一文读懂Faster RCNN
Mask R-CNN
实例分割模型Mask R-CNN详解：从R-CNN，Fast R-CNN，Faster R-CNN再到Mask R-CNN
Detectron
YOLO
SSD
图像分割：
FCN
DeepLab

5-3:

SGD优化：

adagram优化：

Adam优化：

通过对比可以明显的看出Adam优化算法效果比较好！

学习率=0.1时

学习率 = 0.01时

学习率=0.001时

学习率 = 0.0001

通过对比及下降程度，我选择0.001会使效果更好

作业2-2挑战题：

import numpy as np
import matplotlib.pyplot as plt

def load_data():
    # 从文件导入数据
    datafile = './work/housing.data'
    data = np.fromfile(datafile, sep=' ')

    # 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数
    feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \
                      'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]
    feature_num = len(feature_names)

    # 将原始数据进行Reshape，变成[N, 14]这样的形状
    data = data.reshape([data.shape[0] // feature_num, feature_num])

    # 将原数据集拆分成训练集和测试集
    # 这里使用80%的数据做训练，20%的数据做测试
    # 测试集和训练集必须是没有交集的
    ratio = 0.8
    offset = int(data.shape[0] * ratio)
    training_data = data[:offset]

    # 计算train数据集的最大值，最小值，平均值
    maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), \
                                 training_data.sum(axis=0) / training_data.shape[0]

    # 对数据进行归一化处理
    for i in range(feature_num):
        #print(maximums[i], minimums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

    # 训练集和测试集的划分比例
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data

class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
        # np.random.seed(0)
        self.w_1 = np.random.randn(num_of_weights, num_of_weights)
        self.b_1 = np.zeros((1, num_of_weights))
        self.w_2 = np.random.randn(num_of_weights, 1)
        self.b_2 = 0.
        
    def forward(self, x):
        z_1 = np.dot(x, self.w_1) + self.b_1
        z_2 = np.dot(z_1, self.w_2) + self.b_2
        return z_1, z_2
        
    def loss(self, z, y):
        error = z - y
        num_samples = error.shape[0]
        cost = error * error
        cost = np.sum(cost) / num_samples
        return cost
    
    def gradient(self, x, y):
        z_1, z_2 = self.forward(x)
        N = x.shape[0]
        gradient_w_2 = 1. / N * np.sum((z_2-y) * z_1, axis=0)
        gradient_w_2 = gradient_w_2[:, np.newaxis]
        gradient_b_2 = 1. / N * np.sum((z_2-y))
        gradient_z_2 = np.dot((z_2-y), self.w_2.T)
        gradient_w_1 = 1. / N * np.sum(x * gradient_z_2, axis=0)
        gradient_w_1 = gradient_w_1[:, np.newaxis]
        gradient_b_1 = 1. / N * np.sum(gradient_z_2, axis=0)
        return gradient_w_1, gradient_b_1, gradient_w_2, gradient_b_2
    
    def update_1(self, gradient_w, gradient_b, eta = 0.01):
        self.w_1 = self.w_1 - eta * gradient_w
        self.b_1 = self.b_1 - eta * gradient_b
            
    def update_2(self, gradient_w, gradient_b, eta = 0.01):
        self.w_2 = self.w_2 - eta * gradient_w
        self.b_2 = self.b_2 - eta * gradient_b
                
    def train(self, training_data, num_epoches, batch_size=10, eta=0.01):
        n = len(training_data)
        losses = []
        for epoch_id in range(num_epoches):
            # 在每轮迭代开始之前，将训练数据的顺序随机的打乱，
            # 然后再按每次取batch_size条数据的方式取出
            np.random.shuffle(training_data)
            # 将训练数据进行拆分，每个mini_batch包含batch_size条的数据
            mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
            for iter_id, mini_batch in enumerate(mini_batches):
                #print(self.w.shape)
                #print(self.b)
                x = mini_batch[:, :-1]
                y = mini_batch[:, -1:]
                a_1, a_2 = self.forward(x)
                loss = self.loss(a_2, y)
                gradient_w_1, gradient_b_1, gradient_w_2, gradient_b_2 = self.gradient(x, y)
                self.update_1(gradient_w_1, gradient_b_1, eta)
                self.update_2(gradient_w_2, gradient_b_2, eta)
                losses.append(loss)
                print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.
                                 format(epoch_id, iter_id, loss))
        
        return losses

# 获取数据
train_data, test_data = load_data()

# 创建网络
net = Network(13)
# 启动训练
losses = net.train(train_data, num_epoches=500, batch_size=100, eta=0.1)

# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

作业4-2：

基于Python编写的模型和基于飞桨编写的模型的异同如下：

相同点：

1. 从模型功能上看，二者都是实现对波士顿房价的预测，同时二者使用的都是全连接神经网络，同样采用梯度下降优化算法，使用均方误差作为损失函数；
2. 从预处理上看，两者使用的代码是一致的；
3. 从预测的结果来看，两者的结果是非常接近的，最后损失的结果相差不大。
不同点：

1. 从代码编写上来看，由于飞桨本身封装了大量固定的层结构、自动求导与参数更新、以及大量优化算法和损失函数，因此使用框架在代码编写上方便了很多、程序结构也相对简单了很多，只需定义好网络结构，调用飞桨封装的层进行前向计算即可，无需关注梯度和参数更新；
2. 从训练速度上来看，就房价预测的案例来说，由于数据量太小，飞桨框架并没有展现出太大的优势，二者在耗时上几乎相当。但从正常大数据的情况来看，只用CPU计算，使用飞桨框架会比Python编写的模型快出许多，这是由于飞桨底层使用C++实现，编译执行速度远高于Python；若可以使用GPU计算的情况下，飞桨底层封装了CUDA的调用，由于GPU本身包含大量计算核心，可实现高速并行计算，其计算训练效率远非纯Python程序可比。

作业5：

5-1：

params_path = "./checkpoint/mnist_epoch0"
#在使用GPU机器时，可以将use_gpu变量设置成True
use_gpu = False
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()

with fluid.dygraph.guard(place):
# 加载模型参数到模型中
params_dict, opt_dict = fluid.load_dygraph(params_path)
model = MNIST("mnist")
model.load_dict(params_dict)

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.forward(image, label)
avg_acc = fluid.layers.mean(acc)


print("avg_loss:{}".format(avg_acc.numpy()))

5-2：

典型的卷积神经网络有如下：

LeNet,AlexNet,VGGNet,Inception,ResNet,DenseNet,MobileNet,ShuffleNet,DarkNet

5-3:

Adam优化算法下降Loss值更快

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

1.程序结构上：飞桨编写的程序更加简洁明了，易于阅读，方便维护，而python编写的程序则显得十分繁杂，易读性和维护性较差。

2.编写难易程度上：python 编写的模型需要编写大量代码，如果模型结构比较复杂，比如VGG，Resnet等网络，其反向传播方法的工作量是十分巨大的，而使用飞桨编写的模型，在代码上更加简洁，飞桨提供的一些封装好的API方法，比如反向传播，各种优化器等极大的减少了开发者的工作量，这样就使得我们可以把更多的精力放在如何优化模型上，而不是去做这些与模型优化关系不大的繁琐工作。

3.模型的预测效果上：飞桨编写的模型其原理上与python编写的模型是相同的，故模型预测结果差异不会太大。

4.训练耗时上：飞桨提供给我们许多预训练模型，所以对于一些现有的模型或者只需要在自身特定的数据集上调优就可获得较好效果的任务上，我们不需要再从头开始训练，可以节省很多时间，而python编写的程序则需要从头开始训练，训练成本高。

5-1:

基于2-8 【手写数字识别】之训练调试与优化续写（参考了一些帖子），在原始数据集随机抽取100张进行测试

5-2：

常见的卷积网络结构

1.LeNet-5：CNN鼻祖，使用5层网络，在邮政编码数字分类上实现了好的效果；

2.AlexNet，2012年ImageNet竞赛超过第二名10.9个百分点的绝对优势一举夺冠，使得深度学习又一次崛起，使用5层卷积+3个全链接层，softmax实现1000分类；第一次使用数据增广；用ReLU代替Sigmid增加收敛速度；使用多GPU计算；加入Dropout等；

3.VGGNet，全名：《Very Deep Convolutional Networks for Large-Scale Visual Recognition》，顾名思义层数非常多，高达十多层，使用了Pre-training的方式，加入BatchNormalization。

4.GoogLeNet：2014的ImageNet分类任务上击败了VGG-Nets夺得冠军，除了更深的网络，还在网络结构上做了创新，引入Inception结构代替了单纯的卷积+激活的传统操作，引入Inception结构，一个Block通过1x1卷积 池化 3x3 卷积 5x5卷积，最后在通道维上连结，实现较好的准确率

5.NiN，（Network in Network）通过在卷积层中加入多层1x1卷积核，来达到全连接层的效果，实现更好的非线性变换

6.ResNet，何凯明大神在2015年推出，横扫所有对手，引入残差结构，实现恒等映射，防止过深的网络导致梯度消失，这样的结构延续至今，可以结合目前流行的网络使用。

7.DenseNet，CVPR 2017最佳论文，（Dense Convolutional Network），和ResNet及Inception网络做对比，思想上有借鉴，但却是全新的结构，特点是采用密集连接：缓解梯度消失问题，加强特征传播，鼓励特征复用，极大的减少了参数量。

8.MobileNet，提出Depthwise和Separable卷积，在达到普通卷积效果的同时，减少参数量

9.ShuffleNet，引入通道混洗的概念，进一步减少计算量

10.Mixnet， 通过多个卷积核卷积连结，减小参数量的同时提高精度

11.SEnet，创新性的引入SEBlock，计算每个通道的重要性并与对应特征图相乘，并且不需要改动原有的网络结构就可以将SEBlock应用在其他结构当中,目前很多新的网络中都有此结构。

12.ResNeXt：2017ILSVRC，简要概述：增加了子模块的拓扑结构；cardinality（基数）；网络研究中提高增加 cardinality 比增加深度和宽度更有效；可以实现在不增加参数复杂度的前提下提高准确率,减少了超参数的数量；

13.EfficientNet：2019ICML对于分辨率更高的图像，应该增加网络深度，因为需要更大的感受野来帮助捕获更多像素点的类似特征，同时也应该增加网络宽度来获得更细粒度的特征。此网络在网络深度、宽度和分辨率之间论述其平衡的关系，实现更好的网络效果；

14：Res2Net：在一个单个残差块内构造分层的残差类连接，为CNN提出了一种新的构建模块，即Res2Net——以更细粒度（granular level）表示多尺度特征，并增加每个网络层的感受野（receptive fields）范围。 Res2Net是一种简洁有效的模块，探索了 CNN 在更细粒度级别的多尺度表达能力。它揭示了 CNN 网络里面除了深度，宽度等现有维度之外，还可以有新的维度“尺度”。Res2Net 模块可以很容易地融合进 SOTA 的方法。在 CIFAR10 和 ImageNet 上图像分类的结果表明，使用 Res2Net 模块的网络比 ResNet，ResNeXt，DLA 等网络效果更好。

5-3：

SGD：

RMSProp：

Adam：

通过实验发现0.001的学习率可以有不错的效果，Adam会收敛快一些，SGD可以继续调出更好的效果，如果原始的0.01学习率在Adam上会使得loss变化剧烈。

Adam0.01学习率的情况：

作业2-1（2）挑战题：

$$z^l_{jx} = \sum_k w^l_{jk} z^{l-1}_{kx} + b^l_j \qquad (1)$$

作业4-2：

Paddle与其他框架基本相同。对于初学者，就是看相关文档介绍的是否通俗易懂。至于实现新结构和损失函数还不到那个程度。预测效果和训练的资源与耗时那更是工业中才会考虑的了。

作业5-1：

模型训练使用SGDOptimizer(learning_rate=0.01)  损失: [0.07738254], 准确： [0.98]

#测试模型
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()))

#计算多个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))

结果100张图片平均损失及准确为loss=0.08795965792611242, acc=0.9751000100374222

5-2：

常见神经网络有：AlexNet、VGG，ResNet，DenseNet 目标检测有：FastR-CNN、YOLOv3、SDD

5-3:

首先确定最优的优化算法，根据loss情况选定为Momentum 

loss_all = []
with fluid.dygraph.guard(place):
model = MNIST("mnist")
model.train()

#四种优化算法的设置方案，可以逐一尝试效果

SGD = fluid.optimizer.SGDOptimizer(learning_rate=0.01)
Momentum = fluid.optimizer.MomentumOptimizer(learning_rate=0.01, momentum=0.9)
Adagrad = fluid.optimizer.AdagradOptimizer(learning_rate=0.01)
Adam = fluid.optimizer.AdamOptimizer(learning_rate=0.01)
opt = [SGD, Momentum, Adagrad, Adam]
rate = [0.01, 0.001, 0.0001]
for i in opt:
optimizer = i
EPOCH_NUM = 5
iter=0
iters=[]
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, avg_acc = model(image, label)

#计算损失，取一个批次样本损失的平均值
loss = fluid.layers.cross_entropy(predict, label)
avg_loss = fluid.layers.mean(loss)

#每训练了100批次的数据，打印下当前Loss的情况
if batch_id % 100 == 0:
print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(),avg_acc.numpy()))
iters.append(iter)
losses.append(avg_loss.numpy())
iter = iter + 100

#后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
loss_all.append(losses)
#保存模型参数
fluid.save_dygraph(model.state_dict(), 'mnist')

#画出训练过程中Loss的变化曲线

plt.figure()
plt.title("train loss", fontsize=24)
plt.xlabel("iter", fontsize=14)
plt.ylabel("loss", fontsize=14)
plt.plot(iters, loss_all[0],color='red',label='SGD loss')
plt.plot(iters, loss_all[1],color='red',label='Momentum loss')
plt.plot(iters, loss_all[2],color='red',label='Adagrad loss')
plt.plot(iters, loss_all[3],color='red',label='Adam loss')

plt.legend(('SGD loss', 'Momentum loss', 'Adagrad loss', 'Adam loss'), loc='upper right')
plt.grid()
plt.show()

接着使用不同的学习率查看损失

rate = [0.01, 0.001, 0.0001]
for i in rate:
optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=i, momentum=0.9)

...

plt.figure()
plt.title("train loss", fontsize=24)
plt.xlabel("iter", fontsize=14)
plt.ylabel("loss", fontsize=14)
plt.plot(iters, loss_all[0],color='r',label='rate=0.01')
plt.plot(iters, loss_all[1],color='b',label='rate=0.001')
plt.plot(iters, loss_all[2],color='g',label='rate=0.0001')

plt.legend(('rate=0.01', 'rate=0.001', 'rate=0.0001'), loc='upper right')
plt.grid()
plt.show()

作业4-2:

通过Python、深度学习框架，不同方法写房价预测，Python编写的模型 和 基于飞桨编写的模型在程序结构方面是相同的，但是在难易度上，飞桨更容易些。训练的耗时，因为飞桨专门优化过，要比普通没优化过的要快很多

作业3-1

（1）

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.patches as patches

#设置图片大小
plt.figure(figsize=(8, 3))

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
x = np.arange(-10, 10, 0.1)

# 计算tanh函数
t = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

# 将tanh的函数图像画在左边
f = plt.subplot(121)
# 画出函数曲线
plt.plot(x, t, color='y')
# 添加文字说明
plt.text(-6., 0.9, r'$y=tan(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

（2）

import numpy as np
p = np.random.randn(10, 10)
q = p > 0
print(q.sum())

51

作业5：李洪杰

作业5-1：程序及运行结果如下所示，准确率为28%

test_data = paddle.dataset.mnist.test()
test_reader = paddle.batch(test_data, batch_size=100)

with fluid.dygraph.guard():
    model = MNIST('mnist')
    model_dict,_ = fluid.load_dygraph("mnist")
    model.load_dict(model_dict)
    model.eval()
    
    for id, data in enumerate(test_reader()):
        img_data = np.array([x[0] for x in data]).astype(np.float32)
        lbl_data = np.array([x[1] for x in data]).reshape(-1,1).astype(np.float32)
        predict = model(fluid.dygraph.to_variable(img_data))
        result = (predict.numpy().astype(np.int32) == lbl_data)
        print("Accuracy is: {}".format(np.sum(result)/result.shape[0]))
        break

作业5-2：常见的卷积神经网络包括：LeNet、AlexNet、VGG、GoogLenet、ResNet、DenseNet等等。关于这几种卷积神经网络的简单介绍如下：

1）LeNet：LeNet诞生于1994年，由深度学习三巨头之一的Yan LeCun提出，他也被称为卷积神经网络之父。LeNet主要用来进行手写字符的识别与分类，准确率达到了98%，并在美国的银行中投入了使用，被用于读取北美约10%的支票。LeNet奠定了现代卷积神经网络的基础。

2）AlexNet：AlexNet由Hinton的学生Alex Krizhevsky于2012年提出，并在当年取得了Imagenet比赛冠军。AlexNet可以算是LeNet的一种更深更宽的版本，证明了卷积神经网络在复杂模型下的有效性，算是神经网络在低谷期的第一次发声，确立了深度学习，或者说卷积神经网络在计算机视觉中的统治地位。

3）VGG：VGGNet是牛津大学计算机视觉组和Google DeepMind公司一起研发的深度卷积神经网络，并取得了2014年Imagenet比赛定位项目第一名和分类项目第二名。该网络主要是泛化性能很好，容易迁移到其他的图像识别项目上，可以下载VGGNet训练好的参数进行很好的初始化权重操作，很多卷积神经网络都是以该网络为基础，比如FCN，UNet，SegNet等。vgg版本很多，常用的是VGG16，VGG19网络。

4）ResNet：ResNet（残差神经网络）由微软研究院的何凯明等4名华人于2015年提出，成功训练了152层超级深的卷积神经网络，效果非常突出，而且容易结合到其他网络结构中。

作业5-3：通过下面的代码及运行结果可以看出，Adam优化算法最优，学习率在0.001到0.01之间，如果学习率过大（0.1）会震荡不能收敛，过小（0.0001）则收敛速度很慢。

代码如下：

#仅优化算法的设置有所差别
def train(optimizer, ls, name):
    print(name, ": Start training...... ")
    place = fluid.CUDAPlace(0)
    with fluid.dygraph.guard(place = place):
        model = MNIST("mnist")
        model.train()
        #调用加载数据的函数
        train_loader = load_data('train')
        EPOCH_NUM = 5
        iter = 0
        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 = model(image)
                
                #计算损失，取一个批次样本损失的平均值
                loss = fluid.layers.cross_entropy(predict, label)
                avg_loss = fluid.layers.mean(loss)
                
                if batch_id%100 == 0:
                    ls.append((iter, avg_loss.numpy()))
                    iter += 100
                
                #每训练了100批次的数据，打印下当前Loss的情况
                if batch_id % 200 == 0:
                    print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
                
                #后向传播，更新参数的过程
                avg_loss.backward()
                optimizer.minimize(avg_loss)
                model.clear_gradients()
    
        #保存模型参数
        fluid.save_dygraph(model.state_dict(), name)

all_losses = []
for opt in opts:
    losses = []
    for lr in lrs:
        if opt == "SGD":
            optimizer = fluid.optimizer.SGDOptimizer(learning_rate = lr)
        elif opt == "Momentum":
            optimizer = fluid.optimizer.MomentumOptimizer(learning_rate = lr, momentum = 0.1)
        elif opt == "Adagrad":
            optimizer = fluid.optimizer.AdagradOptimizer(learning_rate = lr)
        elif opt == "Adam":
            optimizer = fluid.optimizer.AdamOptimizer(learning_rate = lr)
        
        loss = []
        train(optimizer, loss, opt+'_'+str(lr))
        losses.append(loss)
    all_losses.append(losses)
 
import matplotlib.pyplot as plt
%matplotlib inline
opts = ['SGD','Momentum','Adagrad','Adam']
lrs = [0.0001, 0.001, 0.01, 0.1]

colors = ['red', 'blue', 'green', 'orange']
markers = ['+', 'x', 'o', 's']   
for i,losses in enumerate(all_losses):   
    for j,lss in enumerate(losses):
        xx = [ls[0] for ls in lss]
        yy = [ls[1] for ls in lss]
        plt.plot(xx, yy, color=colors[j], marker=markers[j])
    legends = [opts[i]+"_"+str(lr) for lr in lrs]
    plt.title(opts[i]+" Optimizer")
    plt.legend(legends,loc=1)
    plt.xlabel('iterations')
    plt.ylabel('loss')
    plt.show()

作业5-1

#读取单张图片做预测。应为当前定义的网络不太能接受单张图片和标签，故将数据填充到100维，数据项为100，1，28，28.标签项为100，1。数据内容雷同。由于测试数据集与训练数据集差别极大，预测结果为8

import numpy as np
from PIL import ImageChops
import matplotlib.pyplot as plt
#设置图像地址
Datapath = "./test0.bmp"
# 打开图像,本身为数字矩阵(28x28x3)
imgs = np.array(Image.open(Datapath))
print(img_Slice.shape)
#取第一通道
imgs_Slice = imgs[:, :, 0]
img_Slice = np.copy(imgs_Slice)

IMG_ROWS = 28
IMG_COLS = 28

#整理数据类型，归一化
img = np.reshape(img_Slice, [1, IMG_ROWS, IMG_COLS]).astype('float32')
img = img/255
label = np.array([0])
#print(imgs)
imgs_list = []
labels_list = []
# 按照索引读取数据
for i in np.arange(100):
# 读取图像和标签，转换其尺寸和类型
imgTemp = np.reshape(img, [1, IMG_ROWS, IMG_COLS]).astype('float32')
labelTemp = np.reshape(label, [1]).astype('int64')
imgs_list.append(imgTemp)
labels_list.append(labelTemp)
imgsT = np.array(imgs_list)
lableT = np.array(labels_list)
print(imgsT.shape)
print(lableT.shape)

#做预测

with fluid.dygraph.guard():
model = MNIST("mnist")
model_state_dict, _ = fluid.load_dygraph('mnist')
model.load_dict(model_state_dict)

model.eval()

imgt = fluid.dygraph.to_variable(imgsT)
labelt = fluid.dygraph.to_variable(lableT)
prediction, acc = model(imgt, labelt)
loss = fluid.layers.cross_entropy(input=prediction, label=labelt)
for i in np.arange(1):
print(prediction[i])
print("预测结果为:",format(8))
print("损失为：",format(loss[0]))
plt.imshow(img_Slice)

#2019-12-25从minist数据集的验证集中随机抽取100对象检查模型精确度
# 加载相关库，以evalu
import os
import random
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC
import numpy as np
from PIL import Image

import gzip
import json

# 定义数据集读取器
def my_load_data(mode='eval'):

# 读取数据文件
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
data = json.load(gzip.open(datafile))
# 读取数据集中的训练集，验证集和测试集
train_set, val_set, eval_set = data

# 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
IMG_ROWS = 28
IMG_COLS = 28
# 根据输入mode参数决定使用训练集，验证集还是测试
if mode == 'eval':
imgs = eval_set[0]
labels = eval_set[1]

else:
    return

# 获得所有图像的数量
imgs_length = len(imgs)
# 验证图像数量和标签数量是否一致
assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})".format(
len(imgs), len(labels))

index_list = list(range(imgs_length))

# 读入数据时用到的batchsize
BATCHSIZE = 100

# 定义数据生成器
def data_generator():
# 测试模式下，打乱训练数据
if mode == 'eval':
random.shuffle(index_list)
imgs_list = []
labels_list = []
# 按照索引读取数据
for i in index_list:
# 读取图像和标签，转换其尺寸和类型
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('int64')
imgs_list.append(img)
labels_list.append(label)
# 如果当前数据缓存达到了batch size，就返回一个批次数据
if len(imgs_list) == BATCHSIZE:
    return np.array(imgs_list), np.array(labels_list)
# 清空数据缓存列表
imgs_list = []
labels_list = []

# 如果剩余数据的数目小于BATCHSIZE，
# 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
if len(imgs_list) > 0:
    return np.array(imgs_list), np.array(labels_list)

return data_generator

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 = my_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()))

#计算多个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))

#运行结果。在同分布的数据集上，效果还是很好的

start evaluation .......
loading mnist dataset from ./work/mnist.json.gz ......
loss=0.09338625706732273, acc=0.9850000143051147

作业5-2：

常见的卷积神经网络包括：

诞生于1994年的LeNet.共6层，包括三个卷积层、两个下采样层、一个全连接层

诞生于2012年的AlexNet.共8层。含5层卷积，3个全连接层。第4、5、6层卷积层结构一致。

诞生于2014年的VGGNet.网络深度增至16层。自第5层卷积层开始，结构一致。

诞生于2015年ResNet.网络深度增至34层，采用残差结构，仅使用一层全连接层。

作业5-3：

手写数字识别问题上，0.01学习率下，SGD效果最好，识别精度能达到98%以上。

0.01学习率下，ADAM能够依学习情况自动调整合适的学习率，收敛速度最快，识别精度在96%以上。

作业5-1：

1) 数字0

2) 随机抽取100张

作业5-2 计算机视觉常见卷积网络：

LeNet、Alexnet、GoogleNet、VGG、ResNext、ShuffleNet、MobileNet

作业5-3 哪种算法最好？最优学习率是？

优化器效果比较结果为:

Adam>Adagrad>Momentum>SGD。

2. 优化器Adam学习率在0.002时最优。

作业5：

作业5-1

借助2-8中的程序，可以直接进行测试，每次以100张为一个batch，其准确率如下图所示。第一个batch的准确率为0.99，总体准确率为0.97。

作业5-2：

AlexNet，VGG，ResNet，GoogleNet，mask rcnn，GAN，Deeplab系列，U-Net，ERFNet等

作业5-3：

SGD算法，步长0.01：

SGD算法，步长0.05：

SGD算法，步长0.1：

Momentum算法中还需要设置momentum参数，参数设置不同会导致结果不同，不再讨论。

Adagrad算法，步长0.01：

Adagrad算法，步长0.05：

Adagrad算法，步长0.1：

Adam算法，步长0.01：

Adam算法，步长0.05：

Adam算法，步长0.1：

由于不同的优化算法又有不同的步长，仅以这9组实验无法精确判断哪种优化算法在多大步长下最好。请多参考实验较为丰富的答案。

作业5-1：

训练集使用paddle-api的mnist.train()，epoch_num = 5，AdamOptimizer，learning_rate = 0.001

参数选择依据：作业5-3的测试结果

测试集mnist.test()，总测试数据量10k，准确度91.76%

随机100张图片

作业5-2：

计算机视觉中常见的网络结构：AlexNet，VGG，GoogleNet，ResNet，SSD,YOLO,RCNN等

参见：https:（恶）//github.com（意）/PaddlePaddle（推）/models/tree/（广）develop/PaddleCV

作业5-3：

mnist简单且效果出色，在合适的参数下，训练2批次也能取得较好的结果。

Adagrad，Adam在lr=0.1（较大）时，不适合此模型，loss下降与准确率均不理想

lr在0.01，0.001时，各个优化器均有较好的表现。

从上面2图看出，训练批次大约5左右，loss，acc大都变化趋势很小。