机器学习（三）

### 神经网络结构

#### 多层感知机（MLP）
- **输入层**：这是神经网络的第一层，接受输入数据。例如，如果输入数据有三个特征，则输入层有三个节点。
- **隐藏层**：这些层位于输入层和输出层之间。每个隐藏层包含多个神经元，每个神经元都与前一层的所有神经元连接。隐藏层的数量和每层中的神经元数量可以调节以适应特定问题。
- **输出层**：生成最终预测结果。例如，对于一个二分类问题，输出层通常只有一个神经元，输出一个概率值。

### 权重学习

#### 权重更新
- **没有闭合解**：在神经网络中，权重更新无法通过简单的公式直接求解。必须使用迭代方法来找到一组使输出接近期望值的权重。
- **迭代优化**：通过迭代优化过程，逐步调整权重以最小化损失函数。例如，使用梯度下降算法。

#### 损失函数
- **定义**：损失函数衡量预测输出与实际标签之间的差异。常用的损失函数包括均方误差（MSE）和交叉熵损失。
- **目标**：最小化损失函数，即找到一组权重，使得网络输出与期望输出的差距最小。

### 梯度下降

#### 梯度下降法
- **基本原理**：通过计算损失函数关于每个权重的导数（梯度），然后沿着梯度的反方向更新权重，以减少损失。
- **更新公式**：`w = w - η * ∇L(w)`，其中`w`是权重，`η`是学习率，`∇L(w)`是损失函数关于`w`的梯度。

#### 反向传播（Backpropagation）
- **目的**：计算每层的梯度并更新权重。
- **步骤**：
  1. **前向传播**：计算网络的输出。
  2. **损失计算**：计算损失函数值。
  3. **反向传播**：从输出层开始，计算每一层的梯度，逐层传播到输入层。
  4. **权重更新**：使用梯度更新公式更新每一层的权重。

### 激活函数

#### 常见激活函数
- **Sigmoid**：将输入压缩到(0, 1)之间，公式为`σ(x) = 1 / (1 + e^(-x))`。用于二分类问题。
- **Tanh**：将输入压缩到(-1, 1)之间，公式为`tanh(x) = (e^x - e^(-x)) / (e^x + e^(-x))`。常用于隐藏层。
- **ReLU**：线性整流函数，公式为`ReLU(x) = max(0, x)`。解决了梯度消失问题，常用于隐藏层。
- **Leaky ReLU**：ReLU的变体，公式为`Leaky ReLU(x) = max(0.01x, x)`。允许一些负值通过。
- **Maxout**：选择多个输入中的最大值作为输出。
- **ELU**：指数线性单元，公式为`ELU(x) = x if x > 0 else α(e^x - 1)`。

### 计算图（Computational Graph）

#### 定义
- **计算图**：是一种表示数学函数的有向图，其中节点表示操作，边表示变量的流动。
- **前向传播**：从输入节点开始，逐步计算每个节点的输出，直到得到最终输出。
- **反向传播**：从输出节点开始，逐步计算每个节点的梯度，直到计算所有节点的梯度。

### 反向传播示例

#### 简单例子
- **前向传播**：
  - 计算每层的输出。
  - 保存中间结果以备后续梯度计算。
- **反向传播**：
  - 从输出层开始，计算每个输入的梯度。
  - 使用链式法则，将局部梯度和上游梯度相乘，依次计算每个节点的梯度。

#### 计算梯度
- **标量对标量**：普通导数。
- **向量对标量**：梯度，是一个向量，表示每个输入变化对输出的影响。
- **向量对向量**：雅可比矩阵，是一个矩阵，表示输入向量每个分量变化对输出向量每个分量的影响。

### 向量化反向传播

#### 实现
- **向量化计算**：使用矩阵运算代替显式的循环计算，提高计算效率。
- **避免显式构造大型雅可比矩阵**：通过隐式乘法计算梯度，节省内存和计算时间。

### 示例代码

#### Python实现一个两层神经网络
```python
import numpy as np

# 初始化参数
input_size = 3
hidden_size = 4
output_size = 1

W1 = np.random.randn(hidden_size, input_size)
W2 = np.random.randn(output_size, hidden_size)

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

def sigmoid_derivative(x):
    return x * (1 - x)

# 前向传播
def forward(X):
    z1 = np.dot(W1, X)
    a1 = sigmoid(z1)
    z2 = np.dot(W2, a1)
    y_hat = sigmoid(z2)
    return y_hat, z1, a1, z2

# 反向传播
def backward(X, y, y_hat, z1, a1, z2):
    global W1, W2
    m = y.shape[0]
    
    # 计算损失函数的梯度
    delta2 = (y_hat - y) * sigmoid_derivative(y_hat)
    dW2 = np.dot(delta2, a1.T) / m
    
    delta1 = np.dot(W2.T, delta2) * sigmoid_derivative(a1)
    dW1 = np.dot(delta1, X.T) / m
    
    # 更新权重
    W1 -= 0.01 * dW1
    W2 -= 0.01 * dW2

# 示例数据
X = np.array([[0.1, 0.2, 0.3]]).T
y = np.array([[1]])

# 训练
for i in range(10000):
    y_hat, z1, a1, z2 = forward(X)
    backward(X, y, y_hat, z1, a1, z2)

# 输出预测结果
print("Predicted output:", y_hat)
```

通过以上内容的详细讲解，你应该能够更好地理解神经网络的基本原理和实现方法。如果还有具体问题，请告诉我，我可以进一步深入解释。