一般而言，我們把有兩層或兩層以上隱藏層的網絡叫做深度網絡。我們通常用字母L來表示神經網絡的層數（輸入層不被計算在內），用字母n來表示該層神經元的個數。

以人臉識別舉例

舉例來說，如果一個四層的神經網絡在用來進行人臉識別的時候。第一層的每一個神經元都有可能學習出一類線條的特性。比如一個神經元學習到了豎線條的特性，一個神經元學習到橫線條的特性。第二層的神經元就有可能學習得出了一個器官的特性。比如一個學到了眼睛的特性，一個學到了鼻子的特性。那麼在第三層，神經元才學習到了人臉的特性，才能夠識別出各種人臉。

什麼是遷移學習？

  1.  遷移學習：正是因為深度學習的這種層次的特性，使得後面我們將學習到的遷移學習成為可能。遷移學習非常強大，我們可以簡單地改一下已經訓練好的神經網絡模型讓他來解決一個新的問題。
  • assert：核對矩陣的維度
  • 廣播（Broadcast）是numpy對不同形狀（shape）的數組進行數值計算的方式。

    樣本維度公式

    訓練樣本是什麼？网上有人说 经常采用的是m-folder cross validation的方法，把样本分成m份，轮流把其中一份作为测试集。至于m取多少看样本数量而定，样本充足的话m＝10，另外m＝3也是经常被使用的。
    螢幕擷取畫面 2021-08-03 150503.png

    超參數

  1. 學習率
  2. 正則化參數
  3. 神經網絡的層數
  4. 每一個隱藏層中神經元的個數
  5. 學習的回合數Epoch
  6. 小批量數據minibatch的大小
  7. 輸出神經元的編碼方式
  8. 代價函數的選擇
  9. 權重初始化的方法
  10. 神經元激活函數的種類
  11. 參加訓練模型數據的規模

這些都可以影響神經網絡學習速度和最後分類結果的。
2,3,4,7：主要影響神經網絡的正確分類率。
9：主要影響代價函數曲線下降速度，有時侯也會影響正確率。
1,8,10：主要影響學習速度，這點主要體現在代價函數曲線的下降速度上。
5,6,11：主要影響模型分類正確率和訓練用總體時間。

卷積網絡通常被用於圖像數據。遞歸神經網絡被用於序列數據。

實作

1 - 初始化w和b

  1. # 该函数用于初始化所有层的参数w和b
  2. def initialize_parameters_deep(layer_dims):
  3.     """
  4.     参数:
  5.     layer_dims -- 这个list列表里面，包含了每层的神经元个数。
  6.     例如，layer_dims=[5,4,3]，表示输入层有5个神经元，第一层有4个，最后二层有3个神经元
  8.     返回值:
  9.     parameters -- 这个字典里面包含了每层对应的已经初始化了的W和b。
  10.     例如，parameters['W1']装载了第一层的w，parameters['b1']装载了第一层的b
  11.     """
  12.     np.random.seed(1)
  13.     parameters = {}
  14.     L = len(layer_dims) # 获取神经网络总共有几层
  16.     # 遍历每一层，为每一层的W和b进行初始化
  17.     for l in range(1, L):
  18.         # 构建并随机初始化该层的W。由我前面的文章《1.4.3 核对矩阵的维度》可知，Wl的维度是(n[l] , n[l-1]) 
  19.         parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l - 1]) / np.sqrt(layer_dims[l-1])
  20.         # 构建并初始化b
  21.         parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
  23.         # 核对一下W和b的维度是我们预期的维度
  24.         assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l - 1]))
  25.         assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))
  27.     #就是利用上面的循环，我们就可以为任意层数的神经网络进行参数初始化，只要我们提供每一层的神经元个数就可以了。       
  28.     return parameters

2 - 向前傳播

下面的linear_forward用于实现公式 𝑍[𝑙]=𝑊[𝑙]𝐴[𝑙−1]+𝑏[𝑙]Z[l]=W[l]A[l−1]+b[l]，这个称之为线性前向传播。

  1. def linear_forward(A, W, b):   
  2.     Z = np.dot(W, A) + b
  4.     assert(Z.shape == (W.shape[0], A.shape[1]))
  5.     cache = (A, W, b) # 将这些变量保存起来，因为后面进行反向传播时会用到它们
  7.     return Z, cache

下面的linear_activation_forward用于实现公式 𝐴[𝑙]=𝑔(𝑍[𝑙])A[l]=g(Z[l])，g代表激活函数，使用了激活函数之后上面的线性前向传播就变成了非线性前向传播了。在dnn_utils.py中我们自定义了两个激活函数，sigmoid和relu。它们都会根据传入的Z计算出A。

  1. def linear_activation_forward(A_prev, W, b, activation):
  2.     """
  3.     Arguments:
  4.     A_prev -- 上一层得到的A，输入到本层来计算Z和本层的A。第一层时A_prev就是特征输入X
  5.     W -- 本层相关的W
  6.     b -- 本层相关的b
  7.     activation -- 两个字符串，"sigmoid"或"relu"，指示该层应该使用哪种激活函数
  8.     """
  10.     Z, linear_cache = linear_forward(A_prev, W, b)
  12.     if activation == "sigmoid": # 如果该层使用sigmoid        
  13.         A = sigmoid(Z) 
  14.     elif activation == "relu":
  15.         A = relu(Z)
  17.     assert (A.shape == (W.shape[0], A_prev.shape[1]))
  18.     cache = (linear_cache, Z) # 缓存一些变量，后面的反向传播会用到它们
  20.     return A, cache
  1. # 这个函数构建了一个完整的前向传播过程。这个前向传播一共有L层，前面的L-1层用的激活函数是relu，最后一层使用sigmoid。
  2. def L_model_forward(X, parameters):
  3.     """
  4.     参数:
  5.     X -- 输入的特征数据
  6.     parameters -- 这个list列表里面包含了每一层的参数w和b
  7.     """
  9.     caches = []
  10.     A = X
  12.     # 获取参数列表的长度，这个长度的一半就是神经网络的层数。
  13.     # 为什么是一半呢？因为列表是这样的[w1,b1,w2,b2...wl,bl],里面的w1和b1代表了一层
  14.     L = len(parameters) // 2  
  16.     # 循环L-1次，即进行L-1步前向传播，每一步使用的激活函数都是relu
  17.     for l in range(1, L):
  18.         A_prev = A 
  19.         A, cache = linear_activation_forward(A_prev,
  20.                                              parameters['W' + str(l)], 
  21.                                              parameters['b' + str(l)],
  22.                                              activation='relu')
  23.         caches.append(cache)# 把一些变量数据保存起来，以便后面的反向传播使用
  26.     # 进行最后一层的前向传播，这一层的激活函数是sigmoid。得出的AL就是y'预测值
  27.     AL, cache = linear_activation_forward(A, 
  28.                                           parameters['W' + str(L)], 
  29.                                           parameters['b' + str(L)], 
  30.                                           activation='sigmoid')
  31.     caches.append(cache)
  33.     assert(AL.shape == (1, X.shape[1]))
  35.     return AL, caches

3 - 訓練成本

  1. # 上面已经完成了前向传播了。下面这个函数用于计算成本（单个样本时是损失，多个样本时是成本）。
  2. # 通过每次训练的成本我们就可以知道当前神经网络学习的程度好坏。
  3. def compute_cost(AL, Y):
  5.     m = Y.shape[1]
  6.     cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))
  8.     cost = np.squeeze(cost)# 确保cost是一个数值而不是一个数组的形式
  9.     assert(cost.shape == ())
  11.     return cost

4 - 反向傳播

下面的linear_backward函数用于根据后一层的dZ来计算前面一层的dW，db和dA。也就是实现了下面3个公式𝑑𝑊[𝑙]=1𝑚𝑑𝑍[𝑙]𝐴[𝑙−1]𝑇dW[l]=1mdZ[l]A[l−1]T
𝑑𝑏[𝑙]=1𝑚∑𝑖=1𝑚𝑑𝑍𝑙db[l]=1m∑i=1mdZl
𝑑𝐴[𝑙−1]=𝑊[𝑙]𝑇𝑑𝑍[𝑙]

  1. def linear_backward(dZ, cache):
  2.     """
  3.     参数:
  4.     dZ -- 后面一层的dZ
  5.     cache -- 前向传播时我们保存下来的关于本层的一些变量
  6.     """
  7.     A_prev, W, b = cache
  8.     m = A_prev.shape[1]
  10.     dW = np.dot(dZ, cache[0].T) / m
  11.     db = np.sum(dZ, axis=1, keepdims=True) / m
  12.     dA_prev = np.dot(cache[1].T, dZ)
  14.     assert (dA_prev.shape == A_prev.shape)
  15.     assert (dW.shape == W.shape)
  16.     assert (db.shape == b.shape)
  18.     return dA_prev, dW, db

下面的linear_activation_backward用于根据本层的dA计算出本层的dZ。就是实现了下面的公式𝑑𝑍[𝑙]=𝑑𝐴[𝑙]∗𝑔′(𝑍[𝑙])dZ[l]=dA[l]∗g′(Z[l])
上式的g’()表示求Z相当于本层的激活函数的偏导数。所以不同的激活函数也有不同的求导公式。 

  1. def linear_activation_backward(dA, cache, activation):
  2.     """
  3.     参数:
  4.     dA -- 本层的dA 
  5.     cache -- 前向传播时保存的本层的相关变量
  6.     activation -- 指示该层使用的是什么激活函数: "sigmoid" 或 "relu"
  7.     """
  8.     linear_cache, activation_cache = cache
  10.     if activation == "relu":
  11.         dZ = relu_backward(dA, activation_cache)        
  12.     elif activation == "sigmoid":
  13.         dZ = sigmoid_backward(dA, activation_cache)
  15.     # 这里我们又顺带根据本层的dZ算出本层的dW和db以及前一层的dA
  16.     dA_prev, dW, db = linear_backward(dZ, linear_cache)
  18.     return dA_prev, dW, db
  1. # 下面这个函数构建出整个反向传播。
  2. def L_model_backward(AL, Y, caches):
  3.     """
  4.     参数:
  5.     AL -- 最后一层的A，也就是y'，预测出的标签
  6.     Y -- 真实标签
  7.     caches -- 前向传播时保存的每一层的相关变量，用于辅助计算反向传播
  8.     """
  9.     grads = {}
  10.     L = len(caches) # 获取神经网络层数。caches列表的长度就等于神经网络的层数
  11.     Y = Y.reshape(AL.shape) # 让真实标签的维度和预测标签的维度一致
  13.     # 计算出最后一层的dA，前面文章我们以及解释过，最后一层的dA与前面各层的dA的计算公式不同，
  14.     # 因为最后一个A是直接作为参数传递到成本函数的，所以不需要链式法则而直接就可以求dA（A相当于成本函数的偏导数）
  15.     dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
  17.     # 计算最后一层的dW和db，因为最后一层使用的激活函数是sigmoid
  18.     current_cache = caches[-1]
  19.     grads["dA" + str(L-1)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(
  20.                                                                                             dAL, 
  21.                                                                                             current_cache,
  22.                                                                                             activation = "sigmoid")
  24.     # 计算前面L-1层到第一层的每层的梯度，这些层都使用relu激活函数
  25.     for c in reversed(range(1,L)): # reversed(range(1,L))的结果是L-1,L-2...1。是不包括L的。第0层是输入层，不必计算。
  26.         # 这里的c表示当前层
  27.         grads["dA" + str(c-1)], grads["dW" + str(c)], grads["db" + str(c)] = linear_activation_backward(
  28.             grads["dA" + str(c)], 
  29.             caches[c-1],
  30.             # 这里我们也是需要当前层的caches，但是为什么是c-1呢？因为grads是字典，我们从1开始计数，而caches是列表，
  31.             # 是从0开始计数。所以c-1就代表了c层的caches。数组的索引很容易引起莫名其妙的问题，大家编程时一定要留意。
  32.             activation = "relu")
  34.     return grads

5 - 梯度下降

  1. def update_parameters(parameters, grads, learning_rate):
  2.     """
  3.     Arguments:
  4.     parameters -- 每一层的参数w和b 
  5.     grads -- 每一层的梯度
  6.     learning_rate -- 是学习率，学习步进
  7.     """
  9.     L = len(parameters) // 2 # 获取层数。//除法可以得到整数
  11.     for l in range(1,L+1):
  12.         parameters["W" + str(l)] = parameters["W" + str(l)] - learning_rate * grads["dW" + str(l)]
  13.         parameters["b" + str(l)] = parameters["b" + str(l)] - learning_rate * grads["db" + str(l)]
  15.     return parameters

6 - 構建模型

  1. # 利用上面的工具函数构建一个深度神经网络训练模型
  2. def dnn_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False): 
  3.     """    
  4.     参数:
  5.     X -- 数据集
  6.     Y -- 数据集标签
  7.     layers_dims -- 指示该深度神经网络用多少层，每层有多少个神经元
  8.     learning_rate -- 学习率
  9.     num_iterations -- 指示需要训练多少次
  10.     print_cost -- 指示是否需要在将训练过程中的成本信息打印出来，好知道训练的进度好坏。
  12.     返回值:
  13.     parameters -- 返回训练好的参数。以后就可以用这些参数来识别新的陌生的图片
  14.     """
  16.     np.random.seed(1)
  17.     costs = []                  
  19.     # 初始化每层的参数w和b
  20.     parameters = initialize_parameters_deep(layers_dims)
  22.     # 按照指示的次数来训练深度神经网络
  23.     for i in range(0, num_iterations):
  24.         # 进行前向传播
  25.         AL, caches = L_model_forward(X, parameters)
  26.         # 计算成本
  27.         cost = compute_cost(AL, Y)
  28.         # 进行反向传播
  29.         grads = L_model_backward(AL, Y, caches)
  30.         # 更新参数，好用这些参数进行下一轮的前向传播
  31.         parameters = update_parameters(parameters, grads, learning_rate)
  33.         # 打印出成本
  34.         if i % 100 == 0:
  35.             if print_cost and i > 0:
  36.                 print ("训练%i次后成本是: %f" % (i, cost))
  37.             costs.append(cost)
  39.     # 画出成本曲线图
  40.     plt.plot(np.squeeze(costs))
  41.     plt.ylabel('cost')
  42.     plt.xlabel('iterations (per tens)')
  43.     plt.title("Learning rate =" + str(learning_rate))
  44.     plt.show()
  46.     return parameters

7 - 預測

  1. def predict(X,parameters):   
  2.     m = X.shape[1]
  3.     n = len(parameters) // 2 # number of layers in the neural network
  4.     p = np.zeros((1,m))
  6.     # 进行一次前向传播，得到预测结果
  7.     probas, caches = L_model_forward(X, parameters)
  9.     # 将预测结果转化成0和1的形式，即大于0.5的就是1，否则就是0
  10.     for i in range(0, probas.shape[1]):
  11.         if probas[0,i] > 0.5:
  12.             p[0,i] = 1
  13.         else:
  14.             p[0,i] = 0
  16.     return p