python_神经网络

前言

提醒：
文章内容为方便作者自己后日复习与查阅而进行的书写与发布，其中引用内容都会使用链接表明出处（如有侵权问题，请及时联系）。
其中内容多为一次书写，缺少检查与订正，如有问题或其他拓展及意见建议，欢迎评论区讨论交流。

---

分类与回归算法

机器学习中的分类与回归算法是两种主要的监督学习任务，它们分别用于解决不同类型的问题。以下是这两种算法的总结：

1. 分类算法：
   分类算法用于将数据分成不同的类别，适用于输出为离散标签的问题。常见的分类算法包括：

   1. 逻辑回归：使用逻辑函数来估计概率，用于二分类问题，也可以扩展到多分类问题。
   2. 支持向量机（SVM）：通过找到最优的决策边界来最大化样本的分类准确率，适用于高维数据。
   3. 决策树：通过树结构来进行决策，每个节点代表一个特征的选择，叶子节点代表分类结果。
   4. 随机森林：由多个决策树组成的集成学习方法，通过投票来决定最终分类结果。
   5. 梯度提升决策树（GBDT）：通过构建和结合多个弱学习器来形成强学习器，适用于分类和回归问题。
   6. 朴素贝叶斯：基于贝叶斯定理，假设特征之间相互独立，适用于文本分类等场景。
   7. K近邻（KNN）：根据样本之间的距离进行分类，适用于小规模数据集。
   8. 神经网络：通过多层感知机学习数据的复杂模式，适用于图像、语音等复杂分类问题。

2. 回归算法：
   回归算法用于预测连续数值输出，适用于输出为连续变量的问题。常见的回归算法包括：

   1. 线性回归：通过拟合一条直线来预测目标变量的值，是最简单的回归方法。
   2. 岭回归：线性回归的扩展，通过引入L2正则化项来防止过拟合。
   3. Lasso回归：线性回归的另一种扩展，通过引入L1正则化项来进行特征选择。
   4. 弹性网回归：结合了岭回归和Lasso回归，同时引入L1和L2正则化项。
   5. 决策树回归：使用决策树结构来进行回归预测，适用于非线性关系。
   6. 随机森林回归：由多个决策树组成的集成学习方法，通过平均来决定最终回归结果。
   7. 梯度提升决策树回归（GBDT回归）：通过构建和结合多个弱学习器来形成强学习器，适用于回归问题。
   8. 支持向量回归（SVR）：支持向量机在回归问题上的应用，通过找到最优的决策边界来最大化样本的回归准确率。
   9. 神经网络回归：通过多层感知机学习数据的复杂模式，适用于复杂的回归问题。

3. 分类与回归算法的比较：

   • 输出类型：分类算法输出离散标签，回归算法输出连续数值。
   • 评估指标：分类算法常用准确率、召回率、F1分数等指标，回归算法常用均方误差（MSE）、均方根误差（RMSE）等指标。
   • 问题类型：分类算法适用于类别预测问题，如垃圾邮件检测；回归算法适用于数值预测问题，如房价预测。 在实际应用中，选择分类还是回归算法取决于问题的性质和需求。有时，可以将回归问题转化为分类问题，或者将分类问题转化为回归问题，具体取决于问题的特点和目标。

神经网络

B站大佬视频

从零设计并训练一个神经网络，你就能真正理解它了

原理分析

神经网络分类算法讲解
一、神经网络的基本结构与数学公式
神经网络主要由神经元组成。一个神经元的计算过程可以表示为：

1. 加权求和：
   $$z=w_1{x}_1+w_2{x}_2+...+w_n{x}_n+b=\sum _{i=1}^n{w}_i{x}_i+b$$
   其中，$x_i$ 是输入数据，$w_i$ 是对应的权重，$b$ 是偏置项。
2. 激活函数：
   $$a=\sigma (z)$$
   这里的 $a$ 是神经元的输出，$\sigma$ 是激活函数。常用激活函数包括 Sigmoid 和 ReLU 等。以 Sigmoid 为例：
   $$\sigma (z)=\frac{1}{1+e^{-z}}$$
   它将加权和 $z$ 映射到区间 (0, 1)，适用于二分类问题。
   二、分类算法中的前向传播
   以三层神经网络（输入层、隐藏层、输出层）为例：
3. 输入层到隐藏层：
   $$a_j^{(1)}=\sigma \left(\sum _{i=1}^n{w}_{ji}^{(1)}{x}_i+b_j^{(1)}\right)$$
   其中，$w_{ji}^{(1)}$ 是输入层到隐藏层的权重，$b_j^{(1)}$ 是隐藏层的偏置项。
4. 隐藏层到输出层：
   $$a_k^{(2)}=\sigma \left(\sum _{j=1}^m{w}_{kj}^{(2)}{a}_j^{(1)}+b_k^{(2)}\right)$$
   对于多分类问题，输出层常用 Softmax 函数：
   $$a_k^{(2)}=\frac{e^{z_k^{(2)}}}{\sum _{p=1}^p{e}^{z_p^{(2)}}}$$
   其中，$z_k^{(2)}$ 是输出层的加权和。Softmax 函数将输出转换为类别概率。
   三、分类算法中的训练过程（基于反向传播和梯度下降）
5. 损失函数：
   • 二分类问题的交叉熵损失：
     $$H(p,q)=-[y\log (q)+(1-y)\log (1-q)]$$
   • 多分类问题的交叉熵损失：
     $$H(p,q)=-\sum _{k=1}^p{y}_k\log (q_k)$$
6. 反向传播：
   • 输出层误差梯度：
     $${\delta }_k^{(2)}=a_k^{(2)}-y_k$$
   • 隐藏层误差梯度：
     $${\delta }_j^{(1)}={\sigma }^{\prime }(z_j^{(1)})\sum _{k=1}^p{w}_{kj}^{(2)}{\delta }_k^{(2)}$$
7. 梯度下降：
   • 权重更新：
     $$w_{ji}^{(\ell )}=w_{ji}^{(\ell )}-\eta \cdot {\delta }_j^{(\ell )}\cdot a_i^{(\ell -1)}$$
   • 偏置更新：
     $$b_j^{(\ell )}=b_j^{(\ell )}-\eta \cdot {\delta }_j^{(\ell )}$$
     通过迭代训练，使损失函数减小，得到有效分类模型。
     优势补充：

• 非线性拟合能力：自动学习复杂特征映射，适用于高维、非线性数据。
• 自动特征学习：减少人工特征工程，提高泛化能力。
• 泛化能力：通过正则化（如 L2 正则化）防止过拟合。L2 正则化公式：
  $$\text{正则化项}=\lambda \cdot \sum _w{w}^2$$
  其中，$\lambda$ 为正则化系数，$w$ 为权重参数。

---

反向传播数学原理

1. 损失函数：
   假设损失函数为 $C$，例如均方误差损失：
   $$C=\frac{1}{2}\sum _k(y_k-a_k^{(2)}{)}^2$$
   其中，$y$ 是真实标签，$a^{(2)}$ 是模型的预测结果。

2. 输出层误差：
   计算输出层的误差 ${\delta }_k^{(2)}$：
   $${\delta }_k^{(2)}=\frac{\partial C}{\partial z_k^{(2)}}=(a_k^{(2)}-y_k)\cdot {\sigma }^{\prime }(z_k^{(2)})$$
   其中，${\sigma }^{\prime }(z)=\sigma (z)\cdot (1-\sigma (z))$ 是 Sigmoid 激活函数的导数。

3. 隐藏层误差：
   将误差从输出层传回到隐藏层，计算隐藏层的误差 ${\delta }_j^{(1)}$：
   $${\delta }_j^{(1)}=\sum _k{\delta }_k^{(2)}\cdot w_{kj}^{(2)}\cdot {\sigma }^{\prime }(z_j^{(1)})$$
   其中，$z_j^{(1)}$ 是隐藏层第 $j$ 个神经元的加权和，${\sigma }^{\prime }$ 是激活函数的导数。

4. 梯度计算：
   计算损失函数对权重和偏置的梯度：

   • 输出层权重和偏置：
     $$\frac{\partial C}{\partial w_{kj}^{(2)}}={\delta }_k^{(2)}\cdot a_j^{(1)}$$
     $$\frac{\partial C}{\partial b_k^{(2)}}={\delta }_k^{(2)}$$
   • 隐藏层权重和偏置：
     $$\frac{\partial C}{\partial w_{ij}^{(1)}}={\delta }_j^{(1)}\cdot x_i$$
     $$\frac{\partial C}{\partial b_j^{(1)}}={\delta }_j^{(1)}$$

5. 参数更新：
   使用梯度下降更新参数：

   • 输出层权重和偏置：
     $$w_{kj}^{(2)}=w_{kj}^{(2)}-\eta \cdot {\delta }_k^{(2)}\cdot a_j^{(1)}$$
     $$b_k^{(2)}=b_k^{(2)}-\eta \cdot {\delta }_k^{(2)}$$
   • 隐藏层权重和偏置：
     $$w_{ij}^{(1)}=w_{ij}^{(1)}-\eta \cdot {\delta }_j^{(1)}\cdot x_i$$
     $$b_j^{(1)}=b_j^{(1)}-\eta \cdot {\delta }_j^{(1)}$$
     其中，$\eta$ 是学习率。

6. 链式法则：
   整个反向传播过程实际上是链式法则的运用，通过层层传递误差来计算梯度：
   $$\frac{\partial C}{\partial w}=\frac{\partial C}{\partial a}\cdot \frac{\partial a}{\partial z}\cdot \frac{\partial z}{\partial w}$$

7. 实际应用中的优化：

   • 梯度消失和梯度爆炸：通过使用合适的激活函数（如 ReLU）、更好的权重初始化方法（如 He 初始化）和梯度校正算法（如 Adam）来解决。
   • 批处理和批标准化：通过批处理和批标准化减小内部协变量偏移，使梯度下降更加稳定。

通过这些步骤，反向传播算法能够有效地优化神经网络的权重和偏置，使得模型在训练数据上达到更好的拟合效果。

代码实现

手动实现

代码解释：
神经网络结构
输入层：2个神经元（特征）
隐藏层：3个神经元，使用Sigmoid激活函数
输出层：1个神经元，使用Sigmoid激活函数
示例问题
使用神经网络分类以下两个类别的数据：
类别0：点集 {(0,0), (0,1)}
类别1：点集 {(1,0), (1,1)}

import numpy as np

# 激活函数和其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

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

# 初始化权重和偏置
input_size = 2
hidden_size = 3
output_size = 1

np.random.seed(0)
weights_input_hidden = np.random.uniform(size=(input_size, hidden_size))
bias_hidden = np.random.uniform(size=(1, hidden_size))
weights_hidden_output = np.random.uniform(size=(hidden_size, output_size))
bias_output = np.random.uniform(size=(1, output_size))

# 训练数据
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [0], [1], [1]])

# 学习率
learning_rate = 0.1

# 训练神经网络
for epoch in range(10000):
    # 前向传播
    hidden_input = np.dot(X, weights_input_hidden) + bias_hidden
    hidden_output = sigmoid(hidden_input)
    final_input = np.dot(hidden_output, weights_hidden_output) + bias_output
    final_output = sigmoid(final_input)
    
    # 计算损失
    loss = y - final_output
    
    # 反向传播
    d_output = loss * sigmoid_derivative(final_output)
    error_hidden_layer = d_output.dot(weights_hidden_output.T)
    d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_output)
    
    # 更新权重和偏置
    weights_hidden_output += hidden_output.T.dot(d_output) * learning_rate
    bias_output += np.sum(d_output, axis=0, keepdims=True) * learning_rate
    weights_input_hidden += X.T.dot(d_hidden_layer) * learning_rate
    bias_hidden += np.sum(d_hidden_layer, axis=0, keepdims=True) * learning_rate

# 测试神经网络
print("测试结果：")
for i in range(len(X)):
    hidden_input = np.dot(X[i], weights_input_hidden) + bias_hidden
    hidden_output = sigmoid(hidden_input)
    final_input = np.dot(hidden_output, weights_hidden_output) + bias_output
    final_output = sigmoid(final_input)
    print(f"输入：{X[i]}，预测输出：{final_output}, 真实输出：{y[i]}")

运行结果：

python函数库实现

使用Tensorflow，使用GPU训练，配置可参见：
【深度学习】TensorFlow（cuda版）安装以及对应第三方库安装流程

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

# 定义模型
model = Sequential([
    Dense(units=3, activation='sigmoid', input_shape=(2,)),  # 隐藏层
    Dense(units=1, activation='sigmoid')  # 输出层
])

# 编译模型
model.compile(optimizer=Adam(learning_rate=0.1), loss='binary_crossentropy', metrics=['accuracy'])

# 训练数据
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [0], [1], [1]])

# 训练模型
model.fit(X, y, epochs=10000, verbose=0)

# 测试模型
print("测试结果：")
predictions = model.predict(X)
for i in range(len(X)):
    print(f"输入：{X[i]}，预测输出：{predictions[i].round()}, 真实输出：{y[i]}")

运行结果：