深度学习调参入门_ann调参

1、搭建ANN模型

在python中，使用nn.Module和nn.Sequential都可以用来定义神经网络。假设说我要定义一个输入为3，输出为5维的ANN模型用来做分类，3x20x5的网络结构，可以这样做

import torch
import torch.nn as nn

class MyNetwork(nn.Module):
    def __init__(self):
        super(MyNetwork, self).__init__()
        self.fc1 = nn.Linear(3, 20)
        self.fc2 = nn.Linear(20, 5)
        self.relu = nn.ReLU(inplace=True)
        self.softmax = nn.Softmax(dim=1)  # dim=1表示沿着第一个维度列进行处理
        
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.softmax(x)
        return x

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

用nn.Sequential模块，则可以这样做

class ANN(nn.Module):
    def __init__(self):
        super(ANN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(3, 20),
            nn.ReLU(inplace=True),

            nn.Linear(20, 5),
            nn.Softmax(dim=1)# 将输出转换为概率分布
        )

    def forward(self, x):
        return self.net(x)
1
2
3
4
5
6
7
8
9
10
11
12
13

所以看出来两个方法的区别了吗？用nn.Module可以预先定义好一些网络函数，然后再forward方法中自由组合网络结构。而在nn.Sequential中则网络每一层该如何运行已经按照顺序预先写死了，方便简洁地展示网络结构。

2、lr_scheduler学习率参数管理

torch.optim.lr_scheduler.StepLR 是 PyTorch 中的一个学习率调整器（learning rate scheduler），用于在训练过程中根据指定的步骤调整学习率

使用 StepLR 需要先创建一个优化器（optimizer），然后将该优化器传递给 StepLR 的构造函数。 StepLR 的构造函数有几个参数，其中最重要的是 step_size 和 gamma。

step_size 表示学习率调整的步长，即多少个 epoch 调整一次学习率。例如，如果 step_size=5，则每训练 5 个 epoch，学习率会调整一次。
gamma 表示学习率缩放因子，即每次调整学习率时，将当前学习率乘以 gamma。例如，如果 gamma=0.1，则每次学习率调整时，学习率会变为原来的 0.1 倍。
下面是一个使用 StepLR 调整学习率的示例：

import torch
import torch.optim as optim
import torch.optim.lr_scheduler as lr_scheduler

#创建一个优化器
optimizer = optim.SGD(model.parameters(), lr=0.1)

 创建一个学习率调整器
scheduler = lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

 在训练循环中使用学习率调整器
for epoch in range(num_epochs):
    # 训练模型的代码
    
    # 在每个 epoch 结束时，调整学习率
    scheduler.step()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在上述示例中，我们首先创建了一个优化器 optimizer，使用随机梯度下降（SGD）算法，并设置初始学习率为 0.1。然后，创建了一个学习率调整器 scheduler，通过 StepLR 构造函数传入优化器，设置 step_size=5 和 gamma=0.1。在每个 epoch 结束时，使用 scheduler.step() 来更新学习率。

使用 StepLR 可以根据训练进程中的 epoch 数量来自动调整学习率，以帮助模型更好地收敛。根据任务的不同和调优的需要，可以根据实际情况设置合适的 step_size 和 gamma 参数。

3、对训练数据进行标准化和反标准化

from sklearn.preprocessing import StandardScaler, MinMaxScaler

# 创建一个 StandardScaler 对象
scaler = StandardScaler()
# 拟合训练数据并进行标准化处理
scaled_train_data = scaler.fit_transform(train_data)
# 将数据转换回去
origin_train_data=scaler.inverse_transform(scaled_train_data )
1
2
3
4
5
6
7
8

注意，scaler中还有另一种用法transform。它和fit_transform的区别在于一个是只转换，另一个是拟合加转换。拟合的意思即时会自动获取数据中的均值，标准差信息，然后再标准化转换。而转换transform必须在已经拟合且转换的过程fit_transform之后进行。

为什么这样处理呢，这里涉及到2种做法。
第一种，开始标准化之前将训练集和测试集放在一起，集中进行标准化。
第二种，只将训练集进行标准化，默认测试集与训练集同分布，均值标准差一致，只对测试集进行转换。
这样就会明白了。

4、统计分类准确率

4.1 sklearn.metrics.accuracy_score

输入必须是ndarry类型

from sklearn.metrics import accuracy_score

y_pred=[0,1,1,0]
y_true=[0,1,0,0]
accuracy=accuracy_score(y_true,y_pred)
print(f'Accuracy:{accuracy}')

# output
Accuracy:0.75
1
2
3
4
5
6
7
8
9

4.2 torch.classification.Accuracy

输入必须是tensor类型

import torch
from torchmetrics.classification import Accuracy

# 创建一个Accuracy实例
accuracy_metric = Accuracy(task="multiclass", num_classes=2)

# 模拟模型的输出和目标标签
y_pred = torch.tensor([0.2, 0.8, 0.5, 0.3])
y_true = torch.tensor([0, 1, 1, 0])

# 计算准确性
accuracy = accuracy_metric(y_pred, y_true)
print(f'Accuracy: {accuracy.item()}')

# output 
Accuracy: 0.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意，这种情况下输出的accuracy=0。如果说y_pred和y_true同维度，那么，y_pred则一般必须是已经经过了softmax函数argmax函数处理。
换个例子

import torch
from torchmetrics.classification import Accuracy

# 创建一个Accuracy实例
accuracy_metric = Accuracy(task="multiclass", num_classes=4)

# 模拟模型的输出和目标标签
y_pred = torch.tensor([[0.2, 0.8, 0.5, 0.3],[0.2, 0.8, 0.5, 0.3],[0.2, 0.8, 0.5, 0.3],[0.2, 0.8, 0.5, 0.3]])
y_true = torch.tensor([0, 1, 1, 0])

# 计算准确性
accuracy = accuracy_metric(y_pred, y_true)
"""
这里等价于
y_pred=torch.argmax(y_pred,dim=-1) # y_pred: tensor([1,1,1,1])，取最大值所在列的索引
accuracy=accuracy_metric(y_pred,y_true)
"""

print(f'Accuracy: {accuracy.item()}')
# output
Accuracy: 0.5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5、分类的损失函数

5.1 crossentropyloss

6、如何打印模型的参数两

print(f'model params size: {sum(p.numel() for p in self.model.parameters()) / (1024*1024):.2f} MB')
# model为已经定义好的NN网络
1
2