从0开始机器学习--6.1神经网络概念+基础（深度学习框架介绍，什么是梯度？超参数？Epoch？批Batch？激励、损失函数？优化器？，含华为2024“智联杯”实战）-CSDN博客

本文链接：https://blog.csdn.net/m0_73752612/article/details/142720013

写在前面

在之前的内容尤其是第四篇《机器学习模型》中，我们已经了解了八大基础的机器学习模型，并且通过这些相对基础的模型对机器学习和其任务有了一个较为直观的感受。随着技术的不断发展，神经网络模型也开始越来越活跃在大众的视线中。为了对具体的神经网络模型的原理、代码等有更好的理解，这篇博客主要分享关于神经网络的基础知识。由于我个人的实践经历，本文包括后续会主要以pytorch框架为基础展开。

1.python基础；
2.ai模型概念+基础；
3.数据预处理；
4.机器学习模型--1.聚类；2.降维；3.回归（预测）；4.分类；
5.正则化技术；
6.神经网络模型--1.概念+基础；2.几种常见的神经网络模型；
7.对回归、分类模型的评价方式；
8.简单强化学习概念；
9.几种常见的启发式算法及应用场景；
10.机器学习延申应用-数据分析相关内容--1.A/B Test；2.辛普森悖论；3.蒙特卡洛模拟；
以及其他的与人工智能相关的学习经历，如数据挖掘、计算机视觉-OCR光学字符识别等。

本文目录

写在前面

三种最常见的框架和对比（pytorch、tenserflow、keras）

梯度爆炸（Gradient Explosion）

梯度消失（Gradient Vanishing）

梯度爆炸和梯度消失的直观对比

前馈网络（Feedforward Neural Network，FNN）

网络结构

前向传播（Feedforward Propagation）

反向传播（Backpropagation）

面经：为什么使用 PyTorch 的 torch.Tensor 而不是 NumPy？

pytorch框架中的超参数

学习率（Learning Rate）

概念

学习率调度（Learning Rate Schedule）

Epoch

概念

训练中的 Epoch 作用

Epoch 与 Iteration 的区别

Epoch 数的选择

如何判断 epoch 数是否合适？

批（Batch）批大小（Batch_size）

epoch、batch、step和数据量的意义和关系

Dropout概率p

Dropout工作原理

作用

激励函数（Activation Function）

迁移学习（Transfer Learning）

总结

三种最常见的框架和对比（pytorch、tenserflow、keras）

三种最常见的深度学习框架——PyTorch、TensorFlow 和 Keras，在应用场景、易用性、性能等多个方面各具特点。下面我会从开源公司背景、使用难易程度、性能与灵活性、开发生态、著名使用场景及案例、适用的研究与生产环境、社区支持等角度做更详细的对比分析。

并且会给出对于同一任务--使用随机生成的样本数据进行线性回归预测--三种框架的实现代码。让大家先有一个直观的对区别的感受。至于代码具体是什么意思，在后面的内容中我会详细介绍。

1. PyTorch

开源公司

Meta（原Facebook）在2016年发布了PyTorch，旨在为研究和生产提供灵活、高效的深度学习工具。如今，PyTorch已经成为学术界的首选框架之一，甚至在工业界也得到了广泛应用。

使用难易程度

动态计算图：PyTorch采用动态计算图（Define-by-Run）模式，意味着网络结构可以在每次前向传播（见下）时动态生成。与TensorFlow最初的静态图模式相比，PyTorch的调试和修改更加方便直观，特别适合快速原型开发和实验研究。
易于学习：由于其面向对象的设计、直观的API以及与Python的紧密集成，PyTorch非常适合初学者和研究者使用。

性能与灵活性

PyTorch在研究和实验性场景中表现尤为突出。它提供了极大的灵活性，使得用户可以轻松定义复杂的神经网络结构，并在运行时调整。PyTorch的原生CUDA支持也使得GPU加速训练变得非常便捷。
虽然在早期，PyTorch在大规模部署和分布式训练方面略显不足，但近年来它在生产环境中也得到了越来越多的应用，尤其是在与Caffe2的合并后，支持分布式部署。

开发生态

PyTorch的生态系统不断扩展，包括torchvision、torchaudio、torchtext等多个扩展库，适合处理计算机视觉、自然语言处理和语音识别等任务。
在2018年推出的PyTorch 1.0版本中，加入了TorchScript功能，使得模型在研究与生产之间更容易转换。

著名使用场景及案例

Facebook AI Research（FAIR）：很多Facebook内部的AI研究项目都使用了PyTorch，包括大规模的自然语言处理、图像处理等任务。举例来说，Facebook的图像识别模型，以及用于自动翻译的AI工具，都采用了PyTorch。
Hugging Face Transformers：这一广受欢迎的自然语言处理（NLP）库以PyTorch为基础。它提供了大量的预训练语言模型，如BERT、GPT等，广泛应用于文本生成、翻译、问答等任务。

适用场景

学术研究：由于PyTorch的灵活性和直观性，它已成为学术研究中的首选框架，尤其适合需要反复调整模型结构和进行实验的研究者。
快速原型开发：PyTorch的动态计算图使其非常适合快速迭代和开发实验性项目。

社区支持

PyTorch拥有一个非常活跃的社区，得到了大量的贡献者支持，学术界的很多顶尖论文也是基于PyTorch实现的。

pytorch实现线性回归任务代码

import torch
import torch.nn as nn
import torch.optim as optim

# 生成随机数据：y = 2x + 3
x_train = torch.randn(100, 1)
y_train = 2 * x_train + 3 + torch.randn(100, 1) * 0.1  # 添加一些噪声

# 定义简单的线性模型（pytorch框架）
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
        
    def forward(self, x):
        return self.linear(x)

# 初始化模型、损失函数、优化器
model = LinearRegressionModel()
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(100):
    model.train()
    optimizer.zero_grad()  # 梯度清零
    outputs = model(x_train)
    loss = criterion(outputs, y_train)  # 计算损失
    loss.backward()  # 反向传播
    optimizer.step()  # 更新权重

    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')

# 查看训练后的模型参数
print(f'Learned parameters: {model.linear.weight.item():.4f}, {model.linear.bias.item():.4f}')

2. TensorFlow

开源公司

Google于2015年发布的TensorFlow，是目前最成熟的深度学习框架之一。它不仅仅支持深度学习，还能用于各种机器学习任务，Google内部和很多外部的AI系统都依赖TensorFlow。

使用难易程度

静态计算图：TensorFlow最初使用静态计算图（Define-and-Run），用户需要先定义图结构，再执行训练。这种模式对初学者来说学习曲线较陡，代码调试也相对复杂。不过，Eager Execution的引入改善了这种局面，使得TensorFlow支持动态计算图，接近PyTorch的风格。
TensorFlow的API复杂度相对较高，需要深入理解其图计算和分布式计算模型才能发挥其全部潜力。

性能与灵活性

TensorFlow在分布式计算、大规模训练和跨平台部署上非常出色，支持从CPU、GPU到TPU（Tensor Processing Unit）的加速。尤其在Google的数据中心，TensorFlow搭配TPU能显著提升模型训练速度。
XLA编译器：TensorFlow支持通过XLA（Accelerated Linear Algebra）编译器优化模型计算，提升训练性能和模型部署效率。

开发生态

TensorFlow有一个非常庞大的生态系统，包含多个扩展库和工具，如TensorFlow Extended（TFX）用于生产级ML管道，TensorFlow Lite用于移动设备，TensorFlow.js用于Web端深度学习等。
TensorFlow的支持范围不仅限于深度学习，还能广泛应用于强化学习、图网络和传统机器学习算法。

著名使用场景及案例

Google Brain：几乎所有的Google AI项目都基于TensorFlow，包括Google Translate、YouTube推荐算法和Google Assistant的语音识别。
DeepMind：DeepMind的AlphaGo项目使用了TensorFlow进行训练，创造了AI历史上的一个里程碑。

适用场景

大规模生产部署：TensorFlow因其对分布式计算的强大支持，广泛应用于工业级AI项目，尤其适合在企业环境中部署深度学习模型。
跨平台模型部署：从服务器端到移动设备、Web端，TensorFlow有完整的工具链支持，适合需要将模型部署到不同设备的项目。

社区支持

TensorFlow拥有庞大的开发者和用户社区，定期推出新功能和优化，也有大量的官方文档和教程支持。

tensorflow实现线性回归任务代码

import tensorflow as tf

# 生成随机数据：y = 2x + 3
x_train = tf.random.normal((100, 1))
y_train = 2 * x_train + 3 + tf.random.normal((100, 1)) * 0.1

# 定义简单的线性模型（tensorflow实现）
model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])
model.compile(optimizer='sgd', loss='mse')

# 训练模型
model.fit(x_train, y_train, epochs=100, verbose=0)

# 查看训练后的模型参数
weights, biases = model.layers[0].get_weights()
print(f'Learned parameters: {weights[0][0]:.4f}, {biases[0]:.4f}')

3. Keras

开源公司

François Chollet于2015年发布了Keras，最初是作为一个独立的高阶API，能够在多个后端（如TensorFlow、Theano、CNTK）上运行。2017年，它与TensorFlow深度集成，成为TensorFlow的官方高层API。

使用难易程度

Keras的设计目标是简单易用。它的API高度封装，使用者只需编写少量代码就能快速搭建和训练神经网络。这使得Keras成为初学者和快速原型开发的首选。
虽然其高层次封装提供了极大的便捷，但这也意味着灵活性较低，在需要精细控制模型时，Keras可能不够合适。

性能与灵活性

Keras虽然极大简化了深度学习开发的流程，但牺牲了一定的灵活性和性能。特别是在处理自定义层和操作时，Keras的抽象程度可能限制开发者的操作空间。
当需要微调模型或者定义较复杂的神经网络结构时，使用底层的TensorFlow或PyTorch可能更合适。

开发生态

Keras现在是TensorFlow生态的一部分，所有的TensorFlow功能都可以通过Keras的高层API访问。
通过与TensorFlow的深度集成，Keras同样支持分布式训练、模型压缩、迁移学习等高级功能。

著名使用场景及案例

初学者教程与教学：Keras因其简洁的API，常用于机器学习和深度学习的教学中。很多大学课程和在线学习平台都会以Keras作为初学者的入门框架。
快速原型开发：Keras是构建和测试小型深度学习模型的利器。在研究和生产环境中，Keras常用于快速验证模型的可行性。

适用场景

新手入门：Keras因其简单易懂的API，非常适合作为深度学习入门工具。
快速原型开发：对于需要快速迭代和测试想法的场景，Keras能够极大提高开发效率。

社区支持

Keras有着庞大的社区支持，由于其与TensorFlow的紧密结合，Keras用户可以借助TensorFlow社区的丰富资源。

keras实现线性回归任务代码

Keras作为TensorFlow的高级API实现方式会非常类似：

from keras.models import Sequential
from keras.layers import Dense
import numpy as np

# 生成随机数据：y = 2x + 3
x_train = np.random.randn(100, 1)
y_train = 2 * x_train + 3 + np.random.randn(100, 1) * 0.1

# 定义简单的线性模型
model = Sequential()
model.add(Dense(1, input_dim=1))
model.compile(optimizer='sgd', loss='mse')

# 训练模型
model.fit(x_train, y_train, epochs=100, verbose=0)

# 查看训练后的模型参数
weights, biases = model.layers[0].get_weights()
print(f'Learned parameters: {weights[0][0]:.4f}, {biases[0]:.4f}')

pytorch框架基础概念

梯度

图片来自网络zhuanlan.zhihu.com/p/396113407?utm_id=0

什么是梯度

梯度是一个向量，表示函数在某一点处的偏导数（高数）。梯度告诉我们，在多维空间中，如何改变输入参数以最快地减少或增加输出值。换句话说，梯度指示了一个函数沿着输入空间的最大变化方向。

在神经网络中，梯度是损失函数（模型输出与实际值之间的误差）关于网络参数（如权重和偏置）的导数。通过计算梯度，神经网络能够调整这些参数，使得损失函数的值逐步减小，这就是所谓的梯度下降（Gradient Descent）优化过程。

梯度在神经网络中的作用

在神经网络中，训练的目标是找到一组最优的权重参数，使得模型预测的误差最小化。梯度在这个过程中起着至关重要的作用，它引导权重更新的方向。

前向传播：输入通过神经网络层逐层传递，直到输出。（见下）
计算损失：损失函数计算输出与真实标签之间的误差。
反向传播：通过梯度计算损失函数相对于每个参数的偏导数，然后利用这些梯度更新权重。

这整个过程依赖于梯度下降算法（运筹学），使用梯度来更新网络的参数，通常按以下方式进行：

梯度爆炸（Gradient Explosion）

梯度爆炸是指在训练深层神经网络时，梯度值在反向传播（见下）过程中指数级地增加，导致权重更新变得过大。最终，模型的参数可能会变得极其不稳定，训练过程无法正常进行。通常发生在网络层数较多时，特别是在递归神经网络（RNN）中更为常见。

产生原因

在深层网络中，梯度会通过链式法则逐层传递。如果某些权重或激活函数导致梯度的值大于 1，在反向传播中，梯度经过多层传播时会被逐渐放大，导致梯度爆炸。

后果

权重更新过大，模型无法收敛。
损失函数（见下）的值会突然变得非常大，无法有效下降。

解决方法

梯度裁剪（Gradient Clipping）：将梯度值限制在某个合理范围内，防止它们爆炸性增大。
使用正则化技术或适当的网络初始化策略。（在《5.正则化》中有具体介绍）
使用合适的权重初始化策略，避免初始梯度过大。

梯度消失（Gradient Vanishing）

梯度消失是指在反向传播过程中，梯度值变得非常小，导致权重更新过慢甚至无法更新，网络难以学习到有效的参数。这种情况多见于激活函数是 sigmoid 或 tanh（见下）的深层神经网络。

产生原因

在深层网络中，如果激活函数的导数小于 1，反向传播时梯度会随着网络深度逐层缩小，导致较早的层几乎无法获得有效的梯度更新。尤其对于 sigmoid 和 tanh 激活函数，当输入值远离 0 时，其导数会变得非常小，导致梯度消失。

后果

网络无法有效训练，特别是靠近输入层的权重几乎没有更新。
训练时间变长，模型无法收敛到好的结果。

解决方法

使用ReLU激活函数，ReLU 的梯度在正数范围内不会减小。
使用改进的优化算法，如 Adam、RMSProp。
权重初始化技巧，如 Xavier 初始化或 He 初始化。
使用归一化技术，如批归一化（Batch Normalization）（见下），可以使梯度更加稳定。

梯度爆炸和梯度消失的直观对比

梯度爆炸：梯度值过大，导致权重更新过快，损失值不稳定，可能无法收敛。
梯度消失：梯度值过小，导致权重更新过慢，训练过程几乎停滞，无法有效学习。

前馈网络（Feedforward Neural Network，FNN）

前馈网络是最简单、最常见的神经网络类型之一。它是一个有向无环网络，数据和信号在网络中只从输入层单向传播到输出层，不会有反馈循环，也不会有数据回流到前面层。

网络结构

前馈网络主要由以下几部分组成：

输入层（Input Layer）：接收外部输入数据。
隐藏层（Hidden Layers）：介于输入层和输出层之间的层，用于提取和学习数据的特征。隐藏层可以有一层或多层。每个隐藏层中的节点与前一层的所有节点相连，经过权重和偏置调整，进行非线性变换。
输出层（Output Layer）：最终产生预测结果或输出信号。

各层中的节点（或称为神经元）通过权重相连，输入数据经过一层层的计算、激活函数处理，最终输出结果。

前向传播（Feedforward Propagation）

在前馈网络中，数据从输入层进入，经过隐藏层，最终到达输出层。这一过程称为前向传播：

输入数据：将数据输入到输入层。
加权求和：隐藏层中的每个节点对前一层的输入值乘以对应的权重，并加上偏置项，进行加权求和。
激活函数：通过激活函数（如ReLU、Sigmoid）进行非线性变换，以增强模型表达复杂特征的能力。
输出结果：在输出层，经过处理后的数据变为最终的预测结果。

output = activation_function(weighted_sum(input))

反向传播（Backpropagation）

反向传播是神经网络的核心训练算法之一，用来计算每个参数的梯度，并通过梯度下降算法调整网络的权重和偏置，从而最小化损失函数，提升模型的准确性。

反向传播基本步骤：

前向传播：输入数据通过网络层逐步传递，最终得到输出结果。在这个过程中，网络会记录各层的输出值。
计算损失：根据网络的输出结果和真实标签（ground truth），通过损失函数（如均方误差、交叉熵等）计算网络的误差（loss）。
反向传播误差：从输出层开始，误差逐层向后传播，根据链式法则计算每一层的参数（权重和偏置）的梯度。
参数更新：通过梯度下降或其他优化算法，利用计算得到的梯度更新网络参数，减小误差。

反向传播核心原理：

反向传播基于链式法则（Chain Rule）。每一层的梯度是通过上一层梯度乘以当前层的局部梯度得出的，误差从输出层逐层向输入层传播。

# 反向传播
loss.backward()  # 计算梯度
optimizer.step()  # 更新参数

前馈网络的特点

无反馈：前馈网络的节点连接没有回路，数据不会回流到前面层。
全连接：每个节点与前一层的所有节点相连（常见的是全连接层，也叫密集层）。
易于理解和实现：它是神经网络的基础构造，计算简单，适合用于各种任务，比如回归、分类等。

反馈

hidden_state = rnn_layer(input, hidden_state)

前向传播、反向传播和反馈的区别

前馈网络的应用

前馈神经网络主要用于处理结构化数据或简单问题，但它在面对复杂的序列问题（如时间序列分析、语言模型）时表现不足，因为它无法建模数据间的时间依赖关系。在这种情况下，更复杂的网络结构（如循环神经网络、卷积神经网络）更加适合。

前馈网络的训练

前馈网络的训练过程包含以下步骤：

前向传播：输入数据通过前馈网络传播，生成预测结果。
计算损失：将预测结果与真实值进行比较，计算损失函数值（如均方误差或交叉熵）。
反向传播：使用梯度下降算法和反向传播算法，更新网络中的权重和偏置。
迭代更新：通过多轮训练（epoch），逐渐调整权重和偏置，使模型的损失降低，提升预测精度。

数据类型torch.Tensor

pytorch深度学习框架只接受tensor形式的数据（特点和原因见下）。torch.Tensor 是 PyTorch 中的核心数据类型，类似于 NumPy 的 ndarray，但增加了许多深度学习所需的功能，比如 自动微分 和 GPU 加速。

torch.Tensor 的特点

1. 多维数组：torch.Tensor 是一个多维数组，可以表示标量、向量、矩阵或更高维的张量。如：

0 维：标量 (如 3)
1 维：向量 (如 [1, 2, 3])
2 维：矩阵 (如 [[1, 2], [3, 4]])
3 维及以上：高维张量

import torch
scalar = torch.tensor(3)  # 0维标量
vector = torch.tensor([1, 2, 3])  # 1维向量
matrix = torch.tensor([[1, 2], [3, 4]])  # 2维矩阵

2. 支持自动微分：通过 requires_grad=True，torch.Tensor 可以在计算中追踪每个操作，以便在反向传播时自动计算梯度。这对深度学习中的权重更新非常关键。其实之前还有Variable变量，但从PyTorch0.4版本开始，Variable已被弃用，因为Tensor本身就可直接使用自动微分功能。现在所有张量默认都是可以追踪梯度的。只需设置 x=torch.tensor([1.0, 2.0, 3.0], requires_grad=True)。

x = torch.tensor(2.0, requires_grad=True)
y = x**2 + 3
y.backward()  # 计算y相对于x的梯度
print(x.grad)  # 输出：4.0

3. GPU 加速：torch.Tensor 可以轻松地在 CPU 和 GPU 之间切换。你可以通过 .to(device) 方法将张量放在 GPU 上，从而加速大规模计算。

tensor = torch.tensor([1, 2, 3])
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
tensor = tensor.to(device)  # 转移到GPU

4. 与 NumPy 的互操作性：torch.Tensor 和 NumPy 的 ndarray 可以无缝互转。当张量位于 CPU 上时，转换不会引入额外的开销。

import numpy as np
np_array = np.array([1, 2, 3])
torch_tensor = torch.from_numpy(np_array)  # NumPy 到 Tensor

new_np_array = torch_tensor.numpy()  # Tensor 到 NumPy

5. 高效的计算操作：PyTorch 提供了大量高效的矩阵和张量操作，包括基本的数学运算、矩阵乘法、转置、求逆等。PyTorch 的大部分操作支持自动广播机制，允许不同形状的张量进行运算。这些计算方式的代码与numpy几乎一摸一样（具体可见第一篇《python基础》，有具体介绍）。

import torch
import numpy as np
np_data=np.arange(6).reshape((2,3))
torch_data=torch.from_numpy(np_data) #将numpy转化为tensor
tensor2array=torch_data.numpy()      #将tensor转化为numpy
print('np_data',np_data,'\ntorch_data',torch_data,'\ntensor2arr',tensor2array)
#abs sin mean......

data=[-1,-2,1,2]
tensor=torch.FloatTensor(data)    #将data转化为32bit浮点数的形式
print('\nabs','\nnumpy',np.abs(data),'\ntorch',torch.abs(tensor))

#矩阵运算
data=[[1,2],[3,4]]
tensor=torch.FloatTensor(data)
print('\nnumpy',np.matmul(data,data),'\ntorch',torch.mm(tensor,tensor))
#np.matmul(data,data)==data.dot(data)  
#tensor.dot(tensor)在这个例子中为1*1+2*2+3*3+4*4=30   .mm为矩阵乘法

#创建张量
x=torch.ones(2, 3)  # 生成一个2x3的全1矩阵
y=torch.zeros(2, 3)  # 生成一个2x3的全0矩阵
z=torch.rand(2, 3)  # 生成一个2x3的随机矩阵

#张量加法
result=x+y

#张量输出
print(result)
#输出：
# tensor([[1., 1., 1.],
#         [1., 1., 1.]])

面经：为什么使用 PyTorch 的 `torch.Tensor` 而不是 NumPy？

自动微分（Autograd）：PyTorch 的 Tensor 支持自动求导，而 NumPy 的数组则没有这种功能。在深度学习中，反向传播（见上）依赖于对梯度（运筹学、高数中的基本概念，见上）的计算，而 PyTorch 的 Tensor 可以通过自动微分引擎 autograd 实现这一功能。
GPU 加速：torch.Tensor 可以很方便地在 GPU 上进行计算，从而显著加快深度学习任务，而 NumPy 仅限于 CPU 计算。

pytorch框架中的超参数

学习率（Learning Rate）

概念

学习率是神经网络训练过程中的一个超参数，用来控制模型在每一步优化中，更新参数的步幅大小（见下）。学习率太大可能导致模型在最小化损失时跳过最优点（无法收敛），而学习率太小则会使训练过程缓慢，甚至陷入局部最优解。

步长（Step Size）就是在每次梯度更新时，沿着梯度方向前进的距离，即学习率在每次更新时控制权重变化的幅度。步长越大，模型参数在每次迭代中变化的幅度越大。

学习率调度（Learning Rate Schedule）

指在训练过程中动态调整学习率的方法。常见的调度策略包括：

Step Decay：在设定的epoch数后，将学习率减少固定比例。
Exponential Decay：学习率按指数衰减。通常公式为：lr = initial_lr * exp(-k * epoch)，其中 k 是衰减速率。
Cyclical Learning Rate：在训练期间周期性地调整学习率。有库函数可用。

import torch
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np
from torch.optim.lr_scheduler import CyclicLR

# 学习率调度器：Step Decay 和 Exponential Decay 通用的函数
def step_decay_schedule(initial_lr, drop, epochs_drop, epoch):
    return initial_lr * (drop ** (epoch // epochs_drop))

def exp_decay_schedule(initial_lr, k, epoch):
    return initial_lr * np.exp(-k * epoch)

# 初始化参数
initial_lr = 0.1
drop = 0.5  # Step Decay的衰减比例
epochs_drop = 10  # Step Decay每10个epoch减少一次
epochs = 50
k = 0.05  # Exponential Decay的衰减速率

# 创建子图
fig, axs = plt.subplots(1, 3, figsize=(18, 5))

# 1. Step Decay Learning Rate
lr_values = [step_decay_schedule(initial_lr, drop, epochs_drop, epoch) for epoch in range(epochs)]
axs[0].plot(lr_values)
axs[0].set_title("Step Decay Learning Rate")
axs[0].set_xlabel("Epoch")
axs[0].set_ylabel("Learning Rate")
axs[0].grid(True)

# 2. Exponential Decay Learning Rate
lr_values = [exp_decay_schedule(initial_lr, k, epoch) for epoch in range(epochs)]
axs[1].plot(lr_values)
axs[1].set_title("Exponential Decay Learning Rate")
axs[1].set_xlabel("Epoch")
axs[1].set_ylabel("Learning Rate")
axs[1].grid(True)

# 3. Cyclical Learning Rate (CLR)
model = torch.nn.Linear(1, 1)  # 一个简单模型
optimizer = optim.SGD(model.parameters(), lr=initial_lr)
scheduler = CyclicLR(optimizer, base_lr=0.01, max_lr=0.1, step_size_up=5, mode='triangular')

lr_values = []
for epoch in range(epochs):
    optimizer.step()  # 模拟训练步骤
    lr_values.append(optimizer.param_groups[0]['lr'])
    scheduler.step()

axs[2].plot(lr_values)
axs[2].set_title("Cyclical Learning Rate")
axs[2].set_xlabel("Epoch")
axs[2].set_ylabel("Learning Rate")
axs[2].grid(True)

# 调整子图布局
plt.tight_layout()
plt.show()

Epoch

概念

表示整个训练数据集完整地通过神经网络一次的过程。使用 PyTorch 时，在代码中 epoch 通常在训练循环中作为for循环（在《1.python基础》中有具体介绍）的次数出现。

完整遍历一次数据集：一轮 epoch 就意味着神经网络将所有的训练样本（数据集）都输入一次，经过一次前向传播和反向传播。
多次epoch：通常训练过程中需要多次遍历数据集，因此模型会进行多轮 epoch 的训练。每一轮 epoch 都会根据上一次的梯度和损失进行权重的更新，帮助模型逐渐逼近最优解。

训练中的 Epoch 作用

模型优化：在每个 epoch 中，模型通过反向传播（见上）更新参数，从而逐渐学习如何更好地拟合数据。
损失的减少：随着 epoch 的增加，模型的损失函数通常会逐渐下降，表明模型越来越接近最佳解。

Epoch 与 Iteration 的区别

Iteration（迭代）：指一次前向传播和反向传播的过程，通常每一批（batch）（见下）数据完成一次前向传播和反向传播就算作一次迭代。

因此，一个 epoch = 数据集大小 / 批大小 的迭代次数。例如，如果数据集有 1000 个样本，批大小为 100，那么每一轮 epoch 会有 10 次迭代。

Epoch 数的选择

过小的 epoch 数：如果 epoch 数太少，模型可能没有足够的时间去学习和调整参数，这样训练过程就会中断，导致模型未能学到良好的特征（即欠拟合）。
过大的 epoch 数：如果 epoch 数过多，模型可能会过度拟合训练集，表现为训练集上的性能很好，但在测试集上表现较差（即过拟合（在《4.4分类--决策树》中有具体介绍））。

理想的情况是选择合适的 epoch 数，让模型在训练集和测试集上都表现良好。

如何判断 epoch 数是否合适？

观察损失曲线：通常训练过程中我们会绘制损失函数随 epoch 变化的曲线，观察其变化趋势。理想情况下，损失曲线应该随着 epoch 增加而逐渐下降，达到一个平稳点后停止下降。这时说明模型已经充分训练（即判断是否是过拟合的方式）。
使用早停（Early Stopping）：为避免过拟合，通常可以设置早停机制，即在验证集上的性能不再提高时，提前停止训练。

批（Batch）批大小（Batch_size）

批指的是在每次迭代中用于训练模型的样本子集。整个数据集通常很大，不能一次性送入模型训练，因此我们将其分成多个批次。

批数据训练是指每次只使用一个批次的数据进行训练，而不是整个数据集。批数据训练能够加快模型收敛速度，减少计算资源消耗。

批归一化（Batch Normalization）是指对每一批数据进行标准化，使得每层输出具有相似的分布，从而加速训练并减少梯度消失问题。

以下这段代码可以直观的感受到批的作用。

import torch
import torch.utils.data as Data
BATCH_SIZE=4
x=torch.linspace(1,10,10)
y=torch.linspace(10,1,10)
torch_dataset=Data.TensorDataset(x,y) #数据集，使用datatensor训练，target算误差
loader=Data.DataLoader(               #使用dataloader来进行批训练
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True   #是否需要再训练时随机打乱训练集
)
for epoch in range(3): #整体训练三次
    for step,(batch_x,batch_y) in enumerate(loader): #step是enumerate自带的计数功能的变量，（x,y）来自dataloader
        # training......
        print('Epoch:',epoch,'|Step',step,'|Batch_x',batch_x.numpy(),'|Batch_y',batch_y.numpy())
print()

Epoch: 0 |Step 0 |Batch_x [ 4.  5.  1. 10.] |Batch_y [ 7.  6. 10.  1.]
Epoch: 0 |Step 1 |Batch_x [9. 7. 8. 2.] |Batch_y [2. 4. 3. 9.]
Epoch: 0 |Step 2 |Batch_x [3. 6.] |Batch_y [8. 5.]
Epoch: 1 |Step 0 |Batch_x [ 5.  4. 10.  2.] |Batch_y [6. 7. 1. 9.]
Epoch: 1 |Step 1 |Batch_x [3. 7. 9. 8.] |Batch_y [8. 4. 2. 3.]
Epoch: 1 |Step 2 |Batch_x [1. 6.] |Batch_y [10.  5.]
Epoch: 2 |Step 0 |Batch_x [6. 8. 9. 3.] |Batch_y [5. 3. 2. 8.]
Epoch: 2 |Step 1 |Batch_x [7. 1. 5. 2.] |Batch_y [ 4. 10.  6.  9.]
Epoch: 2 |Step 2 |Batch_x [ 4. 10.] |Batch_y [7. 1.]

epoch、batch、step和数据量的意义和关系

Epoch：整个数据集经过网络一次训练。
Batch：每次训练时处理的部分样本。
Step：每个 batch 完成一次权重更新。
数据量：决定了每个 epoch 包含的 batch 和 step 数量。

Dropout概率p

Dropout 是一种用于防止神经网络过拟合的正则化技术，它通过在训练过程中随机地丢弃一部分神经元，使得网络更具鲁棒性。Dropout 通过强制网络不依赖于某些特定的神经元或路径来达到更好的泛化性能。

Dropout工作原理

在每一次训练时，Dropout 会以一个预设的概率 p （通常为 0.5）随机地将神经网络中的一些神经元“关掉”或者忽略掉。这些被忽略的神经元的输出不会传递给下一层，也不会参与反向传播更新。

具体过程

训练阶段：
- Dropout 在每一次前向传播时，会随机选择一部分神经元，以概率 p 保留，其他神经元以概率1−p 被丢弃（即其输出被设置为 0）。
- 这种随机的丢弃使得网络在训练中不会依赖于某个特定的神经元，因为该神经元有可能在下一次更新时会被丢弃。
测试阶段：
- 在测试时，Dropout 不再随机丢弃神经元，而是使用全部神经元，并且将每个神经元的输出乘以保留概率 p，以保证输出的期望值与训练时一致。

作用

防止过拟合：Dropout 通过在每次迭代中训练不同的“子网络”（由随机选择的神经元组成）来减轻神经网络的过拟合问题。这相当于训练了多个不同的网络，并且在测试时结合这些网络的效果来进行预测。
增加网络的鲁棒性：由于每次都使用不同的神经元组合，网络不能过度依赖某些特定的神经元路径，从而提升了模型对新数据的泛化能力。

Dropout 的优点

减少过拟合：Dropout 通过随机丢弃部分神经元，使得网络不会依赖于某个特定神经元的输出，从而增加了网络的泛化能力。
简单且有效：相较于其他正则化技术，Dropout 实现简单且有效，并且能够显著提升深层网络的性能。

Dropout 的缺点

训练时间变长：由于每次训练时的网络都是不同的“子网络”，因此模型收敛所需的 epoch 可能会变多。
小型网络效果较差：对于小型网络，Dropout 有时会导致丢弃过多的神经元，影响模型的表现。

超参数

Dropout 概率 p：决定了在每次训练时保留神经元的概率。常见的值为 0.5（即丢弃一半的神经元），但是在输入层一般会选择更大的保留率，例如 0.8。

实际应用场景

Dropout 被广泛应用于图像分类、自然语言处理等任务中。比如在中国的图像识别任务中，使用 Dropout 可以有效防止模型对特定背景或颜色的过度依赖。例如，训练一个用于识别不同城市街景的模型时，Dropout 可以防止模型仅仅依赖某些街道特征（如路牌颜色）进行识别，而是学习更具普适性的道路结构特征。还有一个著名应用场景是 AlexNet 。

激励函数（Activation Function）

激活函数赋予神经网络非线性能力，常见的有ReLU、Sigmoid、Tanh等。激励函数（AF）必须可微分，因为只有可微分，才能在反向传播时将误差传递回去。

默认首选，cnn（卷积神经网络）的卷积层中推荐relu，rnn（循环神经网络）推荐relu or tanh。softmax不是线图的激励函数，是用来做概率图的，分类问题每一个类别的概率。

以下代码可以直观的展示这些激励函数是什么。

import torch
import torch.nn.functional as F #nn:神经网络模块
from torch.autograd import Variable
import matplotlib.pyplot as plt 
#制造一些伪数据
x=torch.linspace(-5,5,200) #x data tensor,将线段（-5，5）去200个点数据
x_np=x.data.numpy()        #因为plt作图不能直接接受tensor类型的数据

y_relu=F.relu(x).data.numpy()
y_sigmoid=F.sigmoid(x).data.numpy()
y_tanh=F.tanh(x).data.numpy()
y_softplus=F.softplus(x).data.numpy()

#四个激励函数的图
plt.figure(1,figsize=(8,6))
plt.subplot(221)       #用于创建一个 2x2 的网格子图，并激活其中的第一个子图，从左到右从上到下从1到4编号
plt.plot(x_np,y_relu,c='red',label='relu')
plt.ylim((-1,5))       #设置当前图表的 y 轴范围
plt.legend(loc='best') #将图例自动放置在最合适的位置
plt.subplot(222)
plt.plot(x_np,y_sigmoid,c='red',label='sigmoid')
plt.ylim((-0.2,1.2))
plt.legend(loc='best')
plt.subplot(223)
plt.plot(x_np,y_tanh,c='red',label='tanh')
plt.ylim((-0.2,1.2))
plt.legend(loc='best')
plt.subplot(224)
plt.plot(x_np,y_softplus,c='red',label='softplus')
plt.ylim((-0.2,6))
plt.legend(loc='best')
plt.show()

损失函数（Loss Function）

衡量模型输出与真实标签的差异，用于指导优化过程。常见的有均方误差（MSE）、交叉熵损失等。（具体内容会在《7.评估》中介绍）

优化器（Optimizer）

优化器用于根据损失函数的梯度更新模型的权重。常见的优化器有SGD、Adam、RMSprop等。

SGD:随机梯度下降，每次只用一组数据进行学习；Adam:最优梯度下降（一般情况下它最好）

以下代码可以直观的展示这些优化器是什么。

import torch
import torch.utils.data as Data
import torch.nn.functional as F
import matplotlib.pyplot as plt
#定义一些超参数 hyper parameters
LR=0.01
BATCH_SIZE=32
EPOCH=12
x=torch.unsqueeze(torch.linspace(-1,1,1000),dim=1)
y=x.pow(2)+0.1*torch.normal(torch.zeros(*x.size()))
torch_dataset=Data.TensorDataset(x,y)
loader=Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True)
class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(1,20)
        self.predict=torch.nn.Linear(20,1)
    def forward(self,x):
        x=F.relu(self.hidden(x))
        x=self.predict(x)
        return x
#建立4个不同的神经网络，用于后续四种不同优化器
net_SGD=Net()
net_Momentum=Net()
net_RMSprop=Net()
net_Adam=Net()
nets=[net_SGD, net_Momentum, net_RMSprop, net_Adam]
opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8) #动量项用于加速收敛，尤其是在处理高曲率、小但一致的梯度或嘈杂的梯度时。动量可以帮助优化器克服局部极小值，并在凹谷中更快地收敛。
opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)  #alpha 是梯度平方的指数衰减率，用于控制移动平均线的平滑程度
opt_Adam = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))   #betas 控制动量项和二阶矩估计的指数衰减率。
#以上所有参数都是默认值，可能需要根据实际情况进行修改
optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]
loss_func=torch.nn.MSELoss()
losses_his = [[], [], [], []]   # record loss
# training
for epoch in range(EPOCH):
    print('Epoch: ', epoch)
    for step, (b_x, b_y) in enumerate(loader):          # for each training step
        for net, opt, l_his in zip(nets, optimizers, losses_his):#一个个网络一种种opt优化器进行训练
            output = net(b_x)              # get output for every net
            loss = loss_func(output, b_y)  # compute loss for every net
            opt.zero_grad()                # clear gradients for next train
            loss.backward()                # backpropagation, compute gradients
            opt.step()                     # apply gradients
            l_his.append(loss.data.numpy())     # loss recoder

labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
for i, l_his in enumerate(losses_his):
    plt.plot(l_his, label=labels[i])
plt.legend(loc='best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim((0, 0.2))
plt.show()

搭建简易的pytorch框架的神经网络

在最简单的情况下，可以像搭积木一样堆叠各层，例如全连接层（Linear）、激活函数（ReLU）和Dropout 等层。PyTorch 提供了 nn.Sequential，允许你通过线性堆叠快速构建网络。

对于更复杂的任务，可能需要设计非线性结构，如残差网络（ResNet）、卷积神经网络（CNN）、递归神经网络（RNN）等。此时，线性堆叠无法满足需求，通常会通过继承 nn.Module 类来自定义网络的前向传播逻辑。

在这一篇中，我们仅对pytorch框架大致了解即可，下一篇内容才会涉及到更复杂的具体神经网络内容。因此，我把堆叠的代码放在这里，我在代码中也尽可能加入了详细的注释。神经网络也可以处理回归和分类两种任务。

还有一些主要的库函数，如DataLoader等。

回归任务

import torch
import torch.nn.functional as F #nn:神经网络模块
import matplotlib.pyplot as plt
x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1) #torch只会处理二维的数据，unsqueeze把一维变成二维
y=x.pow(2)+0.2*torch.rand(x.size())               #后面的是噪点
class Net(torch.nn.Module):#从torch.nn.Module继承模块
    def __init__(self,n_features,n_hidden,n_output):#层的信息
        super(Net,self).__init__() #官方步骤（必须）
        self.hidden=torch.nn.Linear(n_features,n_hidden)#这一层中有多少个输入，多少个输出（隐藏层的神经元的个数）
        self.predict=torch.nn.Linear(n_hidden,n_output)
    def forward(self,x):          #前向传递的过程,搭建模型，x为输入信息
        x=F.relu(self.hidden(x))  #x经过hidden层后用relu加工
        x=self.predict(x)         #预测不用激励函数因为线性的取值范围很大，若使用激励函数，结果可能被截断在一个小范围内
        return x
net=Net(1,10,1) #（n_features,n_hidden,n_output）
print(net)      #输出层结构

plt.ion() #将图片变为实时打印的过程
plt.show()
optimizer=torch.optim.SGD(net.parameters(),lr=0.5) #用优化器优化神经网络中的参数net.parameters()
loss_func=torch.nn.MSELoss()#均方差
for t in range(100):
    prediction=net(x)
    loss=loss_func(prediction,y)
    optimizer.zero_grad()  #优化步骤1：将所有参数的梯度降为0
    loss.backward()        #优化步骤2：当前次的反向传递
    optimizer.step()       #优化步骤3：以lr优化梯度
    if(t%5==0): #每拟合5次输出一次
        plt.cla()
        plt.scatter(x.data.numpy(),y.data.numpy())
        plt.plot(x.data.numpy(),prediction.data.numpy(),'r-',lw=5)
        plt.text(0.5,0,'loss=%.4f' % loss.data, fontdict={'size':20,'color':'red'})
        plt.pause(0.5)
plt.ioff()
plt.show()

输出：

Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)

分类任务

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

# 构造伪数据
n_data = torch.ones(100, 2)    #创建了一个形状为 (100, 2) 的张量，这个张量有 100 行，每行有 2 个元素，每个元素的值都是 1。
x0 = torch.normal(2*n_data, 1)      # torch.normal()生成一个符合正态分布（也称高斯分布）的张量。
#torch.normal(2*n_data, 1) 表示生成一个形状和2*n_data相同（即(100, 2)）的张量，其中每个元素都符合均值为2(因为n_data中的每个元素都是，乘2后每个元素变成2)、标准差为1的正态分布。
y0 = torch.zeros(100)               #类0，与后续“类1”做区分
x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)
y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor) #合并x0x1作为全部的数据，在第0维（行的方向）上连接  # shape (200, 2) FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)   #这个type为pytorch中标签默认的形式，一定要是64位的int #合并y0y1作为全部的标签 省略了维度参数，默认为在第0维 # shape (200,) LongTensor = 64-bit integer
plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.show()#可视化当前两类数据点
class Net(torch.nn.Module):
    def __init__(self,n_features,n_hidden,n_output):
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(n_features,n_hidden)
        self.predict=torch.nn.Linear(n_hidden,n_output)
    def forward(self,x):
        x=F.relu(self.hidden(x))#做为一个function
        x=self.predict(x)
        return x
net=Net(2,10,2) #输入和输出都是两个特征，因为分为0或1两类，默认层中有10个神经元
#对于多分类问题，输出为[0,1]代表机器认为属于第二个大类，[1,0]代表机器认为属于第一个大类，[0,1,0]代表机器认为属于第二个大类，综上，哪一栏打上了tag1,机器就将他分到了哪一类
print(net)
plt.ion()
plt.show()
optimizer=torch.optim.SGD(net.parameters(),lr=0.02)
loss_func=torch.nn.CrossEntropyLoss() #回归问题用均方差(MSE),多分类问题用交叉熵（这种损失函数计算的是softmax，即每一类别的概率(概率和为1)）
for t in range(100):
    out=net(x)
    loss=loss_func(out,y)
    optimizer.zero_grad() #优化步骤1：将所有参数的梯度降为0
    loss.backward()       #优化步骤2：当前次的反向传递
    optimizer.step()      #优化步骤3：以lr优化梯度
    if(t%5==0): #每2步输出一次
        # plot and show learning process
        plt.cla()#清空当前的绘图，这样在每次绘图时不会重叠之前的图像。
        prediction = torch.max(F.softmax(out, dim=1), 1)[1] #在第一个维度上（即列方向）使用激励函数softmax，将out转化为概率，“，1”即为找到最大值，索引为[1]即概率最大的位置。最大值的索引通常表示预测的类别，[0]就是最大值
        # 总之，这行代码的作用是从 out 张量中计算出每个样本的预测类别
        pred_y = prediction.data.numpy().squeeze() #.squeeze()：移除单维度条目（即长度为1的维度），使数据更容易处理和可视化
        # torch.squeeze()：移除大小为 1 的维度，可以选择性地在特定维度上进行。
        # torch.unsqueeze()：在指定位置插入一个大小为 1 的维度。
        target_y = y.data.numpy()
        plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
        accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
        plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.5)
plt.ioff()
plt.show()

输出：

Net(
  (hidden): Linear(in_features=2, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=2, bias=True)
)

在这两段代码中，我们也能简单的找到一些搭建简易的pytorch框架神经网络的一些规律，如在网络的class中先一层层的定义层的信息，注意该层输入输出的特征数，下一层输入的特征数通常是该层输出的特征数；再定义与层数对应数量的前向传播函数，注意每一层使用的激励函数以及最后一层的预测x=self.predict(x)；以及在训练循环中，optimizer.zero_grad() #优化步骤1：将所有参数的梯度降为0、loss.backward() #优化步骤2：当前次的反向传递、optimizer.step() #优化步骤3：以lr优化梯度，这三个优化步骤通常是必不可少的。

快速搭建法

线性堆叠，这个网络的效果和上述分类问题的net是一样的。

import torch
net=torch.nn.Sequential(   #sequential的意思就是在其中一层层的累神经层
    torch.nn.Linear(2,10),
    torch.nn.ReLU(),       #做为一个class，要大写，区别于上面的function（激励函数）
    torch.nn.Linear(10,2)
)

保存和提取

分为两种方式保存和提取，分别为保存整个网络和只保存每个点的状态（参数），保存和提取必须对应使用。使用状态保存和提取的方式时，必须先建立一样结构的网络，再使用提取的内容给它赋参数。

path1=r"./net.pth"
path2=r"./net_dict.pth"

import torch
torch.manual_seed(1) #可复现的随机
x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)#torch只会处理二维的数据，unsqueeze把一维变成二维
y=x.pow(2)+0.2*torch.rand(x.size())#后面的是噪点

def save():
    net=torch.nn.Sequential(
    torch.nn.Linear(1,10),
    torch.nn.ReLU(),
    torch.nn.Linear(10,1)
    )
    optimizer=torch.optim.SGD(net.parameters(),lr=0.5)
    loss_func=torch.nn.MSELoss()
    for t in range(100):
        prediction=net(x)
        loss=loss_func(prediction,y)
        optimizer.zero_grad() #优化步骤1：将所有参数的梯度降为0
        loss.backward()       #优化步骤2：当前次的反向传递
        optimizer.step()      #优化步骤3：以lr优化梯度
    torch.save(net,path1)             #保存整个网络
    torch.save(net.state_dict(),path2)#只保存每个点的状态（参数）

def restore_entire_net():
    net1=torch.load(path1)
    # pred1=net1(x)
def restore_dict_net(): #比上一种方式更快更轻便
    net2=torch.nn.Sequential(
    torch.nn.Linear(1,10),
    torch.nn.ReLU(),
    torch.nn.Linear(10,1)
    ) #这种方法必须先建立一样的结构，再赋参数
    net2.load_state_dict(torch.load(path2))

华为2024“智联杯”实战

任务书是这样的：

这个任务其实用上面所述的内容就可以很好的完成，我记得当时我们这部分是获得了前20名的，以下是代码：

train.py

import os
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import joblib  # 用于加载标准化参数

# 数据加载和预处理
def load_and_preprocess_data(folder_path):
    data = []
    labels = []
    for file in os.listdir(folder_path):
        if file.endswith('.bin'):
            file_path = os.path.join(folder_path, file)
            label = int(file.split('_')[2])
            with open(file_path, 'rb') as f:
                signal = np.fromfile(f, dtype=np.float16)
            data.append(signal)
            labels.append(label)
    data = np.array(data)
    labels = np.array(labels)
    # 标准化处理
    scaler = StandardScaler()
    data = scaler.fit_transform(data)
    # 保存标准化参数
    scaler_path = r"./scaler.pkl"
    joblib.dump(scaler, scaler_path)
    return data, labels

# 构建数据集类
class MyDataset(Dataset):
    def __init__(self, data, labels):
        self.data = torch.tensor(data, dtype=torch.float32)
        self.labels = torch.tensor(labels, dtype=torch.long)

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(30720, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 128) #增加隐藏层和神经元的数量
        self.fc4 = nn.Linear(128, 64)
        self.dropout = nn.Dropout(0.15)
        # self.dropout = nn.Dropout(0.1)
        self.fc5 = nn.Linear(64, 11)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.relu(self.fc3(x))
        x = torch.relu(self.fc4(x))
        x = self.dropout(x)
        x = self.fc5(x)
        return x

# 训练模型
def train_model(model, train_loader, val_loader, criterion, optimizer, num_epochs, device):
    model.to(device)
    best_accuracy = 0.0
    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        for inputs, targets in train_loader:
            inputs, targets = inputs.to(device), targets.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()

        # 验证集上的评估
        model.eval()
        val_loss = 0.0
        total_correct = 0
        with torch.no_grad():
            for inputs, targets in val_loader:
                inputs, targets = inputs.to(device), targets.to(device)
                outputs = model(inputs)
                loss = criterion(outputs, targets)
                val_loss += loss.item()
                _, predicted = torch.max(outputs, 1)
                total_correct += (predicted == targets).sum().item()

        accuracy = total_correct / len(val_loader.dataset)
        print(f'Epoch {epoch + 1}, Loss: {running_loss/len(train_loader)}, Val Loss: {val_loss/len(val_loader)}, Val Accuracy: {accuracy}')\
        
        # 保存验证集上表现最好的模型
        if accuracy > best_accuracy:
            best_accuracy = accuracy
            best_model_wts = model.state_dict()

    # 加载最佳模型权重
    model.load_state_dict(best_model_wts)

# 加载数据
folder_path = r"D:\智联杯\本地调试的数据集\1.AI场景分类训练集(带标签)\train_set_remake"
data, labels = load_and_preprocess_data(folder_path)
X_train, X_val, y_train, y_val = train_test_split(data, labels, test_size=0.22, random_state=42)

# 构建数据加载器
train_dataset = MyDataset(X_train, y_train)
val_dataset = MyDataset(X_val, y_val)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32)

# 定义模型、损失函数和优化器
model = MyModel()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.0001, weight_decay=1e-5) 

# 训练模型
num_epochs = 650
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_model(model, train_loader, val_loader, criterion, optimizer, num_epochs, device)

# 测试模型
model.eval()
with torch.no_grad():
    total_correct = 0
    for inputs, targets in val_loader:
        inputs, targets = inputs.to(device), targets.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total_correct += (predicted == targets).sum().item()

accuracy = total_correct / len(val_loader.dataset)
print("模型在验证集上的准确率：", accuracy)

# 定义模型保存路径
model_path = r"./my_model.pth"
# 保存模型
torch.save(model.state_dict(), model_path)
print("模型已保存")

predict.py

import os
import numpy as np
import torch
import torch.nn as nn
import pandas as pd
from sklearn.preprocessing import StandardScaler
import joblib  # 用于加载标准化参数
from natsort import natsorted  # 用于自然排序

# 定义模型架构
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(30720, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 128)
        self.fc4 = nn.Linear(128, 64)
        self.dropout = nn.Dropout(0.15)
        self.fc5 = nn.Linear(64, 11)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.relu(self.fc3(x))
        x = torch.relu(self.fc4(x))
        x = self.dropout(x)
        x = self.fc5(x)
        return x

# 加载并预处理数据
def load_and_preprocess_single_data(file_path):
    data = []
    with open(file_path, 'rb') as f:
        signal = np.fromfile(f, dtype=np.float16)
    data.append(signal)
    signal = np.array(data)
    # 加载标准化参数
    scaler_path = r"./scaler.pkl"
    scaler = joblib.load(scaler_path)
    signal = scaler.transform(data)
    return signal

# 预测函数
def predict(model, input_data):
    model.eval()
    with torch.no_grad():
        inputs = torch.tensor(input_data, dtype=torch.float32)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
    return predicted.item()

# 定义模型并加载参数
model = MyModel()
model_path = r"./my_model.pth"
model.load_state_dict(torch.load(model_path))

# 读取要预测的文件夹路径
predict_folder_path = r"D:\智联杯\本地调试的数据集\2.AI场景分类测试集(无标签)"

# 存储所有预测结果
predictions = []

# 对文件夹中的每个文件进行预测
for file in natsorted(os.listdir(predict_folder_path)):
    if file.endswith('.bin'):
        file_path = os.path.join(predict_folder_path, file)
        input_data = load_and_preprocess_single_data(file_path)
        predicted_label = predict(model, input_data)
        predictions.append(predicted_label)

# 将预测结果保存到 CSV 文件
csv_output_path = r"./result.csv"
df_predictions = pd.DataFrame(predictions, columns=['PredictedLabel'])
df_predictions.to_csv(csv_output_path, index=False, header=False)  # header=False 避免写入表头

print(f'Predictions have been saved to {csv_output_path}')

其实就是用了数据预处理（标准化）、构建pytorch分类的网络类（线性层、dropout、激励函数）、训练循环、后向传播、学习率+调度、损失函数、优化器、保存和提取模型。准确率便能达到68%。

https://github.com/lzglzglzglzg/Wireless-program，这是当场第一的队伍的代码仓库，他们的准确率达到了惊人的99%。

迁移学习（Transfer Learning）

迁移学习的核心思想是使用在大规模数据集（如ImageNet）上预训练的模型，进行微调（fine-tuning）来适应新的任务。

# 冻结预训练模型的参数
for param in model.parameters():
    param.requires_grad = False

# 修改最后一层以适应新任务
model.fc = nn.Linear(model.fc.in_features, 10)  # 假设新任务有10个类别

这样，只需要训练模型最后的几层，利用预训练模型的知识。

总结

PyTorch 作为一种灵活的神经网络框架，支持从简单的线性堆叠到复杂的非线性网络拓扑构建。通过 nn.Sequential 可以快速搭建简单的模型，而通过继承 nn.Module，则可以自定义复杂的前向传播逻辑以适应各类任务需求。学习率、梯度下降、反向传播、超参数（如 epoch、batch）在网络训练中至关重要，Dropout 等正则化方法能有效防止过拟合。理解这些概念有助于高效地搭建和优化神经网络。