Week2：神經網路的程式設計基礎(Basics of Neural Network programming)

Pre:本章基本字母含義

在这里插入图片描述

2.1 Binary Classification(二分法)

邏輯迴歸模型一般用來解決二分類（Binary Classification）問題。

二分類就是輸出y只有{0,1}兩個離散值（也有{-1,1}的情況）。
以一個影象識別問題爲例，判斷圖片中是否有貓存在，0代表no cat，1代表cat。
1. 彩色圖片包含RGB三個通道。例如該cat圖片的尺寸爲(64,64,3)。在神經網路模型中，我們首先要將圖片輸入 $x$ (維度是(64,64,3))轉化爲一維的特徵向量(feature vector)。方法是每個通道一行一行取，再連線起來。由於64x64x3=12288，則轉化後的輸入特徵向量維度爲(12288,1)。此特徵向量 $x$ 是列向量，維度一般記爲 $n_x$ 。
2. 如果訓練樣本共有 $m$ 張圖片，那麼整個訓練樣本X組成了矩陣，維度是 $(n_x，m)$ 。注意，這裏矩陣 $X$ 的行 $n_x$ 代表了每個樣本 $x^{(i)}$ 特徵個數，列 $m$ 代表了樣本個數。
3. Python實現的時候，你會看到X.shape，這是一條Python命令，用於顯示矩陣的規模，即X.shape等於 $(n_x,m)$

2.2 Logistic Regression(邏輯迴歸)

2.3 Logistic Regression Cost Function(邏輯迴歸的損失函數)

參照吳恩達《機器學習》Week3的邏輯迴歸和代價/損失函數。

2.4 Gradient Descent(邏輯迴歸的梯度下降法)

問題提出
對單個數據 $(x,y)$ 邏輯迴歸的損失函數是： $L\left( \hat{y},y \right)=-y\log(\hat{y})-(1-y)\log (1-\hat{y})$ ， $m$ 個樣本的損失函數是：
$J\left( w,b \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{L\left( {{{\hat{y}}}^{(i)}},{{y}^{(i)}} \right)}=\frac{1}{m}\sum\limits_{i=1}^{m}{\left( -{{y}^{(i)}}\log {{{\hat{y}}}^{(i)}}-(1-{{y}^{(i)}})\log (1-{{{\hat{y}}}^{(i)}}) \right)}$
所以在訓練邏輯迴歸模型時候，我們需要找到合適的 $w$ 和 $b$ ，來讓代價函數 $J$ 的總代價降到最低。其中： $\hat{y}=\sigma\left(w^{T} x+b\right), \sigma(z)=\frac{1}{1+e^{-z}}$
梯度下降法
- 由於J(w,b)是convex function，梯度下降演算法是先隨機選擇一組參數w和b值，然後每次迭代的過程中分別沿着w和b的梯度（偏導數）的反方向前進一小步，不斷修正w和b。每次迭代更新w和b後，都能讓J(w,b)更接近全域性最小值。梯度下降的過程如下圖所示：
- 梯度下降演算法每次迭代更新，w和b的修正表達式爲：
  $w:=w-\alpha\frac{\partial J(w,b)}{\partial w}$
  $b:=b-\alpha\frac{\partial J(w,b)}{\partial b}$
- 上式中， $\alpha$ 是學習因子（learning rate），表示梯度下降的步進長度。
  - $\alpha$ 越大， $w$ 和 $b$ 每次更新的「步伐」更大一些；
  - $\alpha$ 越小， $w$ 和 $b$ 每次更新的「步伐」更小一些。
- 在程式程式碼中，我們通常使用 $dw$ 來表示 $\frac{\partial J(w,b)}{\partial w}$ ，用 $db$ 來表示 $\frac{\partial J(w,b)}{\partial b}$ 。
  
  微積分裡， $\frac{df}{dx}$ 表示對單一變數求導數， $\frac{\partial f}{\partial x}$ 表示對多個變數中某個變數求偏導數。

2.5 Derivatives(求導)

2.6 More Derivative Examples

這兩節是求導和求導的例子。

2.7 Computation graph(計算圖)

整個神經網路的訓練過程實際上包含了兩個過程：正向傳播（Forward Propagation）和反向傳播（Back Propagation）。

正向傳播是從輸入到輸出，由神經網路計算得到預測輸出的過程；
反向傳播是從輸出到輸入，對參數w和b計算梯度的過程。
用計算圖（Computation graph）的形式來理解這兩個過程。舉個簡單的例子，假如Cost function爲 $J(a,b,c)=3(a+bc)$ ，包含 $a，b，c$ 三個變數。我們用 $u$ 表示 $bc$ ， $v$ 表示 $a+u$ ，則 $J=3v$ 。它的計算圖可以寫成如下圖所示：
令 $a=5，b=3，c=2$ ，則 $u=bc=6，v=a+u=11，J=3v=33$ 。計算圖中，這種從左到右，從輸入到輸出的過程就對應着神經網路或者邏輯迴歸中輸入與權重經過運算計算得到Cost function的 $\color{red}正向過程$ 。

2.8 Derivatives with a Computation Graph(計算圖的求導)

上一節介紹了計算圖的正向傳播（Forward Propagation），下面下麪來介紹計算圖的反向傳播（Back Propagation），即計算輸出對輸入的偏導數。
在这里插入图片描述

還是上個計算圖的例子，輸入參數有3個，分別是 $a，b，c$ 。

首先計算J對參數a的偏導數。從計算圖上來看，從右到左， $J$ 是 $v$ 的函數， $v$ 是 $a$ 的函數。則利用求導技巧，可以得到：
$\frac{\partial J}{\partial a}=\frac{\partial J}{\partial v}\cdot \frac{\partial v}{\partial a}=3\cdot 1=3$
根據這種思想，然後計算 $J$ 對參數 $b$ 的偏導數。從計算圖上來看，從右到左， $J$ 是 $v$ 的函數， $v$ 是 $u$ 的函數， $u$ 是 $b$ 的函數。可以推導：
$\frac{\partial J}{\partial b}=\frac{\partial J}{\partial v}\cdot \frac{\partial v}{\partial u}\cdot \frac{\partial u}{\partial b}=3\cdot 1\cdot c=3\cdot 1\cdot 2=6$
最後計算 $J$ 對參數 $c$ 的偏導數。仍從計算圖上來看，從右到左， $J$ 是 $v$ 的函數， $v$ 是 $u$ 的函數， $u$ 是 $c$ 的函數。可以推導：
$\frac{\partial J}{\partial c}=\frac{\partial J}{\partial v}\cdot \frac{\partial v}{\partial u}\cdot \frac{\partial u}{\partial c}=3\cdot 1\cdot b=3\cdot 1\cdot 3=9$

2.9 Logistic Regression Gradient Descent(邏輯迴歸的梯度下降法)

在这里插入图片描述
將對邏輯迴歸進行梯度計算。對單個樣本而言，邏輯迴歸Loss function表達式如下：
$\begin{array}{l}z=w^Tx+b\\ \hat y=a=\sigma(z)\\ L(a,y)=-(ylog(a)+(1-y)log(1-a))\end{array}$

首先是正向傳播過程。根據上述公式，例如輸入樣本 $x$ 有兩個特徵 $(x_1,x_2)$ ，相應的權重 $w$ 維度也是 $2$ ，即 $(w_1,w_2)$ 。則 $z=w_1x_1+w_2x_2+b$ ，Loss function的計算圖如上圖。
然後，計算該邏輯迴歸的反向傳播過程，即由Loss function計算參數w和b的偏導數。推導過程如下：
$\begin{array}{l}da=\frac{\partial L}{\partial a}=-\frac ya+\frac{1-y}{1-a}\\ dz=\frac{\partial L}{\partial z}=\frac{\partial L}{\partial a}\cdot \frac{\partial a}{\partial z}=(-\frac ya+\frac{1-y}{1-a})\cdot a(1-a)=a-y\end{array}$
知道了dz之後，就可以直接對w_1，w_2和b進行求導了。
$\begin{array}{l}dw_1=\frac{\partial L}{\partial w_1}=\frac{\partial L}{\partial z}\cdot \frac{\partial z}{\partial w_1}=x_1\cdot dz=x_1(a-y)\\ dw_2=\frac{\partial L}{\partial w_2}=\frac{\partial L}{\partial z}\cdot \frac{\partial z}{\partial w_2}=x_2\cdot dz=x_2(a-y)\\ db=\frac{\partial L}{\partial b}=\frac{\partial L}{\partial z}\cdot \frac{\partial z}{\partial b}=1\cdot dz=a-y\end{array}$
則梯度下降演算法可表示爲：
$\begin{array}{l}w_1:=w_1-\alpha\ dw_1\\ w_2:=w_2-\alpha\ dw_2\\ b:=b-\alpha\ db\end{array}$

2.10 Gradient descent on m examples(m個樣本的梯度下降法)

在之前的視訊中,你已經看到如何計算導數，以及應用梯度下降在邏輯迴歸的一個訓練樣本上。現在我們想要把它應用在 $m$ 個訓練樣本上。 $m$ 個樣本，其Cost function表達式如下：
$\begin{array}{l} z^{(i)}=w^Tx^{(i)}+b\\ \hat y^{(i)}=a^{(i)}=\sigma(z^{(i)})\\ J(w,b)=\frac1m\sum_{i=1}^mL(\hat y^{(i)},y^{(i)})=-\frac1m\sum_{i=1}^m[y^{(i)}log\ \hat y^{(i)}+(1-y^{(i)})log\ (1-\hat y^{(i)})]\end{array}$

$w$ 和 $b$ 的偏導數可以寫成和平均的形式：
$\begin{array}{l}dw_1=\frac1m\sum_{i=1}^mx_1^{(i)}(a^{(i)}-y^{(i)})\\ dw_2=\frac1m\sum_{i=1}^mx_2^{(i)}(a^{(i)}-y^{(i)})\\ db=\frac1m\sum_{i=1}^m(a^{(i)}-y^{(i)}) \end{array}$
這樣，每次迭代中 $w$ 和 $b$ 的梯度有 $m$ 個訓練樣本計算平均值得到。其演算法流程圖如下所示：
```
J=0; dw1=0; dw2=0; db=0;
for i = 1 to m
    z(i) = wx(i)+b;
    a(i) = sigmoid(z(i));
    J += -[y(i)log(a(i))+(1-y(i)）log(1-a(i));
    dz(i) = a(i)-y(i);
    dw1 += x1(i)dz(i);
    dw2 += x2(i)dz(i);
    db += dz(i);
J /= m;
dw1 /= m;
dw2 /= m;
db /= m;
```
經過每次迭代後，根據梯度下降演算法，w和b都進行更新：
$\begin{array}{l}w_1:=w_1-\alpha\ dw_1\\ w_2:=w_2-\alpha\ dw_2\\ b:=b-\alpha\ db\end{array}$
這樣經過 $n$ 次迭代後，整個梯度下降演算法就完成了。
這種計算中有兩個缺點，也就是說應用此方法在邏輯迴歸上你需要編寫兩個for回圈。
- 第一個for回圈是一個小回圈遍歷 $m$ 個訓練樣本，第二個for回圈是一個遍歷所有特徵的for回圈。
- 如果你有更多特徵，你開始編寫你的因此 $d{{w}_{1}}$ ， $d{{w}_{2}}$ ，你有相似的計算從 $d{{w}_{3}}$ 一直下去到 $d{{w}_{n}}$ 。所以看來你需要一個for回圈遍歷所有 $n$ 個特徵。
- 深度學習演算法，在程式碼中顯式地使用for回圈使你的演算法很低效，同時在深度學習領域會有越來越大的數據集。需要使用矩陣，進行向量化處理。

2.11 向量化(Vectorization)

向量化是非常基礎的去除程式碼中for回圈的藝術，在深度學習安全領域、深度學習實踐中，你會經常發現自己訓練大數據集，因爲深度學習演算法處理大數據集效果很棒，所以你的程式碼執行速度非常重要。

以python爲例子，向量化來加速運算(np.function)，遍歷

m

遍的

for

回圈可以寫成：z=np.dot(w, x) + b

import numpy as np #匯入numpy庫
a = np.array([1,2,3,4]) #建立一個數據a
print(a)
# [1 2 3 4]

import time #匯入時間庫
a = np.random.rand(1000000)
b = np.random.rand(1000000) #通過round隨機得到兩個一百萬維度的陣列
tic = time.time() #現在測量一下當前時間

#向量化的版本
c = np.dot(a,b)
toc = time.time()
print("Vectorized version:" + str(1000*(toc-tic)) +"ms") #列印一下向量化的版本的時間

#繼續增加非向量化的版本
c = 0
tic = time.time()
for i in range(1000000):
    c += a[i]*b[i]
toc = time.time()
print(c)
print("For loop:" + str(1000*(toc-tic)) + "ms")#列印for回圈的版本的時間

輸出結果類似於：

250286.989866
Vectorized version:1.5027523040771484ms
250286.989866
For loop:474.29513931274414ms

Python安裝Jupyter Notebook設定使用教學

爲了加快深度學習神經網路運算速度，可以使用比CPU運算能力更強大的GPU。事實上，GPU和CPU都有並行指令（parallelization instructions），稱爲Single Instruction Multiple Data（SIMD）。SIMD是單指令多數據流，能夠複製多個運算元，並把它們打包在大型暫存器的一組指令集。SIMD能夠大大提高程式執行速度。
- python的numpy庫中的內建函數（built-in function）就是使用了SIMD指令。
- 相比而言，GPU的SIMD要比CPU更強大一些。

2.12 向量化的更多例子（More Examples of Vectorization）

在python的numpy庫中，我們通常使用np.dot()函數來進行矩陣運算。當你想寫回圈時候，檢查numpy是否存在類似的內建函數，從而避免使用回圈(loop)方式。
numpy庫有很多向量函數。比如 u=np.log是計算對數函數( $log$ )、 np.abs() 計算數據的絕對值、np.maximum(v, 0) 按元素計算 $v$ 中每個元素和和0相比的最大值，v**2 代表獲得元素 $v$ 每個值的平方、 1/v 獲取 $v$ 中每個元素的倒數等等。

2.13 向量化邏輯迴歸(Vectorizing Logistic Regression)

常規回圈
首先我們回顧一下邏輯迴歸的前向傳播步驟。如果有 $m$ 個訓練樣本，然後對第一個樣本進行預測，你需要這樣計算。
- 計算 $z$ ，我正在使用這個熟悉的公式 $z^{(1)}=w^{T}x^{(1)}+b$ 。然後計算啓用函數 $a^{(1)}=\sigma (z^{(1)})$ ，計算第一個樣本的預測值 $y$ 。
- 然後對第二個樣本進行預測，你需要計算 $z^{(2)}=w^{T}x^{(2)}+b$ ， $a^{(2)}=\sigma (z^{(2)})$ 。
- 然後對第三個樣本進行預測，你需要計算 $z^{(3)}=w^{T}x^{(3)}+b$ ， $a^{(3)}=\sigma (z^{(3)})$ ，依次類推。
- 如果你有 $m$ 個訓練樣本，你可能需要這樣做 $m$ 次。
向量表示
- 定義了一個矩陣 $X$ 作爲訓練輸入，每個 $x$ 樣本是 $n_x$ ，將不同的列中堆積在一起。這是一個 $n_x$ 行 $m$ 列的矩陣。我現在將它寫爲Python numpy的形式 $(n_{x},m)$ ，這只是表示 $X$ 是一個 $n_x$ 乘以 $m$ 的矩陣 $R^{n_x \times m}$ 。
- $z^{(1)}$ ， $z^{(2)}$ ……一直到 $z^{(m)}$ ，所有值都是在同一時間內完成。
  $[z^{(1)} z^{(2)}...z^{(m)}]=w^{T}X+[b,b...b]$
  $[b,b...b]$ 是一個 $1\times m$ 的向量或者 $1\times m$ 的矩陣或者是一個 $m$ 維的行向量。所以希望你熟悉矩陣乘法，你會發現的 $w$ 轉置乘以 $x^{(1)}$ ， $x^{(2)}$ 一直到 $x^{(m)}$ 。繼續簡化可以寫成：
  $Z= [z^{(1)} z^{(2)}...z^{(m)}]=w^{T}X+[b,b...b]=[w^{T}x^{(1)}+b,w^{T}x^{(2)}+b...w^{T}x^{(m)}+b]$
  其中大寫的 $Z$ 表示爲 $[z^{(1)} z^{(2)} ... z^{(m)}]$ ， $w^{T}x^{(1)}+b$ 這是第一個元素， $w^{T}x^{(2)}+b$ 這是第二個元素， $w^{T}x^{(m)}+b$ 這是第 $m$ 個元素。
Python表示
- numpy命令是Z=np.dot(w.T,X)+b；最後再進行 $sigmoid$ 函數，一次性表示出 $A = [a^{(1)},a^{(2)}...a^{(m)}]$ 。
- 這裏在Python中有一個巧妙的地方，這裏 $b$ 是一個實數，或者你可以說是一個 $1\times 1$ 矩陣。但是當你將這個向量加上這個實數時，Python自動把這個實數 $b$ 擴充套件成一個 $1\times m$ 的行向量。在Python中被稱作廣播(brosdcasting)，後邊會具體介紹。

2.14 向量化 logistic 迴歸的梯度輸出（Vectorizing Logistic Regression’s Gradient）

注：本節中大寫字母代表向量，小寫字母代表元素

在本節 $2.10$ 中，已經給出了邏輯迴歸中梯度下降法的一般表示形式：
$\begin{array}{l}dz_j = a_j - y_j\\ dw_j=\frac1m\sum_{i=1}^mx_j^{(i)}(a^{(i)}_j-y^{(i)}_j)\\ db=\frac1m\sum_{i=1}^m(a^{(i)}_j-y^{(i)}_j) \end{array}$
接下來看看邏輯迴歸中的梯度下降演算法如何轉化爲向量化的矩陣形式，對於所有 $m$ 個樣本。
- $dZ$ 的維度是 $(1，m)$ ，可表示爲：
  $dZ=A-Y$
- $db$ 可表示爲：
  $db=\frac1m dZ = \frac1m \sum_{i=1}^mdz^{(i)}$
  對應的程式爲：db = 1/m*np.sum(dZ)
- $dw$ 可表示爲：
  $dw=\frac1m X\cdot dZ^T$
  對應的程式爲：dw = 1/m*np.dot(X,dZ.T)
- 我們把整個邏輯迴歸中的 $for$ 回圈儘可能用矩陣運算代替，對於單次迭代，梯度下降演算法流程如下所示：
```
Z = np.dot(w.T,X) + b
A = sigmoid(Z)
dZ = A-Y
dw = 1/m*np.dot(X,dZ.T)
db = 1/m*np.sum(dZ)

w = w - alpha*dw
b = b - alpha*db
```
  其中 $\alpha$ 是學習因子，決定 $w$ 和 $b$ 的更新速度。上述程式碼只是對單次訓練更新而言的，外層還需要一個 $for$ 回圈，表示迭代次數。

2.15 Python 中的廣播（Broadcasting in Python）

numpy廣播機制機製
- 定義：對於四則運算及其混合形式，如果兩個陣列的後緣維度的軸長度相符或其中一方的軸長度爲1，則認爲它們是廣播相容的。廣播會在缺失維度和軸長度爲1的維度上進行。 python中的廣播機制機製可由下面下麪四條表示：
- 對於Matlab/Octave 有類似功能的函數bsxfun。

numpy中的axis

import numpy as np
#輸入數據
A = np.array([[56.0, 0.0, 4.4, 68.0],
              [1.2, 104.0, 52.0, 8.0],
              [1.8, 135.0, 99.0, 0.9]])
print(A)
# 求每列的和
cal = A.sum(axis= 0)
print(cal)

A.sum(axis = 0)中的參數axis。axis用來指明將要進行的運算是沿着哪個軸執行，在numpy中，0軸是垂直的，也就是列，而1軸是水平的，也就是行。

2.16 關於 python _ numpy 向量的說明（A note on python or numpy vectors）

本講Python中的numpy一維陣列的特性，以及與行向量或列向量的區別。並介紹在實際應用中的一些小技巧，去避免在coding中由於這些特性而導致的bug。

秩1：
```
a = np.random.randn(5)
```
這條語句生成的a的維度是（5，）。它既不是行向量也不是列向量，我們把a叫做rank 1 array（秩1）。這種定義會帶來一些問題。例如我們對a進行轉置，還是會得到a本身。
定義向量：
- 如果我們要定義（5，1）的列向量或者（1，5）的行向量，最好使用下來標準語句，避免使用rank 1 array。
```
a = np.random.randn(5,1)
b = np.random.randn(1,5)
```
- 可以使用assert語句對向量或陣列的維度進行判斷，例如：
```
assert(a.shape == (5,1))
```
  assert會對內嵌語句進行判斷，即判斷a的維度是不是（5，1）的。如果不是，則程式在此處停止。使用assert語句也是一種很好的習慣，能夠幫助我們及時檢查、發現語句是否正確。
- 還可以使用reshape函數對陣列設定所需的維度：
```
a.reshape((5,1))
```

2.17 Jupyter/iPython Notebooks快速入門（Quick tour of Jupyter/iPython Notebooks）