Course 1：神经网络与深度学习基础

课程简介

学习神经网络的数学基础与搭建方法，理解逻辑回归、梯度下降、向量化等核心概念。

🎬 本课程视频：Deep Learning Specialization — 深度学习专项课程

一、逻辑回归：深度学习的构建基石

逻辑回归（Logistic Regression）是深度学习中最基础也是最重要的二分类算法。它的核心思想是将输入特征经过线性组合后，通过一个非线性激活函数映射到概率输出，从而完成分类任务。这个看似简单的模型实际上是整个深度学习大厦的基石——理解逻辑回归，你就理解了神经网络中每个神经元的工作原理。

1.1 模型表示与数学推导

给定输入特征向量 $x \in \mathbb{R}^n$，逻辑回归首先计算一个线性组合：

$$z = w^T x + b = w_1 x_1 + w_2 x_2 + \cdots + w_n x_n + b$$

其中 $w \in \mathbb{R}^n$ 是权重向量，$b \in \mathbb{R}$ 是偏置项。线性组合 $z$ 的取值范围是 $(-\infty, +\infty)$，但我们希望输出一个介于0和1之间的概率值。为此，我们引入Sigmoid函数：

$$\hat{y} = \sigma(z) = \frac{1}{1 + e^{-z}}$$

Sigmoid函数具有以下重要性质：当 $z \to +\infty$ 时 $\sigma(z) \to 1$；当 $z \to -\infty$ 时 $\sigma(z) \to 0$；当 $z=0$ 时 $\sigma(0)=0.5$。特别重要的是它的导数形式：$\sigma'(z) = \sigma(z)(1-\sigma(z))$，这在梯度下降中非常有用。

1.2 损失函数的选择

为什么逻辑回归不使用均方误差（MSE）？如果使用MSE：$\mathcal{L} = \frac{1}{2}(\hat{y} - y)^2$，代入 $\hat{y} = \sigma(w^T x + b)$ 后，损失函数关于参数 $w$ 是非凸的——存在多个局部极小值。交叉熵损失是凸函数，可以保证梯度下降找到全局最优：

$$\mathcal{L}(\hat{y}, y) = -[y \log \hat{y} + (1-y) \log (1-\hat{y})]$$

当 $y=1$ 时：如果 $\hat{y}$ 接近1，损失接近0；如果 $\hat{y}$ 接近0，损失趋近无穷大。当 $y=0$ 时：如果 $\hat{y}$ 接近0，损失接近0；如果 $\hat{y}$ 接近1，损失趋近无穷大。

整个训练集的成本函数：

$$J(w,b) = -\frac{1}{m}\sum_{i=1}^{m}[y^{(i)}\log\hat{y}^{(i)} + (1-y^{(i)})\log(1-\hat{y}^{(i)})]$$

1.3 梯度下降推导

使用链式法则求导：

$$\frac{\partial\mathcal{L}}{\partial w_j} = \frac{\partial\mathcal{L}}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w_j}$$

其中 $a = \hat{y} = \sigma(z)$。分别计算：
- $\frac{\partial\mathcal{L}}{\partial a} = -\frac{y}{a} + \frac{1-y}{1-a}$
- $\frac{\partial a}{\partial z} = a(1-a)$
- $\frac{\partial z}{\partial w_j} = x_j$

代入化简后得到简洁的结果：$\frac{\partial\mathcal{L}}{\partial w_j} = (a - y) x_j$

对于整个训练集：

$$\frac{\partial J}{\partial w_j} = \frac{1}{m}\sum_{i=1}^{m}(a^{(i)} - y^{(i)})x_j^{(i)}$$
$$\frac{\partial J}{\partial b} = \frac{1}{m}\sum_{i=1}^{m}(a^{(i)} - y^{(i)})$$

参数更新：$w_j := w_j - \alpha \frac{\partial J}{\partial w_j}$，$b := b - \alpha \frac{\partial J}{\partial b}$

1.4 向量化实现

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# 前向传播（向量化）
Z = np.dot(W.T, X) + b
A = sigmoid(Z)
cost = -1/m * np.sum(Y * np.log(A) + (1-Y) * np.log(1-A))

# 反向传播（向量化）
dW = 1/m * np.dot(X, (A - Y).T)
db = 1/m * np.sum(A - Y)

# 参数更新
W = W - learning_rate * dW
b = b - learning_rate * db

对比循环实现和向量化实现：循环实现需要 $O(m \times n)$ 次操作，向量化实现利用BLAS库将常数因子降低数十倍。

1.5 完整逻辑回归实现

class LogisticRegression:
    def __init__(self, lr=0.01, num_iter=1000):
        self.lr = lr
        self.num_iter = num_iter
        self.W = None
        self.b = None

    def fit(self, X, Y):
        m = X.shape[1]
        self.W = np.zeros((X.shape[0], 1))
        self.b = 0.0

        for i in range(self.num_iter):
            Z = np.dot(self.W.T, X) + self.b
            A = 1 / (1 + np.exp(-Z))
            cost = -1/m * np.sum(Y * np.log(A) + (1-Y) * np.log(1-A))

            dW = 1/m * np.dot(X, (A - Y).T)
            db = 1/m * np.sum(A - Y)

            self.W -= self.lr * dW
            self.b -= self.lr * db

            if i % 100 == 0:
                print(f"Iter {i}, cost = {cost:.6f}")
        return self

    def predict(self, X):
        A = 1 / (1 + np.exp(-(np.dot(self.W.T, X) + self.b)))
        return (A > 0.5).astype(int)

1.6 逻辑回归与神经网络的关系

逻辑回归可以看作是一个单神经元神经网络。每个隐藏神经元的计算本质上都是一个逻辑回归——线性变换加激活函数。理解逻辑回归就是理解神经网络的基本计算单元。

1.7 学习率选择

学习率 $\alpha$ 是最重要的超参数。过大导致震荡甚至发散，过小导致收敛极慢。常用策略：从${0.1, 0.01, 0.001}$中选择，观察损失曲线的下降速度。学习率衰减策略可以让训练更稳定。

二、浅层神经网络

2.1 网络结构

一个标准的浅层神经网络包含输入层、一个隐藏层和输出层：
- 输入层：$a^{[0]} = x$
- 隐藏层：$z^{[1]} = W^{[1]}a^{[0]} + b^{[1]}$，$a^{[1]} = \sigma(z^{[1]})$
- 输出层：$z^{[2]} = W^{[2]}a^{[1]} + b^{[2]}$，$a^{[2]} = \sigma(z^{[2]})$

2.2 激活函数

Tanh：$\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}$，输出范围(-1,1)，均值为0

ReLU：$\text{ReLU}(z) = \max(0, z)$，最常用的隐藏层激活函数，计算简单，梯度不衰减

Leaky ReLU：$\text{LeakyReLU}(z) = \max(0.01z, z)$，解决ReLU死亡问题

2.3 反向传播推导

输出层梯度：$dZ^{[2]} = A^{[2]} - Y$，$dW^{[2]} = \frac{1}{m}dZ^{[2]}A^{[1]T}$

隐藏层梯度：$dZ^{[1]} = W^{[2]T}dZ^{[2]} \odot g'(Z^{[1]})$，$dW^{[1]} = \frac{1}{m}dZ^{[1]}X^T$

2.4 权重初始化

零初始化导致对称性问题——所有神经元学到相同特征。推荐随机初始化：$W = \text{np.random.randn}(n_h, n_x) \times 0.01$，打破对称性。