吴恩达《深度学习》-第一门课 (Neural Networks and Deep Learning)-第二周：(Basics of Neural Network programming)-课程笔记

第二周：神经网络的编程基础 (Basics of Neural Network programming)

2.1、二分类(Binary Classification)

二分类问题的目标就是习得一个分类器，它以图片的特征向量（RGB值的矩阵，最后延展成一维矩阵x，如下）作为输入，然后预测输出结果为 1 还是 0：

主要需要注意的是一些符号定义：

：表示一个维数据，为输入数据，维度为(, 1)；

：表示输出结果，取值为(0,1)；

( () , () )：表示第组数据，可能是训练数据，也可能是测试数据，此处默认为训练数 据；

= [ (1) , (2) , . . . , () ]：表示所有的训练数据集的输入值，放在一个 × 的矩阵中， 其中表示样本数目，输入神经网络时数据形状为 $ nx∗m:([x(1),x(2)⋯ x(m)]) $ 而非 \(m * nx:\left(\begin{matrix} x_{(1)}^T \\ x_{(2)}^T \\ \vdots\\ x_{(m)}^T \\ \end{matrix}\right)\)

= [ (1) , (2) , . . . , () ]：对应表示所有训练数据集的输出值，维度为1 × 。

python实现的时候：.shape 等于(, )，Y.shape 等于(1, )

---

2.2、 逻辑回归(Logistic Regression)

让\(\hat{y}\)表示实际值等于 1 的机率的话， \(\hat{y}\)应该在 0 到 1 之间。因为\(w^Tx +b\)可能比 1 要大得多，或者甚至为一个负值。因此在逻辑回归中，输出应该是\(\hat{y}\)等于由上面得到的线性函数式子\(w^Tx +b\)作为自变量的 sigmoid 函数中，将线性函数转换为非线性函数。

介绍一种符号惯例，可以让参数和参数分开 :

定义一个额外的特征称之为\(x_0\)，并且使它等于 1，那么现在就是一 个+1 维的变量

这样\(\theta_0\)就充当了，这是一个实数，而剩下的\(\theta_1\) 直到\(\theta_{nx}\) 充当了\(w\)

---

2.3 逻辑回归的代价函数（Logistic Regression Cost Function）

训练代价函数来得到参数和参数b：

损失函数又叫做误差函数，Loss function：\(L(\hat{y},y)\).

逻辑回归中用到的损失函数是： \(L(\hat{y},y)=-(ylog(\hat{y}+(1-y)log(1-\hat{y}))\)

使用该Loss function 的理由：

​ 当 = 1时损失函数\( = −log(\hat{y})\)，如果想要损失函数尽可能得小，那么 \(\hat{y}\) 就要尽可能大， 因为 sigmoid 函数取值[0,1]，所以 \(\hat{y}\) 会无限接近于 1。

​ 当 = 0时损失函数 = −log(1 − \(\hat{y}\) )，如果想要损失函数尽可能得小，那么\(\hat{y}\) 就要尽可能小，因为 sigmoid 函数取值[0,1]，所以\(\hat{y}\) 会无限接近于 0。

有很多的函数效果和现在这个类似，就是如果等于 1，我们就尽可能让 \(\hat{y}\) 变大，如果等于 0，我们就尽可能让 \(\hat{y}\) 变小。

损失函数是在单个训练样本中定义，它衡量的是算法在单个训练样本中表现。

衡量算法在全部训练样本上的表现，需要定义一个算法的代价函数（Cost function）：对个样本的损失函数求和然后除以：

在训练逻辑回归模型时候，需要找到合适的和，来让代价函数 的总代价降到最低。

逻辑回归可以看做是一个非常小的神经网络。

---

2.4 梯度下降法（Gradient Descent）

梯度下降法（仅有一个参数）

=表示更新参数.

表示学习率（learning rate），用来控制步长（step）.

\(\frac{()}{}\)就 是函数()对 求导（derivative） 对于导数更加形象化的理解就是斜率（slope）.

逻辑回归的代价函数（成本函数）(, )是含有两个参数的：

\[w := w - a\frac{\partial J(w,b)}{\partial w} \qquad b := b - a\frac{\partial J(w,b)}{\partial b} \]

在代码中使用 表示 \(\frac{\partial J(w,b)}{\partial w}\)， 使用 \(db\) 表示\(\frac{\partial J(w,b)}{\partial b}\)

---

2.5 导数（Derivatives）

超简单导数讲解，没什么笔记。

---

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

一些基础函数的导数讲解。

---

2.7 计算图（Computation Graph）

神经网络的计算，都是按照前向或反向传播过程组织的：

首先我们计算出一个新的网络的输出（前向过程），紧接着进行一个反向传输操作。后者我们用来计算出对应的梯度或导数。

计算图解释了为什么我们用这种方式组织这些计算过程，计算图组织计算的形式是用蓝色箭头从左到右的计算。

---

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

主要使用的是求导中的链式法则：

\[\frac{dJ}{du} = \frac{dJ}{dv} \frac{dv}{du} \quad , \quad\frac{dJ}{db}=\frac{dJ}{du}\frac{du}{db} \quad , \quad\frac{dJ}{da}=\frac{dJ}{du}\frac{du}{da} \]

这是一个计算流程图，就是正向或者说从左到右的计算来计算成本函数，然后反向从右到左计算导数。

---

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

和的修正量,\(a\)为学习率:

\[w:=w-a\frac{\partial J(w,b)}{\partial w}\quad,\quad b:=b-a\frac{\partial J(w,b)}{\partial b} \]

微积分得到：

\[\frac{dL(a,y)}{da}=-(y/a+(1-y)/(1-a)) \]

\[\frac{da}{dz}=f'(z)=\left( \frac{1}{1+e^{-z}}\right)'=\frac{e^{-z}}{(1+e^{-z})^2}=\frac{1+e^{-z}-1}{(1+e^{-z})^2}=\frac{1}{(1+e^{-z})}\left(1-\frac{1}{1+e^{-z}}\right)=a(1-a) \]

\[\frac{dL(a,y)}{dz}=\frac{dL}{dz}=(\frac{dL}{da})\cdot(\frac{da}{dz})=(-\frac{y}{a}+\frac{(1-y)}{(1-a)})\cdot a(1-a)=a-y​ \]

现在进行最后一步反向推导：

\(dw_1\)表示\(\frac{\partial L}{\partial w_1}\)，\(dw_2\)表示\(\frac{\partial L}{\partial w_2}\)，\(db=dz\)。

然后: 更新\(_1 = _1 − _1\)， 更新\(_2 = _2 − _2\)， 更新\( = − \)。

2.10 m 个样本的梯度下降(Gradient Descent on m Examples)

损失函数(, )的定义：

\[J(w,b)=\frac{1}{m}\sum_{i=1}^mL(a^{(i)},y^{(i)}) \]

现在带有求和的全局代价函数，实际上是 1 到项各个损失的平均。 它表明全局代价函数对1的微分，对1的微分也同样是各项损失对1微分的平均。

代码流程：

初始化：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;
J/= m;
dw1/= m;
dw2/= m;
db/= m;
w=w-alpha*dw
b=b-alpha*db

这种计算中有两个缺点：

需要编写两个 for 循环。 第一个 for 循环是一个小循环遍历个训练样本，第二个 for 循环是一个遍历所有特征的 for 循环。这个例子中只有 2 个特征，所以等于 2 并且 等于 2。 但如果有更多特征， 需要一 个 for 循环遍历所有个特征。

向量化技术：可以允 许代码摆脱这些显式的 for 循环。

2.11 向量化(Vectorization)

矩阵向量的加减，主要突出：采用numpy库函数进行向量的运算速度比使用for循环快超级多！

import numpy as np #导入 numpy 库
a = np.random.rand(1000000)
b = np.random.rand(1000000) #通过 round 随机得到两个一百万维度的数组
c = np.dot(a,b)#向量相加

for i in range(1000000):#采用for循环
 c += a[i]*b[i]

运行时间对比：

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

矩阵乘法$ u=Av $:

向量化方式就可以用 = . (, )，消除了两层循环使得代码运行速度更快。

主要就是用numpy进行矩阵的运算。

2.13 向量化逻辑回归(Vectorizing Logistic Regression)

用numpy库的计算表示logistic regression。

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

2.13中虽然去掉了一个for循环：针对w、d等参数的，但仍有一个遍历训练集的循环：

\[ = 0\\ += ^{(1)}∗ ^{(1)}\\ += ^{(2)}∗ ^{(2)}\\ ………….\\ \\ += ^{()}∗ ()\\ = \frac{}{}\\ = 0\\ += ^{(1)}\\ += ^{(2)}\\ ………….\\ += ^{()}\\ = \frac{}{}\\ \]

但计算 仍然需要一个循环遍历训练集，所以就用一个np.sum函数来快速替代就好了。

2.15 Python 中的广播（Broadcasting in Python）

broadcasting可以这样理解：如果你有一个mn的矩阵，让它加减乘除一个1n的矩阵，它会被复制m次，成为一个mn的矩阵，然后再逐元素地进行加减乘除操作。同样地对m1的矩阵成立：

2.16 关于 python _ numpy 向量的说明（A note on python or numpy vectors）

Python 语言巨大的灵活性也是缺点，由于广播巨大的灵活性，有时候可能会产生很细微或者看起来很奇怪的 bug。例如，将一个列向量添加到一个行向量中，会以为它报出维度不匹配或类型错误之类的错误，但是实际上会得到一个行向量和列向量的求和。

是如果对 Python 不熟悉的话，就可能会非常生硬、非常艰难地去寻找 bug。

置 = . . (5)此时 的 shape（形 状）是一个(5, )的结构。这在 Python 中被称作一个一维数组。相反，如果你设置 为(5,1)，那么这就将置于 5 行 1 列向量中。

要去简化你的代码，而且不要使用一维数组。总是使用 × 1 维矩阵（基本上是列向量），或者 1 × 维矩阵（基本上是行向量）

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

jupyter介绍，没什么好说的。

2.18 （选修）logistic 损失函数的解释（Explanation of logistic regression cost function）

约定 \(\hat{} = ( = 1|)\) ，即算法的输出\(\hat{}\)是 给定训练样本 条件下 等于 1 的概率。 换句话说，如果 = 1，在给定训练样本 条件下y = \(\hat{}\)； 反过来说，如果 = 0，在给定训练样本条件下 ( = 1 − \(\hat{}\))， 因此，如果 \(\hat{}\) 代表 = 1 的概率，那么1 − \(\hat{}\)就是 = 0的概率。 接下来，我们就来分析这两个条件概率公式。

\[If \qquad y=1:\qquad p(y|x)=\hat{y}\\ If \qquad y=0:\qquad p(y|x)=1-\hat{y} \]

可以将这两个公式合并成一个公式。需要指出的是我们讨论的是二分类问题的损失函 数，因此，的取值只能是 0 或者 1:

\[p(y|x)=\hat{y}^y(1-\hat{y})^{(1-y)} \]

第一种情况:\(y=1 \quad (|) = \hat{y}\)

第二种情况:$y=0\quad p(y|x)=1\times(1-\hat{y})^{1-y} $

由于 log 函数是严格单调递增的函数，最大化 ((|)) 等价于最大化 (|) 通过对数 函数化简为：

\[ylog(\hat{y})+(1-y)log(1-\hat{y}) \]