【吴恩达深度学习笔记】1.2 神经网络编程基础Basics of Neural Network Programming

分手后的思念是犯贱 2022-12-08 14:15 123阅读 0赞

# 第一门课 神经网络和深度学习(Neural Networks and Deep Learning) #

## 2.1二分分类（Binary Classfication） ##

神经网络的训练过程：

*  前向传播（Foward Propagation）
 *  反向传播（Backward Propagation）

逻辑回归（Logistic Regression）是一个用于二分类的算法

**符号定义：**  
 x x x：一个 n x n\_x nx维数据，为输入数据，维度为 ( n x , 1 ) (n\_x,1) (nx,1)；  
 y y y：输出结果，取值为 ( 0 , 1 ) (0,1) (0,1)；  
 ( x ( i ) , y ( i ) ) (x^\{(i)\},y^\{(i)\}) (x(i),y(i))：第 i i i组数据，默认为训练数据，通常用 M t e x t M\_\{text\} Mtext表示测试数据集， M t r a i n M\_\{train\} Mtrain表示训练数据集；  
 X = \[ x ( 1 ) , x ( 2 ) , . . . , x ( m ) \] X=\[x^\{(1)\},x^\{(2)\},...,x^\{(m)\}\] X=\[x(1),x(2),...,x(m)\]：所有训练数据集的输入值，放在一个 X . s h a p e = n x × m X.shape=n\_x×m X.shape=nx×m的矩阵中，其中 m m m表示样本数目;  
 Y = \[ y ( 1 ) , y ( 2 ) , . . . , y ( m ) \] Y=\[y^\{(1)\},y^\{(2)\},...,y^\{(m)\}\] Y=\[y(1),y(2),...,y(m)\]：对应表示所有训练数据集的输出值，维度为 Y . s h a p e = 1 × m Y.shape=1×m Y.shape=1×m。

## 2.2回归（Regression） ##

对于一个二元分类问题，给定一输入特征向量 X X X，我们想要计算输出的估计值 y ^ = P ( y = 1 ∣ x ) \\hat y=P(y=1|x) y^=P(y=1∣x)，其中 y ^ ∈ \[ 0 , 1 \] \\hat y∈\[0,1\] y^∈\[0,1\]，设： z = w T x + b z=w^Tx+b z=wTx\+b

其中参数 w ∈ R n x ， b ∈ R w∈\\mathbb\{R\}^\{n\_x\}，b∈\\mathbb\{R\} w∈Rnx，b∈R，则输出： y ^ = σ ( w T x + b ) = σ ( z ) = 1 1 + e − z \\hat y=\\sigma(w^Tx+b)=\\sigma(z)=\\frac\{1\}\{1+e^\{-z\}\} y^=σ(wTx\+b)=σ(z)=1\+e−z1

如果 z z z足够大， σ = 1 \\sigma=1 σ=1;如果 z z z足够小， σ = 0 \\sigma=0 σ=0；利用python绘制出的 S i g m o i d Sigmoid Sigmoid函数和之前的 R e L u ReLu ReLu函数如下：

import numpy as np
    import matplotlib.pyplot as plt
    
    def sigmoid(x):
        return 1./(1+np.exp(-x))
    
    def relu(x):
        return np.where(x<0,0,x)
    
    def plot_sigmoid():
        x = np.arange(-10, 10, 0.1)
        y = sigmoid(x)
        plt.plot(x,y)
        plt.show()
        
    def plot_relu():
        x = np.arange(-10, 10, 0.1)
        y = relu(x)
        plt.plot(x,y)
        plt.show()
        
    if __name__ == '__main__':
        plot_sigmoid()
        plot_relu()

输出的函数图像为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 1]

## 2.3逻辑回归的代价函数（Logistic Regression cost function） ##

为了训练逻辑回归模型的参数 w w w和 b b b需要代价函数（Cost Function），通过训练代价函数得到 w w w和 b b b。对于第 i i i个训练样本有： y ^ ( i ) = σ ( w T x ( i ) + b ) = σ ( z ( i ) ) = 1 1 + e − z ( i ) ) \\hat y^\{(i)\}=\\sigma (w^Tx^\{(i)\}+b)=\\sigma (z^\{(i)\})=\\frac\{1\}\{1+e^\{-z^\{(i)\})\}\} y^(i)=σ(wTx(i)\+b)=σ(z(i))=1\+e−z(i))1

对于给定的数据集 \{ ( x ( 1 ) , y ( 1 ) ) , . . . , ( x ( m ) , y ( m ) ) \} \\\{(x^\{(1)\},y^\{(1)\}),...,(x^\{(m)\},y^\{(m)\})\\\} \{ (x(1),y(1)),...,(x(m),y(m))\}，我们想要输出的估计值等于真实值，即 y ^ ( i ) ≈ y ( i ) \\hat y^\{(i)\}≈ y^\{(i)\} y^(i)≈y(i)，但输出结果总会存在一定的误差，由此引入**损失函数**（Loss/Error Function）： L ( y ^ , y ) = − ( y l o g y ^ + ( 1 − y ) l o g ( 1 − y ^ ) ) L(\\hat y,y)=-\\left(ylog\\hat y+(1-y)log(1-\\hat y)\\right) L(y^,y)=−(ylogy^\+(1−y)log(1−y^))

若 y = 1 y=1 y=1： L ( y ^ , y ) = − l o g y ^ L(\\hat y,y)=-log\\hat y L(y^,y)=−logy^，如果想要损失函数 L L L尽可能得小，那么就要 y ^ \\hat y y^尽可大，因为sigmoid函数取值 \[ 0 , 1 \] \[0,1\] \[0,1\]，所以 y ^ \\hat y y^会无限接近于1。  
若 y = 0 y=0 y=0： L ( y ^ , y ) = − l o g ( 1 − y ^ ) L(\\hat y,y)=-log(1-\\hat y) L(y^,y)=−log(1−y^)，如果想要损失函数 L L L尽可能得小，那么就要 y ^ \\hat y y^尽可能小，因为sigmoid函数取值 \[ 0 , 1 \] \[0,1\] \[0,1\]，所以 y ^ \\hat y y^会无限接近于0。为了衡量算法在全部训练样本上的表现如何，我们需要定义一个算法的代价函数，算法的代价函数是对 m m m个样本的损失函数求和然后除以 m m m:  J ( w , b ) = 1 m ∑ i = 1 m L ( y ^ ( i ) , y ( i ) ) = − 1 m ∑ i = 1 m \[ y ( i ) l o g y ^ ( i ) + ( 1 − y ( i ) ) l o g ( 1 − y ^ ( i ) ) \] J(w,b)=\\frac1\{m\}\\sum\_\{i=1\}^\{m\}L\\left( \\hat y^\{(i)\}, y^\{(i)\}\\right) =- \\frac1\{m\}\\sum\_\{i=1\}^\{m\}\{\[y^\{(i)\}log\\hat y^\{(i)\} +(1-y^\{(i)\})log\{(1-\\hat y^\{(i)\})\}\]\} J(w,b)=m1i=1∑mL(y^(i),y(i))=−m1i=1∑m\[y(i)logy^(i)\+(1−y(i))log(1−y^(i))\]

损失函数 L L L只适用于像这样的单个训练样本，而代价函数 J J J是参数的总代价，所以在训练逻辑回归模型时候，我们需要找到合适的 w w w和 b b b，来让代价函数 J J J的总代价降到最低。

## 2.4梯度下降法（Gradient Descent） ##

利用梯度下降法中的参数更新  
 w : = w − α ∂ J ( w , b ) ∂ w w:=w-\\alpha \\frac\{\\partial J(w,b)\}\{\\partial w\} w:=w−α∂w∂J(w,b)

b : = b − α ∂ J ( w , b ) ∂ b b:=b-\\alpha \\frac\{\\partial J(w,b)\}\{\\partial b\} b:=b−α∂b∂J(w,b)

其中 α \\alpha α表示学习率（Learning Rate），用来控制步长。

## 2.5导数（Derivatives） ##

### 2.6更多的导数例子（More Derivative Examples） ###

### 2.7计算图（Computation Graph） ###

## 2.8使用计算图求导（Derivatives with a Computation Graph） ##

## 2.9逻辑回归中的梯度下降（Logistic Regression Gradient Descent） ##

根据之前的推导得：  
 z = w T x + b z=w^Tx+b z=wTx\+b y ^ = a = σ ( z ) \\hat y=a=\\sigma(z) y^=a=σ(z)

L ( a , y ) = − ( y l o g ( a ) + ( 1 − y ) l o g ( 1 − a ) ) L(a,y)=-(ylog(a)+(1-y)log(1-a)) L(a,y)=−(ylog(a)\+(1−y)log(1−a))

d L ( a , y ) a = − y a + 1 − y 1 − a \\frac\{dL(a,y)\}\{a\}=-\\frac\{y\}\{a\}+\\frac\{1-y\}\{1-a\} adL(a,y)=−ay\+1−a1−y

进一步推导得出：

d a d z = a ⋅ ( 1 − a ) \\frac\{da\}\{dz\}=a·(1-a) dzda=a⋅(1−a)

d z = d L ( a , y ) d z = d L d a ⋅ d a d z = ( y a + 1 − y 1 − a ) ⋅ a ( 1 − a ) = a − y dz=\\frac\{dL(a,y)\}\{dz\}=\\frac\{dL\}\{da\}·\\frac\{da\}\{dz\}=(\\frac\{y\}\{a\}+\\frac\{1-y\}\{1-a\})·a(1-a)=a-y dz=dzdL(a,y)=dadL⋅dzda=(ay\+1−a1−y)⋅a(1−a)=a−y

d w 1 = x 1 ⋅ d z dw\_1=x\_1·dz dw1=x1⋅dz

d w 2 = x 2 ⋅ d z dw\_2=x\_2·dz dw2=x2⋅dz

d b = d z db=dz db=dz

关于单个样本的梯度下降算法，需要使用公式 d z = ( a − y ) dz=(a-y) dz=(a−y)计算 d z dz dz，然后计算 d w 1 、 d w 2 、 d b dw\_1、dw\_2、db dw1、dw2、db，然后更新 w 1 = w 1 − α d w 1 w\_1=w\_1-\\alpha dw\_1 w1=w1−αdw1； w 2 = w 2 − α d w 1 w\_2=w\_2-\\alpha dw\_1 w2=w2−αdw1； b = b − α d w 1 b=b-\\alpha dw\_1 b=b−αdw1。

## 2.10*m*个样本的梯度下降（Gradient Descent on m Examples） ##

当存在m个样本时，关于损失函数 J ( w , b ) J(w,b) J(w,b)的函数定义： J ( w , b ) = 1 m ∑ i = 1 m L ( a ( i ) , y ( i ) ) J(w,b)=\\frac\{1\}\{m\}\\sum\_\{i=1\}^\{m\}L(a^\{(i)\},y^\{(i)\}) J(w,b)=m1i=1∑mL(a(i),y(i))

此方法的代码如下：

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=w-alpha*dw
    b=b-alpha*db

## 2.11向量化（Vectorization） ##

通过向量化可以去除代码中的for循环从而加快代码的运行速度。

import numpy as np
    import time
    
    # 通过round随机得到两个一百万维度的数组
    a = np.random.rand(1000000)
    b = np.random.rand(1000000)
    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循环的版本时间

输出为：

Vectorized version:9.537696838378906ms
    249765.47639794543
    For loop:659.264326095581ms

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

向量化的计算效率要远快于for循环的计算效率，因此要减少for循环的使用次数，在公式中如下体现：  
参数初始化 d w 1 = 0 , d w 2 = 0 dw\_1=0,dw\_2=0 dw1=0,dw2=0替换为 d w = n p . z e r o ( ( n x , 1 ) ) dw=np.zero((n\_x,1)) dw=np.zero((nx,1))  
 d w 1 + = x 1 ( i ) d z ( i ) , d w 2 + = x 2 ( i ) d z ( i ) dw\_1+=x\_1^\{(i)\}dz^\{(i)\},dw\_2+=x\_2^\{(i)\}dz^\{(i)\} dw1\+=x1(i)dz(i),dw2\+=x2(i)dz(i)替换为 d w + = x ( i ) d z ( i ) dw+=x^\{(i)\}dz^\{(i)\} dw\+=x(i)dz(i)

## 2.13向量化逻辑回归（Vectorizing Logistic Regression） ##

根据之前的知识：  
 a ( 1 ) = σ ( z ( 1 ) ) = σ ( w T x ( 1 ) + b ) a^\{(1)\}=\\sigma(z^\{(1)\})=\\sigma (w^Tx^\{(1)\}+b) a(1)=σ(z(1))=σ(wTx(1)\+b)

a ( 2 ) = σ ( z ( 2 ) ) = σ ( w T x ( 2 ) + b ) a^\{(2)\}=\\sigma(z^\{(2)\})=\\sigma (w^Tx^\{(2)\}+b) a(2)=σ(z(2))=σ(wTx(2)\+b)

a ( 3 ) = σ ( z ( 2 ) ) = σ ( w T x ( 3 ) + b ) a^\{(3)\}=\\sigma(z^\{(2)\})=\\sigma (w^Tx^\{(3)\}+b) a(3)=σ(z(2))=σ(wTx(3)\+b)

利用向量化的表示为： z = \[ z ( 1 ) , z ( 2 ) , . . . , z ( m ) \] = w T X + \[ b   . . .   b \] 1 × m = \[ w T x ( 1 ) + b , . . . , w T x ( m ) + b \] z=\[z^\{(1)\},z^\{(2)\},...,z^\{(m)\}\]=w^TX+\[b\\space ... \\space b\]\_\{1×m\}=\[w^Tx^\{(1)\}+b,...,w^Tx^\{(m)\}+b\] z=\[z(1),z(2),...,z(m)\]=wTX\+\[b ... b\]1×m=\[wTx(1)\+b,...,wTx(m)\+b\]

在程序中表示为： Z = n p . d o t ( w . T , X ) + b Z=np.dot(w.T,X)+b Z=np.dot(w.T,X)\+b

定义 A = \[ a ( 1 ) , a ( 2 ) , . . . , a ( m ) \] = σ ( Z ) A=\[a^\{(1)\}, a^\{(2)\},...,a^\{(m)\}\]=\\sigma (Z) A=\[a(1),a(2),...,a(m)\]=σ(Z)

## 2.14向量化回归的梯度输出（Vectorizing Logistic Regression’s Gradient） ##

不使用for循环，而是用向量实现逻辑回归:

正向传播： Z = w T X + b = n p . d o t ( w . T , X ) + b Z=w^TX+b=np.dot(w.T,X)+b Z=wTX\+b=np.dot(w.T,X)\+b

A = σ ( Z ) A=\\sigma(Z) A=σ(Z)

反向传播： d Z = A − Y dZ=A-Y dZ=A−Y

d w = 1 m ∗ X ∗ d z T dw=\\frac\{1\}\{m\}\*X\*dz^T dw=m1∗X∗dzT

d b = 1 m ∗ n p . s u m ( d Z ) db=\\frac\{1\}\{m\}\*np.sum(dZ) db=m1∗np.sum(dZ)

参数更新： w : = w − α ∗ d w w:=w-\\alpha\*dw w:=w−α∗dw

b : = b − α ∗ d b b:=b-\\alpha\*db b:=b−α∗db

## 2.15Python中的广播（Broadcasting in Python） ##

API中是这样解释broadcasting的：

> *The term broadcasting describes how numpy treats arrays with different shapes during arithmetic operations. Subject to certain constraints, the smaller array is “broadcast” across the larger array so that they have compatible shapes. Broadcasting provides a means of vectorizing array operations so that looping occurs in C instead of Python. It does this without making needless copies of data and usually leads to efficient algorithm implementations. There are, however, cases where broadcasting is a bad idea because it leads to inefficient use of memory that slows computation.*

通用公式：

*  矩阵 a m × n a\_\{m×n\} am×n加减乘除矩阵 b 1 × n b\_\{1×n\} b1×n，矩阵 b b b会触发广播机制复制转化为 b m × n b\_\{m×n\} bm×n。
 *  矩阵 c m × 1 c\_\{m×1\} cm×1加减乘除实数 R R R，会触发广播机制，实数 R R R会复制转化成 m m m行的实数矩阵。

## 2.16关于python\_numpy向量的说明（A Note on Python or Numpy Vectors） ##

tip：若不确定一个向量的维度（Dimension）,经常使用断言语句（Assertion Statement）: a s s e r t ( a . s h a p e = = ( 5 , 1 ) ) assert(a.shape==(5,1)) assert(a.shape==(5,1))

**错题笔记：**  
矩阵叉乘：需要矩阵 a a a的列数等于矩阵 b b b的行数。  
Matlab代码： c = a ∗ b ; c=a\*b; c=a∗b;  
Python代码： c = n p . d o t ( a , b ) c=np.dot(a,b) c=np.dot(a,b)

矩阵点乘：指按元素相乘，需要两矩阵维度相同。  
Matlab代码： c = a . ∗ b ; c=a.\*b; c=a.∗b;  
Python代码： c = n p . m u l t i p l y ( a , b ) c=np.multiply(a,b) c=np.multiply(a,b)或 c = a ∗ b c=a\*b c=a∗b

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/84c7679d43ec45ad82bac4fb1cb787f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/376422f4d5724183840aef1bd639e91e.png