利用nn.BatchNorm构建带BN的神经网络

Tomorrow'sThinker

已于 2022-09-29 20:58:33 修改

阅读量1.1k

点赞数

分类专栏：深度学习文章标签：神经网络深度学习人工智能

于 2022-09-14 20:01:53 首次发布

本文链接：https://blog.youkuaiyun.com/a_Loki/article/details/126854398

版权

深度学习专栏收录该内容

16 篇文章

订阅专栏

该博客探讨了在PyTorch中如何使用批量归一化（BatchNormalization）进行网络构建，并展示了其在模型训练中的应用。通过对比实验，说明了BatchNormalization的位置对模型效果的影响，以及在不同Batch_size下，模型的收敛速度和性能变化。同时强调了综合调参的重要性，尤其是在复杂模型和大数据量的情况下，BatchNormalization能带来更好的效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

网络构建:

用写好的fit函数进行模型训练

综合调参:

Bach Normalization与Batch_size综合调参

网络构建:

在构建网络中，我们会定义好一些选择哪种激活函数和是否需要进行BatchNorm以及是在激活函数之前进行BatchNorm还是之后进行，其它为正常网络构建过程:

import torch.nn as nn
import torch

class net_class1(nn.Module):
    def __init__(self,act_fun=torch.relu,in_features=2,n_hidden=4,out_features=1,bias=True,BN_model=None,momentum=0.1):
        super(net_class1, self).__init__()
        self.linear1 = nn.Linear(in_features,n_hidden,bias=bias)
        self.bn1 = nn.BatchNorm1d(n_hidden,momentum=momentum)
        self.linear2 = nn.Linear(n_hidden,out_features,bias=bias)
        self.act_fun = act_fun
        self.BN_model = BN_model

    def forward(self,x):
        if self.BN_model == 'pre':
            z1 = self.bn1(self.linear1(x))
            f1 = self.act_fun(z1)
            out = self.linear2(f1)
        elif self.BN_model == 'post':
            z1 = self.linear1(x)
            f1 = self.act_fun(z1)
            out = self.linear2(self.bn1(f1))
        else:
            z1 = self.linear1(x)
            f1 = self.act_fun(z1)
            out = self.linear2(f1)
        return out

""""""

无论bn层在隐藏层之前还是之后，对实际结果不会有影响

用写好的fit函数进行模型训练

from  MyPython.test.study.MyTorchUtils import  MyTorchUtils

"""fit model"""
utils = MyTorchUtils()
torch.manual_seed(420)

# create data
features,labls = utils.tensorDataGenRe(bag=2,w=[2,-1],bias=False)

# split data
train_loader,test_loader = utils.split_loader(features,labls)

# instantiation nn , enter training mode
relu_model1_norm = net_class1(BN_model='pre')
relu_model1_norm.train()

lr = 0.3
utils.fit(net=relu_model1_norm,
          criterion=nn.MSELoss(),
          optimizer=optim.SGD(relu_model1_norm.parameters(),lr=lr),
          batchdata=train_loader,
          epochs=20,
          cla=False)

print([*relu_model1_norm.modules()][2].weight)
print([*relu_model1_norm.modules()][2].bias)

print([*relu_model1_norm.modules()][2].running_mean)
print([*relu_model1_norm.modules()][2].running_var)

# enter testing mdoe
relu_model1_norm.eval()
print(utils.mse_cla(train_loader, relu_model1_norm))
print(utils.mse_cla(test_loader, relu_model1_norm))

print([*relu_model1_norm.modules()][2].weight)
print([*relu_model1_norm.modules()][2].bias)

print([*relu_model1_norm.modules()][2].running_mean)
print([*relu_model1_norm.modules()][2].running_var)

注意的是，单独无脑的加入BN层并不一定会提升模型的效果，这里加入一段对比代码:

def bn_sigmoid():
    torch.manual_seed(929)

    sigmoid_model1 = net_class1(act_fun=torch.sigmoid)
    sigmoid_model_norm = net_class1(act_fun=torch.sigmoid,BN_model='pre')

    model_1 = [sigmoid_model1,sigmoid_model_norm]
    name_1 = ['simoid_model1','sigmoid_model1_norm']

    lr = 0.03
    num_epochs = 40

    train_1,test_1 = utils.model_comparison(model_1=model_1,
                                            name_1=name_1,
                                            train_data=train_loader,
                                            test_data=test_loader,
                                            num_epochs=num_epochs,
                                            criterion=nn.MSELoss(),
                                            optimizer=optim.SGD,
                                            lr=lr,
                                            cla=False,
                                            eva=utils.mse_cla)
    for i,name in enumerate(name_1):
        plt.plot(list(range(num_epochs)),train_1[i],label=name)
    plt.legend(loc=1)
    plt.show()

在上面模型中加入bn层，模型效果反而会变差，此时需要和别的参数进行联合调参，结果:

综合调参:

Bach Normalization与Batch_size综合调参

我们首先要明白的一点是，要让模型得到最好的效果其实就是bn层计算出的均值和方差越接近真实的均值和方差，而当面对的数据量(也就是Batch_size)太少的时候，我们用小批数据去估计大的整体就会出现较大的偏差，影响模型准确率。

调大数据数量来对比:

def bn_sigmoid2():
    utils = MyTorchUtils()

    torch.manual_seed(420)

    features,labls = utils.tensorDataGenRe(bag=2,w=[2,-1],bias=False)

    train_loader,test_loader = utils.split_loader(features,labls,batch_size=50)

    sigmoid_model1 = net_class1(act_fun=torch.sigmoid)
    sigmoid_model_norm = net_class1(act_fun=torch.sigmoid,BN_model='pre')

    model_1 = [sigmoid_model1,sigmoid_model_norm]
    name_1 = ['simoid_model1','sigmoid_model1_norm']

    lr = 0.03
    num_epochs = 40

    train_1, test_1 = utils.model_comparison(model_1=model_1,
                                             name_1=name_1,
                                             train_data=train_loader,
                                             test_data=test_loader,
                                             num_epochs=num_epochs,
                                             criterion=nn.MSELoss(),
                                             optimizer=optim.SGD,
                                             lr=lr,
                                             cla=False,
                                             eva=utils.mse_cla)

    for i,name in enumerate(name_1):
        plt.plot(list(range(num_epochs)),train_1[i],label=name)
    plt.legend(loc=1)
    plt.show()

对比上段代码，更改了batch_size，结果如下: