DNN深度神经网络的参数、结构对比

一、参数与结构

参数与结构主要是包含：

  1. 网络层数

  2. 不同隐含层个数

  3. 不同激活函数（隐含层的Sigmoid() 函数，Relu() 函数。注：输出层是统一的softmax()函数）)

  4. 不同超参数（包含随机初始化权重值，学习率，训练（迭代）次数）

  5. 优化方法

二、网络层数

2.1 网络层数：

越来越深，输入层和输出层神经元个数不变，一个输入层一个输出层。保持学习率，隐含层神经元个数，激活函数、初始化权重值，训练次数不变。

layer 结果
[784, 100, 10] 收敛过程1704214307620
1704214336664 学习结果1704214392337
泛化能力
[784, 100, 75, 10] 收敛过程：1704213206246
1704212863831 学习结果1704255754628
泛化能力
[784, 100, 75, 50,10] 收敛过程1704214802785
学习结果1704214784606
泛化能力

结论：网络越深，收敛的越慢，一定的深度增加测试集合的准确率和验证集的准确率。

2.2 不同隐含层神经元个数

增加隐含层神经元的个数，使用四层网络的结构，保持训练次数500，学习率0.01，使用relu激活函数。

layer 结果
[784, 100, 75, 10] 收敛过程1704213206246
学习结果1704213232090
泛化能力
[784, 200, 150, 10] 收敛过程1704255662678
学习结果1704255685680
泛化能力
[784, 300,225,10] 收敛过程1704256528864
学习结果1704256521924
泛化能力

结论：随着隐含层的神经元个数的增加，

2.3 不同激活函数

（1）Sigmoid() 函数：

函数表达式：$$Sigmoid(x)=\frac{1}{1+e^{-x}}$$

代码实现：

1
2
3
4
def sigmoid(Z):
    A = 1/(1+np.exp(-Z))
    cache = Z
    return A, cache

其导函数为：f(x)=1+e−x1=*ex*+1*ex*=1−(*e*x*+1)−1

代码实现：

1
2
3
4
5
def sigmoid_backward(dA, cache):
    Z = cache
    s = 1/(1+np.exp(-Z))
    dZ = dA * s * (1-s)
    return dZ

（2）Relu() 函数：

函数表达式：$$f\left( x \right) ,,=,,Max\left( 0,x \right) $$
代码实现：

1
2
3
4
def relu(Z):
    A = np.maximum(0,Z)
    cache = Z
    return A, cache

其导函数为：$$
f\left( x \right) ’ =,,\begin{cases}
0 , x,,=,,0;\
1 , x,,\ne ,,0;\
\end{cases}
$$

代码实现：

1
2
3
4
5
def relu_backward(dA, cache):
    Z = cache
    dZ = np.array(dA, copy=True)
    dZ[Z <= 0] = 0
    return dZ

（3） 两个激活函数的对比

再相同的网络结构、参数下进行训练：[784, 100, 75, 10]

结果：

relu（） sigmoid（）
1704256826607 1704256866516
收敛过程： 1704213206246 1704258199041
学习结果与泛化能力： 1704255754628 1704258190910

总结：一开始sigmoid（）函数收敛快，但是到某一点的时候，收敛速度陡然下降，并几乎为一个常数。relu（）函数则从开始到最后都保持一个很好的稳定性。且在MINIST数据集上，sigmod函数效果比relu函数的差。

2.4 不同超参数

（1）随机初始化权重值 （通过改变np.random.seed(3)随机种子值来设置初始化权重参数）

1
2
3
4
5
6
7
8
def init_W(layers_dims):
    np.random.seed(3)
    parameters = {}
    L = len(layers_dims)
    for l in range(1, L):
        parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) / np.sqrt(layers_dims[l - 1])
        parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))
    return parameters

（2）学习率

改变代码中的learning_rate=0.0075（默认），改变学习率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def deepnet(X, Y,net_layers,learning_rate=0.0075, num_iterations=3000,step =1, print_cost=False, isPlot=True):
    np.random.seed(1) #设计种子
    costs = [] #用于画图
    parameters = init_W(net_layers)
    for i in range(0, num_iterations):
        # 迭代
        AL, caches = L_forword(X, parameters)

        costi = cost(AL, Y) #这里的Y是标准化的Y

        grads = L_model_backward(AL, Y, caches,"softmax")

        parameters = update_parameters(parameters, grads, learning_rate)

        if i % step == 0:
            # 记录成本
            costs.append(costi)
            # 是否打印成本值
            if print_cost:
                print("第", i, "次迭代，成本值为：", np.squeeze(costi))


    if isPlot:
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()
        # plt.savefig(fnme = "cast"+str(datetime.datetime.now())+".jig")
    return parameters

使用网络结构为[784, 50,35,10]，500的迭代次数。

learning_rate 结果
0.01 收敛过程1704259997141
学习结果1704260013837
0.1 收敛过程1704260240515
学习结果与泛化能力1704260257343
1 收敛过程1704260474926
学习结果泛化能力1704260491851

总结：学习率选择合适对网络非常重要，过小等于0.01时，收敛慢，过大等于1时导致在最优值左右摆动。

（3）训练（迭代）次数

改变代码中的num_iterations=3000，改变训练（迭代）次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def deepnet(X, Y,net_layers,learning_rate=0.0075, num_iterations=3000,step =1, print_cost=False, isPlot=True):
    np.random.seed(1) #设计种子
    costs = [] #用于画图
    parameters = init_W(net_layers)
    for i in range(0, num_iterations):
        # 迭代
        AL, caches = L_forword(X, parameters)

        costi = cost(AL, Y) #这里的Y是标准化的Y

        grads = L_model_backward(AL, Y, caches,"softmax")

        parameters = update_parameters(parameters, grads, learning_rate)

        if i % step == 0:
            # 记录成本
            costs.append(costi)
            # 是否打印成本值
            if print_cost:
                print("第", i, "次迭代，成本值为：", np.squeeze(costi))


    if isPlot:
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()
        # plt.savefig(fnme = "cast"+str(datetime.datetime.now())+".jig")
    return parameters

[784, 50,35,10]

num_iterations 结果
500 收敛过程 第 490 次迭代，成本值为： 0.213061341423906261704260240515
学习结果1704260013837
泛化能力
1000 收敛过程 第 950 次迭代，成本值为： 0.20895630481856121704261316326
学习结果1704261278193
泛化能力

总结：在正常情况下，随着迭代次数的增多，网络效果越好。