《深度学习入门》前四章学习笔记

《深度学习入门》前四章学习笔记

第1章 Python入门与NumPy基础

1.1 Python基础语法

• 动态类型语言特性
• 列表/字典/元组操作
• 函数定义与类的基本用法

1.2 NumPy核心操作

• 数组生成：np.array(), np.arange()
• 广播机制（Broadcasting）

A = np.array([[1,2], [3,4]])
B = np.array([10,20])
A * B  # 自动扩展维度计算

• 矩阵运算：np.dot(), 元素级运算
• 索引技巧：切片、布尔索引

---

第2章 感知机（Perceptron）

2.1 感知机原理

• 数学表达式：
  ( y = \begin{cases}
  0 & (w_1x_1 + w_2x_2 + b \leq 0) \
  1 & (w_1x_1 + w_2x_2 + b > 0)
  \end{cases} )
• 局限性：只能表示线性空间

2.2 逻辑门实现

• 与门（AND）：权重(0.5, 0.5)，偏置-0.7
• 或门（OR）：权重(0.5, 0.5)，偏置-0.2
• 与非门（NAND）：权重(-0.5, -0.5)，偏置0.7

2.3 多层感知机

• 异或门实现：组合NAND+OR+AND

def XOR(x1, x2):
    s1 = NAND(x1, x2)
    s2 = OR(x1, x2)
    return AND(s1, s2)

• 核心结论：单层感知机无法解决非线性问题，多层网络可实现复杂逻辑

---

第3章 神经网络

3.1 激活函数

• Sigmoid：
  ( \sigma(x) = \frac{1}{1 + e^{-x}} )
• ReLU：
  ( \text{ReLU}(x) = \max(0, x) )
• 阶跃函数与sigmoid对比：连续可导性对梯度下降的重要性

3.2 网络架构

• 输入层 → 隐藏层 → 输出层
• 矩阵表示：
  ( \mathbf{Y} = \mathbf{X}\mathbf{W} + \mathbf{B} )

3.3 输出层设计

• 回归任务：恒等函数
• 分类任务：Softmax
  ( y_k = \frac{e^{{a_k}}{\sum_{i=1}}n e^{a_i}} )
• 批处理优化：提升矩阵运算效率

---

第4章 神经网络的学习

4.1 损失函数

• 均方误差（MSE）：
  ( E = \frac{1}{2}\sum_{k}(y_k - t_k)^2 )
• 交叉熵误差（CEE）：
  ( E = -\sum_{k} t_k \log y_k )

4.2 梯度计算

• 数值梯度法（中心差分）：
  ( \frac{df(x)}{dx} \approx \frac{f(x+h) - f(x-h)}{2h} )
• 反向传播的优势：计算效率比数值微分高10^4倍量级

4.3 学习算法实现

1. 初始化权重参数
2. 前向传播计算预测值
3. 计算损失函数值
4. 反向传播计算梯度
5. 参数更新：
   ( \mathbf{W} \leftarrow \mathbf{W} - \eta \frac{\partial L}{\partial \mathbf{W}} )

4.4 超参数要点

• 学习率（η）：典型值0.01或0.001
• 批大小：常用32/64/128
• 迭代次数：通过验证集确定

---

关键总结

1. 感知机局限性 → 通过多层网络解决非线性问题
2. 激活函数选择 → 引入非线性表达能力
3. 批处理技术 → 提升矩阵运算效率
4. 梯度计算方式 → 反向传播高效计算梯度
5. 学习率策略 → 影响模型收敛速度与稳定性

---

第1章 Python与NumPy示例

1.1 广播机制演示

import numpy as np

# 形状(2,2)与标量运算
A = np.array([[1,2],[3,4]])
print(A * 10)  # 标量自动广播

# 形状(2,2)与(2,)运算
B = np.array([10, 20])
print(A * B)   # 输出：[[10 40],[30 80]]

1.2 高级索引操作

# 布尔索引筛选数据
arr = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
print(arr[arr % 2 == 0])  # 输出：[0 2 4 6 8]

# 花式索引重塑数组
print(arr[[3, 1, 4]])  # 输出：[3 1 4]

---

第2章 感知机实现示例

2.1 与门实现类

class ANDGate:
    def __init__(self):
        self.w = np.array([0.5, 0.5])  # 权重
        self.b = -0.7                  # 偏置

    def forward(self, x):
        tmp = np.sum(self.w * x) + self.b
        return 0 if tmp <= 0 else 1

# 测试用例
and_gate = ANDGate()
print(and_gate.forward([1,1]))  # 输出1
print(and_gate.forward([0,0]))  # 输出0

2.2 多层感知机实现异或门

def NAND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([-0.5, -0.5])
    b = 0.7
    tmp = np.sum(w*x) + b
    return 0 if tmp <= 0 else 1

def OR(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.2
    tmp = np.sum(w*x) + b
    return 0 if tmp <= 0 else 1

def XOR(x1, x2):
    return AND(NAND(x1, x2), OR(x1, x2))

print(XOR(0,0))  # 0
print(XOR(1,0))  # 1
print(XOR(0,1))  # 1
print(XOR(1,1))  # 0

---

第3章 神经网络核心实现

3.1 激活函数实现

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

def relu(x):
    return np.maximum(0, x)

# 测试激活函数
x = np.array([-1.0, 0.0, 1.0])
print(sigmoid(x))  # [0.2689, 0.5, 0.7311]
print(relu(x))     # [0.0, 0.0, 1.0]

3.2 三层神经网络前向传播

def init_network():
    network = {}
    network['W1'] = np.array([[0.1,0.3,0.5], [0.2,0.4,0.6]])
    network['b1'] = np.array([0.1,0.2,0.3])
    network['W2'] = np.array([[0.1,0.4], [0.2,0.5], [0.3,0.6]])
    network['b2'] = np.array([0.1,0.2])
    return network

def forward(network, x):
    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']
    
    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    y = sigmoid(a2)
    return y

network = init_network()
x = np.array([1.0, 0.5])
print(forward(network, x))  # 示例输出：[0.574, 0.689]

---

第4章 学习过程实现

4.1 交叉熵误差实现

def cross_entropy_error(y, t):
    delta = 1e-7  # 防止log(0)
    if y.ndim == 1:
        y = y.reshape(1, -1)
        t = t.reshape(1, -1)
    
    batch_size = y.shape[0]
    return -np.sum(t * np.log(y + delta)) / batch_size

# one-hot编码示例
y = np.array([0.1, 0.9])    # 预测概率
t = np.array([0, 1])        # 真实标签
print(cross_entropy_error(y, t))  # 输出：0.105

4.2 数值梯度计算

def numerical_gradient(f, x):
    h = 1e-4
    grad = np.zeros_like(x)
    
    for idx in range(x.size):
        tmp_val = x[idx]
        
        x[idx] = tmp_val + h
        fxh1 = f(x)
        
        x[idx] = tmp_val - h
        fxh2 = f(x)
        
        grad[idx] = (fxh1 - fxh2) / (2*h)
        x[idx] = tmp_val
        
    return grad

# 测试梯度计算
def func(x):
    return x[0]**2 + x[1]**2

print(numerical_gradient(func, np.array([3.0,4.0])))  # [6. 8.]

4.3 简单梯度下降

def gradient_descent(f, init_x, lr=0.01, step_num=100):
    x = init_x.copy()
    
    for i in range(step_num):
        grad = numerical_gradient(f, x)
        x -= lr * grad
        
    return x

# 最小化函数f(x)=x0^2 + x1^2
init_x = np.array([-3.0, 4.0])
print(gradient_descent(func, init_x))  # 接近 [0,0]

---

关键代码说明

1. 广播机制：演示不同形状数组的自动扩展规则
2. 感知机实现：通过类封装实现逻辑门电路
3. 激活函数对比：Sigmoid与ReLU的非线性转换差异
4. 批处理实现：cross_entropy_error函数支持批量输入
5. 梯度验证：数值梯度法验证反向传播的正确性