批量归一化（BATCH NORM）

眠.

已于 2024-06-12 22:01:32 修改

阅读量664

点赞数 8

文章标签： batch 开发语言人工智能卷积神经网络 pytorch

于 2024-05-28 20:54:25 首次发布

本文链接：https://blog.csdn.net/2202_75851137/article/details/139277351

版权

什么是批量归一化

批量归一化（Batch Normalization）是深度学习中常用的一种技术，旨在加速神经网络的训练并提高收敛速度。它通过对每个特征的数值进行归一化处理，使得数据分布更加稳定，有利于网络的训练。可以避免梯度消失或梯度爆炸问题，并且有助于加速模型的训练过程。

为什么要用批量归一化

缓解梯度消失和梯度爆炸：在深度神经网络中，梯度消失和梯度爆炸是常见的问题，批量归一化可以帮助控制梯度的范围，从而缓解这些问题。
加速训练收敛：批量归一化有助于加速神经网络的训练收敛速度，减少训练时间，提高训练效率。
增加模型的稳定性：批量归一化使得神经网络对参数初始化不那么敏感，增加了训练的稳定性，有利于训练更深、更复杂的网络结构。
允许更高的学习率：使用批量归一化可以允许更高的学习率，从而更快地找到损失函数的最优解。
减少对初始权重的敏感性。

怎么归一化

什么样的数据适合归一化

归一化适合用于具有不同量纲或取值范围的特征的数据。一般来说，以下类型的数据适合进行归一化处理：

批量归一化适用于深度神经网络中的各层输入数据。具体来说，以下情况的数据适合进行批量归一化处理：
深度神经网络：批量归一化主要应用于深度神经网络中，特别是对于包含多个隐藏层的复杂网络结构，如卷积神经网络（CNN）和循环神经网络（RNN）等。
输入数据分布不稳定：当神经网络各层的输入数据分布发生变化时，例如训练过程中每个批次的数据分布不一致，这种情况下适合使用批量归一化来稳定网络的训练。
提高模型的泛化能力：批量归一化有助于提高模型对未见过数据的泛化能力，减少过拟合的风险。
解决梯度消失和梯度爆炸问题：批量归一化可以缓解梯度消失和梯度爆炸问题，有助于更稳定地训练深度神经网络。

代码举例

下面是一个用pytorch写的一个10分类的卷积神经网络架构：

import torch.nn as nn
import torch.nn.functional as F
import torch

class Net(nn.Module):
    def __init__(self) :
        super(Net, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.GELU()
        )

        self.max_pooling1 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.conv2_1 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.GELU()
        )

        self.conv2_2 = nn.Sequential(
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.GELU()
        )

        self.max_pooling2 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.conv3_1 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1),
            nn.BatchNorm2d(256),
            nn.GELU()
        )

        self.conv3_2 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.GELU()
        )
        self.max_pooling3 = nn.MaxPool2d(kernel_size=2, stride=2,padding=1)

        self.conv4_1 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.GELU()
        )

        self.conv4_2 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.GELU()
        )
        self.max_pooling4 = nn.MaxPool2d(kernel_size=2, stride=2)
        
        self.fc = nn.Linear(512 * 2 * 2 ,10)

    def forward(self, x):
        batchsize = x.size(0)
        out = self.conv1(x)
        out = self.max_pooling1(out)
        out = self.conv2_1(out)
        out = self.conv2_2(out)
        out = self.max_pooling2(out)
        out = self.conv3_1(out)
        out = self.conv3_2(out)
        out = self.max_pooling3(out)
        out = self.conv4_1(out)
        out = self.conv4_2(out)
        out = self.max_pooling4(out)
        
        out = out.view(batchsize, -1)
        out = self.fc(out)
        out = F.log_softmax(out, dim=1)
        return out