0. 前言

机器学习 算法，并列，其 随机森林 和 神经网络 都是 基础的方法

**其方法之前，还有一个特征工程 + 数据预处理步骤 **
神经网络最大特点： 能够接收 高维数据，所以 他很自然的成为了 特征工程后，接收信息的东西。

神经网络 和 SVM，随机森林 都并列， 深度学习 = 自动化 特征工程 + 多层神经网络

构建神经网络 ==== 输入层 隐藏层 输出层，
由 神经元 组成，
加上 损失函数，激活函数（二者都 非线性）

1. 前向传播 按照 流程进行， 输入，然后 隐藏，然后输出，信息是没有反馈的。

其实 ，这些算法的目的，都是拟合，用一些已知的数据 拟合出一个函数，然后用这个函数，对未来的输入进行结果预测。

神经网络，就是一个 万能函数拟合工具，其可以逼近任意复杂的函数。 这使得其在 回归，分类，生成 等任务中 表现出色。

有一个万能函数逼近定理，就是说 一个具有足够多隐藏层神经元的前馈神经网络，可以以任意精度逼近任何连续函数。具体来说，对于任意一个连续函数 f:Rn →R，存在一个前馈神经网络，其输入层有 n 个神经元，输出层有 1 个神经元，隐藏层有足够多的神经元，使得该网络能够以任意精度逼近函数 f。

1. 神经网络

1.1 基本结构

a. 神经元（Neurons） 就是一个 非线性 y = f ( kx+b )

其中 kx+b 是线性的， 然后找一个激活函数 f() 。它提供非线性。

一个神经元接收多个输入，通过 加权求和后， 再经过一个激活函数，产生输出。

激活函数 直接影响 反向传播中 梯度计算的值，所有选择不同的激活函数的特性会影响到反向传播梯度计算这个过程。

激活函数的数学特性 会直接影响梯度计算的 稳定性和效率

一些常见的激活函数( activation function )：

Sigmoid （torch 中称为 logistic）:适用于二分类，y∈(0,1)，但两端梯度接近于0，可能导致梯度消失问题。

Relu（Rectified Linear Unit）：可以解决梯度消失问题，输出非负，适用于 隐藏层

Tanh（双曲正切函数）：y∈(-1,1)，梯度在两端接近于0

b. 神经网络的层，一层一层由神经元组成

1.2 网络训练

a. 正向传播：样本的特征进来——经过很多神经元 得到结果

b.计算损失：预测结构和正式结果计算损失

c.反向传播：从后往前 计算每个参数的梯度，梯度下降法更新参数

所谓的反向传播，就是一个链式法则，对 函数求偏导，然后算梯度，再按照最大梯度方向，用步长去进行调参。

优化器：动态调整步长，步长：就是每次沿梯度方向，走多少。

找一个合适的损失函数，

2.数据预处理

从数据尺寸来看，

对于结构化数据而言，假设每个样本的每个特征都是 float ，10000个样本，100个特征，则共计为 100001004 = 410^6 字节，也就是 4 MB，很小
但是对于 图像数据而言， 若为 RGB三通道图像，每个像素用单精度浮点数，一张照片 1024x1024x3x4 = 1210^6 字节，若有10000张，那么大约为 117GB ，显存根本不够。

从硬件设备上

GPU 具有多个核心，适用于并行计算，处理图形数据占优， 但是若数据量过大，其会超过显存容量，会出现显存溢出问题。
CPU 八核 或者 十二核 的CPU，虽然 核心 相对GPU少，但是 每个核心功能更加强大

所以 机器学习，直接加载数据即可，而深度学习，则要多次处理数据集。

numpy —— 读取后 转化为 array 格式
pandas —— 读取后 转化为 dataframe 格式
torch —— 读取后 转化为 tensor 格式 张量
因为每个包 在底层都对常见任务做了优化，所以需要变成自己的数据格式 才好计算

Dataset 类，pytorch 中 定义数据集结构的基础类

用户需要继承该类，而后实现 len 和 getitem 方法，以便返回数据集的样本和样本数量。

** python 的继承**

class BaseClass:
  #基类主体
class DerivedClass(BaseClass):
  #派生类的主体

from torch.utils.data import Dataset
# 定义一个 MyDataset 的类，然后继承 Dataset 
class MyDataset(Dataset):
    def __init__(self, images, labels):
        self.images = images  # 图片数据
        self.labels = labels  # 标签数据

    def __len__(self):    # 提供一个 _len_ 的 属性 
        return len(self.images)  # 返回数据集的总样本数量

    def __getitem__(self, index):       
        image = self.images[index]  # 根据索引获取图片
        label = self.labels[index]  # 根据索引获取标签
        return image, label  # 返回图片和标签

DataLoader ，pytorch 中 用于 批量加载数据的工具，能够将 Dataset 中数据分成小批次，并 支持多线程加载。

迭代 Dataset ，提供 批处理，打乱数据顺序，并行加载。

用户需首先自定义一个 Dataset 类，处理数据， 而后将 Dataset 实例传递给 DataLoader
super() 是一个内置函数，用于调用父类（基类）的方法。在类的继承中，super() 通常用于调用父类的构造方法（init 方法），以确保父类的初始化逻辑被执行。这在定义子类时尤为重要，因为它确保了父类的属性和方法被正确初始化。

for batch_idx, (batch_data, batch_labels) in enumerate(data_loader):
这个循环表示在每个 epoch 中，数据集会被分成多个小批次。

data_loader 会根据 batch_size 参数，将数据集分成多个批次。一批次数据有 batch_size 个。

每个批次包含 batch_size 个样本。
batch_idx 是当前批次的索引。
batch_data 是当前批次的输入数据。
batch_labels 是当前批次的标签。

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc = nn.Linear(10, 2)

    def forward(self, x):
        return torch.softmax(self.fc(x), dim=1)
# 创建 Dataset 实例
data = torch.randn(100, 10)  # 100 个样本，每个样本 10 个特征
labels = torch.randint(0, 2, (100,))  # 100 个标签，取值为 0 或 1
dataset = MyDataset(data, labels)

# 创建 DataLoader 实例
data_loader = DataLoader(dataset, batch_size=10, shuffle=True, num_workers=2)

# 初始化模型、损失函数和优化器
model = MyModel()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(5):  # 训练 5 个 epoch
    for batch_idx, (batch_data, batch_labels) in enumerate(data_loader):
        optimizer.zero_grad()       # 清空梯度
        output = model(batch_data)  # 前向传播
        loss = criterion(output, batch_labels)  # 计算损失
        loss.backward()             # 反向传播
        optimizer.step()            # 更新权重
        if batch_idx % 5 == 0:
            print(f"Epoch {epoch+1}, Batch {batch_idx+1}, Loss: {loss.item()}")
            

3. 模型实例化

机器学习中，直接是封装好的各种模型的类 如：model = SVM()

但 深度学习中，因为模型提供了更多的自由（神经网络的层数，每层的神经元数量），所以 只提供了一个基础的类，我们要重新定义一个类，然后继承这个基础类的数学，方法，并且写自己的方法，属性。

4. 模型的训练

机器学习 关于训练 只需要一步 model.fit

但是深度学习的训练，则需要 实例化损失函数，优化器，写训练原理

在每个迭代中，执行以下步骤

前向传播 模型传递输入数据 计算预测

计算损失 使用 损失函数，评估 预测和真实标签之间的差异

反向传播 根据损失 计算梯度

权重更新 使用优化器模型，更新模型权重 —— 优化器模型，就是动态调整步长

5. 模型评估

机器学习就一句话 y_pred = model.predict(X_test)

但是深度学习，以批次的方式来加载数据，预测结果，需要自己写——再次用到加载器

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
import numpy as np

# 生成一些示例数据
X = np.random.rand(100, 10)  # 100 个样本，每个样本有 10 个特征
y = np.random.randint(0, 2, 100)  # 二分类问题，标签为 0 或 1

# 将数据转换为 PyTorch 张量
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.long)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建 DataLoader
train_dataset = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(10, 16)  # 输入层到隐藏层
        self.fc2 = nn.Linear(16, 2)   # 隐藏层到输出层

    def forward(self, x):
        x = F.relu(self.fc1(x))  # 激活函数
        x = self.fc2(x)
        return x

# 初始化模型
model = MyModel()

# 定义损失函数（交叉熵损失）
criterion = nn.CrossEntropyLoss()

# 定义优化器（Adam 优化器）
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    for inputs, labels in train_loader:
        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 打印每个 epoch 的损失
    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# 测试模型
model.eval()  # 设置模型为评估模式
with torch.no_grad():
    X_test = torch.tensor(X_test, dtype=torch.float32)
    y_test = torch.tensor(y_test, dtype=torch.long)
    outputs = model(X_test)
    _, predicted = torch.max(outputs, 1)
    accuracy = (predicted == y_test).sum().item() / len(y_test)
    print(f'Test Accuracy: {accuracy:.4f}')

6. 过拟合

损失函数的值 虽然越小确实表示模型在训练数据上表现的越好，但是这并不一定意味着 模型在 测试数据上的表现也会更好， 因为 很有可能 就是 过拟合 现象。

在上述代码的调参中，我发现 虽然 更改模型的层数和神经元数量后，损失函数值变大， 但是 最后的测试集确实变得更好。

模型 过于复杂（层数+神经元数量）会使得学习到训练数据中的噪声和异常值，而非是数据中的真实模式。

另外，如果数据本身有问题，分布不均匀等，那就是过拟合的，没有泛化能力。

如果没有使用正则化，就是在一些模型中，1000 和 1 可能在权重或者计算上影响较大，这样子的话，也会指的模型变向一部分数据。

7.避免过拟合的常见方法

7.1 数据增强

定义：增加训练数据的多样性来提高模型的泛化能力

方法：对图像数据进行 翻转，旋转，缩放；

对 文本数据进行 同义词替换，句子重组；

7.2 正则化

通过在损失函数中 添加惩罚项来限制模型的复杂度

其实深度学习中，批归一化更常用些，其对每个批次的数据进行归一化处理，使得输入数据的分布更加稳定，加快训练速度，提高模型性能。

计算均值和方差：对每个批次的数据计算均值和方差。

归一化：将数据归一化到标准正态分布。

缩放和平移：通过可学习的参数对归一化后的数据进行缩放和平移，以恢复数据的表达能力。

L1正则化：又名 Lasso 正则化，在 损失函数中 添加权重的绝对值之和，作为惩罚项，使得模型中 一些权重变为0，从而减少模型的复杂度。实现特征选择，提高泛化能力。

L2正则化：Ridge 正则化，在损失函数中 添加权重的平方和作为惩罚项， 也是让模型的权重更小，和L1一样的，只不过这里是平方。

Dropout：在训练过程中，每次训练都随机丢弃一部分神经元，防止模型过于依赖某些特点神经元。（通常是隐藏层）

丢弃率（Dropout Rate）：通常用 p 表示，表示被丢弃的神经元的比例。常见的值为 0.2 到 0.5。
模型平均：Dropout 可以看作是一种模型平均技术，每次训练时相当于训练了一个不同的模型，最终的模型是这些模型的平均。

7.3 早停

7.4 模型选择

7.5 集成学习

8. 提升精度的一些方法

8.1 欠拟合问题 —— 引入非凸概念

非凸函数

函数图像上存在两点，连接这两点的线段的至少有一点位于函数图像的上方。
就是凸函数的反定义，两点连线，所有点都在函数图像下方。

非凸集合

如果集合 S 不是凸集合，那么它就是非凸集合。凸集合的定义是对于集合 S 中的任意两点 ，连接这两点的线段上的所有点都属于集合 S

因为 在对参数进行更新时，是第 L层的 Wl新 = WL旧 - a 残差(L+1)

所以 凸函数，带 负号，那么就可以找到 极值点

而 如果 残差（损失函数） 不是凸函数，则极有可能 落在 局部最优点，产生 欠拟合现象。

所以我们可以根据非凸函数 构造 凸代理函数—— 神经网络的凸优化问题

神经网络的参数通常是高维的(如百万甚至十亿级参数)。
在极高维空间中，严格的局部最优点(周围所有方向损失均更高)非常罕见，更多是鞍点(某些方向梯度上升，某些方向梯度下降)。
–所谓的最优点其实就是梯度接近于0的地区，梯度几乎不更新了，那么实际上避免这个问题的策略主要体现在:—逃离鞍点----优化器 步长

Dropout：训练时的随机丢弃神经元，相当于探索不同参数路径----也可以解决过拟合归一化(BatchNorm):稳定激活值分布，减少对参数初始化的依赖。

消融和对比实验

消融实验 ： 是指在模型中逐步移除某些组件或特征，观察模型性能的变化，从而评估这些组件或特征对模型性能的贡献。

对比实验 ： 是指在相同的实验条件下，比较不同模型或不同配置的性能，从而评估哪种方法更有效。

9. 一些合适的损失函数

二分类中，常用 二元交叉熵损失

多分类中，常用 交叉熵损失

回归问题，nn.MESLoss

softmax 分类问题的输出层一般是 softmax

softmax 软最大，所有分类的结果都给出概率

hardmax 硬最大，只给出 最大的 分类结构

10. 我们之前讲的 BP神经网络，是一种基础的神经网络，用 y = kx+b作为神经元，然后在加激活函数，每层间用 权重处理。

10. 一些其他网络的介绍

深度学习 是 深一点的神经网络（改进版）+ 自动特征提取器

10.1 卷积网络 CNN 多用于图像分类，目标检测，语义分割（识别图像中天空，道路，云彩）

CNN 通常由 以下几部分组成

1. 卷积层 （Convolutional Layer）
2. 激活函数（Activation Function）
3. 池化层（Pooling Layer）
4. 全连接层（Fully connected Layer）

1. 卷积层（Filter)：CNN的核心，通过卷积操作提取图像特征， 卷积操作使用 一个小型矩阵（卷积核）在图像上滑动，计算卷积核与输入图像的局部区域的点积，生成特征图（Feature Map）

卷积层 是 CNN的核心组件，负责从输入数据中提取特征。

卷积层，利用卷积核（Kernel）在输入图像上滑动，提取局部特征。 卷积操作可以有效的捕捉图像中空间信息， 如： 边缘，纹理，形状等

具体操作上：

假设你有一张 4x4 的图像（为了简单起见），如下所示：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
现在，我们用一个 2x2 的卷积核来扫描这张图像，卷积核如下：
a b
c d
扫描图像：从图像的左上角开始，卷积核覆盖的区域是：
将卷积核的值与覆盖的图像区域对应位置的值相乘，然后相加，得到一个特征值：

4x4 的图像会被转换成一个 3x3 的特征图（假设没有填充）。

1.1. 填充——在卷积层的常规操作，输入数据的边缘添加额外的像素，以控制特征图的大小。

例子 1：零填充——在输入图像的边缘填充零值。

反射填充——在输入图像的边缘填充输入数据的镜像值。这种方式可以更好地保留边缘信息，但实现相对复杂。

2. 激活函数 —— 用于引入非线性，因为卷积层的输出仍为线性，所以 给模型引入非线性

就是，

3. 池化层（Pooling Layer）

池化层 —— 一个压缩机，它将特征图中的信息进行压缩，减少数据量，同时保留重要特征，并且增强图像的平移不变性（对物体位置变化的不敏感性）

假设我们有一个 4x4 的特征图：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

我们使用 2x2 的池化窗口，步幅为 2。

划分区域：将特征图划分为 2x2 的小块：

1 2 | 3 4
5 6 | 7 8

9 10 | 11 12
13 14 | 15 16

计算池化值：对于每个 2x2 的小块，计算一个代表值。常见的池化方法有：

最大池化（Max Pooling）：取小块中的最大值。

平均池化（Average Pooling）：取小块中的平均值。

生成池化结果：将每个小块的代表值组成新的特征图。

经过池化操作后，4x4 的特征图会被压缩成一个 2x2 的特征图。

4. 全连接层（Fully Connected Layer）

全连接层通常位于CNN末端，负责 将前面层 提取 的特征综合起来，用于分类回归等任务。 加权求和 和 激活函数等操作，将特征图中的信息整合为更高层次的特征表示。

其实 前面的卷积层，激活函数和池化层就相当于机器学习中的 数据预处理部分，特征工程， 而现在的全连接层 才是真正的 神经网络，或者说 模型的拟合函数。

5. 输出层（Output Layer）CNN 的最后一层，负责输出最终的分类结果或回归值。在分类任务中，输出层通常使用 Softmax 函数将全连接层的输出转换为概率分布，表示输入数据属于各个类别的概率。

6. 然后 还是 损失函数，优化器，对模型进行训练， 可考虑用 Dropout，L1/L2 正则化等 防止模型过拟合。

7. 最后评估指标（如：均方误差，平均绝对误差等）评估模型。

10.1 简单CNN——

假设我们有一个简单的 CNN，用于手写数字识别任务：

1. 输入层：28x28 的灰度图像。

2. 卷积层：使用 3x3 的卷积核，生成 16 个 26x26 的特征图。

3. 激活函数：对卷积层的输出应用 ReLU 激活函数。

4. 池化层：对特征图进行 2x2 的最大池化，生成 16 个 13x13 的特征图。

5. 全连接层：将池化后的特征图展平为一维向量，输入到全连接层，生成 128 个神经元的输出。

6. 输出层：将全连接层的输出通过 Softmax 函数，生成 10 个类别的概率分布。

在这个例子中，卷积层、激活函数和池化层负责提取和预处理图像特征，全连接层负责最终的分类任务。

卷积层、激活函数和池化层：可以看作是对输入图像的一种特征提取和预处理，为后续的全连接层提供更有意义的特征表示。

CNN 的改进（全是预处理和特征工程）

1. 更深的网络结构，通过增加网络的层数，使模型能够学习到更复杂的特征。如：ResNet，DenseNet

ResNet：引入了残差连接（Skip Connection），解决了深层网络训练中的梯度消失问题，使网络可以更深。

DenseNet：每一层都与前面的所有层相连，增强了特征的传递和利用，进一步提高了模型的性能。

2. 更有效的卷积方式，如 深度可分离卷积（Depthwise Separable Convolution）用于 MobileNet 等 轻量级网络

标准卷积： 同时对空间和通道进行卷积，计算量较大。

所谓的通道，就是 池化层输出的特征图的数量。

深度可分离卷积：将标准卷积分解为两个步骤：

深度卷积（Depthwise Convolution）：对每个输入通道单独进行卷积，计算量较小。

逐点卷积（Pointwise Convolution）：对深度卷积的输出进行 1x1 卷积，合并通道信息。

大大减少了计算量和参数数量，使模型更轻量化，适合移动设备等资源受限的场景。

3. 注意力机制 在 CNN 中应用：如 SENet，CBAM，使网络能够更加关注重要的特征区域。

SENet：通过引入 squeeze 和 excitation 操作，对通道进行加权，使模型能够关注重要的通道特征。

CBAM：结合了通道注意力和空间注意力，分别对通道和空间位置进行加权，进一步增强模型的特征选择能力。

RNN （循环神经网络——Recurrent Neural Network） 处理序列数据的神经网络。

RNN（Recurrent Neural Network）

循环神经网络，一种专门用于处理序列数据的神经网络，能够捕捉序列中的 时间依赖关系。

RNN 基本结构也是 输入，隐藏，输出层

与传统的前馈神经网络不同，RNN隐藏层之间有循环连接，这使其能够处理序列数据

隐藏状态，RNN会维护一个隐藏状态—存储序列的历史信息， 处理新输入时，同时参考当前输入和隐藏状态进行更新。

其 可以捕捉 序列中的时间依赖关系，句子中词语的顺序关系，时间序列数据的前后关联性等。

RNN 存在的问题：梯度消失，梯度爆炸，难以捕捉长距离依赖 等

经典 CNN 架构

前馈架构（Feedforward）

层次化结构：多个卷积层，激活函数层，池化层，全连接层堆叠组成，层次化提取特征结构

空间层次结构：卷积+池化，CNN逐步减小特征图的空间尺寸，提取 越来越抽象和全局的特征，形成一种空间上的层次结构

局部连接和权值共享：卷积层的核心特点，网络可以高效的提取局部特征，减少参数数量。