精华内容
下载资源
问答
  • m = nn.BatchNorm2d(2,affine=True) #权重w和偏重将被使用 input = torch.randn(1,2,3,4) output = m(input) print("输入图片:") print(input) print("归一化权重:") print(m.weight) print("归一化的偏重:") ...
  • BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) 1.num_features:一般输入参数为batch_sizenum_featuresheight*width,即为其中特征的数量,即为输入BN层的通道数; 2.eps:...

    BN原理、作用:

    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    函数参数讲解:

    BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    

    1.num_features:一般输入参数为batch_sizenum_featuresheight*width,即为其中特征的数量,即为输入BN层的通道数;
    2.eps:分母中添加的一个值,目的是为了计算的稳定性,默认为:1e-5,避免分母为0;
    3.momentum:一个用于运行过程中均值和方差的一个估计参数(我的理解是一个稳定系数,类似于SGD中的momentum的系数);
    4.affine:当设为true时,会给定可以学习的系数矩阵gamma和beta
    一般来说pytorch中的模型都是继承nn.Module类的,都有一个属性trainning指定是否是训练状态,训练状态与否将会影响到某些层的参数是否是固定的,比如BN层或者Dropout层。通常用model.train()指定当前模型model为训练状态,model.eval()指定当前模型为测试状态。
    同时,BN的API中有几个参数需要比较关心的,一个是affine指定是否需要仿射,还有个是track_running_stats指定是否跟踪当前batch的统计特性。容易出现问题也正好是这三个参数:trainning,affine,track_running_stats。
    其中的affine指定是否需要仿射,也就是是否需要上面算式的第四个,如果affine=False则γ=1,β=0,并且不能学习被更新。一般都会设置成affine=True。
    trainning和track_running_stats,track_running_stats=True表示跟踪整个训练过程中的batch的统计特性,得到方差和均值,而不只是仅仅依赖与当前输入的batch的统计特性。相反的,如果track_running_stats=False那么就只是计算当前输入的batch的统计特性中的均值和方差了。当在推理阶段的时候,如果track_running_stats=False,此时如果batch_size比较小,那么其统计特性就会和全局统计特性有着较大偏差,可能导致糟糕的效果。
    如果BatchNorm2d的参数track_running_stats设置False,那么加载预训练后每次模型测试测试集的结果时都不一样;track_running_stats设置为True时,每次得到的结果都一样。
    running_mean和running_var参数是根据输入的batch的统计特性计算的,严格来说不算是“学习”到的参数,不过对于整个计算是很重要的。BN层中的running_mean和running_var的更新是在forward操作中进行的,而不是在optimizer.step()中进行的,因此如果处于训练中泰,就算不进行手动step(),BN的统计特性也会变化。

    model.train() #处于训练状态
    for data , label in self.dataloader:
        pred =model(data)  #在这里会更新model中的BN统计特性参数,running_mean,running_var
        loss=self.loss(pred,label)
        #就算不进行下列三行,BN的统计特性参数也会变化
        opt.zero_grad()
        loss.backward()
        opt.step()
    

    这个时候,要用model.eval()转到测试阶段,才能固定住running_mean和running_var,有时候如果是先预训练模型然后加载模型,重新跑测试数据的时候,结果不同,有一点性能上的损失,这个时候基本上是training和track_running_stats设置的不对。
    如果使用两个模型进行联合训练,为了收敛更容易控制,先预训练好模型model_A,并且model_A内还有若干BN层,后续需要将model_A作为一个inference推理模型和model_B联合训练,此时希望model_A中的BN的统计特性量running_mean和running_var不会乱变化,因此就需要将model_A.eval()设置到测试模型,否则在trainning模式下,就算是不去更新模型的参数,其BN都会变化,这将导致和预期不同的结果。

    展开全文
  • 本文整理匯總了Python中torch.nn.BatchNorm2d方法的典型用法代碼示例。如果您正苦於以下問題:Python nn.BatchNorm2d方法的具體用法?Python nn.BatchNorm2d怎麽用?Python nn.BatchNorm2d使用的例子?那麽恭喜您, ...

    本文整理匯總了Python中torch.nn.BatchNorm2d方法的典型用法代碼示例。如果您正苦於以下問題:Python nn.BatchNorm2d方法的具體用法?Python nn.BatchNorm2d怎麽用?Python nn.BatchNorm2d使用的例子?那麽恭喜您, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在模塊torch.nn的用法示例。

    在下文中一共展示了nn.BatchNorm2d方法的14個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於我們的係統推薦出更棒的Python代碼示例。

    示例1: __init__

    ​點讚 7

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self, input_size, n_channels, ngf, n_layers, activation='tanh'):

    super(ImageDecoder, self).__init__()

    ngf = ngf * (2 ** (n_layers - 2))

    layers = [nn.ConvTranspose2d(input_size, ngf, 4, 1, 0, bias=False),

    nn.BatchNorm2d(ngf),

    nn.ReLU(True)]

    for i in range(1, n_layers - 1):

    layers += [nn.ConvTranspose2d(ngf, ngf // 2, 4, 2, 1, bias=False),

    nn.BatchNorm2d(ngf // 2),

    nn.ReLU(True)]

    ngf = ngf // 2

    layers += [nn.ConvTranspose2d(ngf, n_channels, 4, 2, 1, bias=False)]

    if activation == 'tanh':

    layers += [nn.Tanh()]

    elif activation == 'sigmoid':

    layers += [nn.Sigmoid()]

    else:

    raise NotImplementedError

    self.main = nn.Sequential(*layers)

    開發者ID:jthsieh,項目名稱:DDPAE-video-prediction,代碼行數:25,

    示例2: __init__

    ​點讚 7

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self):

    super(GoogLeNet, self).__init__()

    self.pre_layers = nn.Sequential(

    nn.Conv2d(3, 192, kernel_size=3, padding=1),

    nn.BatchNorm2d(192),

    nn.ReLU(True),

    )

    self.a3 = Inception(192, 64, 96, 128, 16, 32, 32)

    self.b3 = Inception(256, 128, 128, 192, 32, 96, 64)

    self.maxpool = nn.MaxPool2d(3, stride=2, padding=1)

    self.a4 = Inception(480, 192, 96, 208, 16, 48, 64)

    self.b4 = Inception(512, 160, 112, 224, 24, 64, 64)

    self.c4 = Inception(512, 128, 128, 256, 24, 64, 64)

    self.d4 = Inception(512, 112, 144, 288, 32, 64, 64)

    self.e4 = Inception(528, 256, 160, 320, 32, 128, 128)

    self.a5 = Inception(832, 256, 160, 320, 32, 128, 128)

    self.b5 = Inception(832, 384, 192, 384, 48, 128, 128)

    self.avgpool = nn.AvgPool2d(8, stride=1)

    self.linear = nn.Linear(1024, 10)

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:26,

    示例3: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self):

    super(Model, self).__init__()

    self.conv1 = nn.Conv2d(3, 16, 3, padding=1)

    self.bn1 = nn.BatchNorm2d(16)

    self.conv2 = nn.Conv2d(16, 32, 3, padding=1)

    self.bn2 = nn.BatchNorm2d(32)

    self.conv3 = nn.Conv2d(32, 64, 3, padding=1)

    self.bn3 = nn.BatchNorm2d(64)

    self.conv4 = nn.Conv2d(64, 128, 3, padding=1)

    self.bn4 = nn.BatchNorm2d(128)

    self.conv5 = nn.Conv2d(128, 128, 3, dilation=2, padding=2)

    self.bn5 = nn.BatchNorm2d(128)

    self.conv6 = nn.Conv2d(128, 128, 3, dilation=4, padding=4)

    self.bn6 = nn.BatchNorm2d(128)

    self.conv7 = nn.Conv2d(128, 1+9, 3, padding=1)

    開發者ID:aleju,項目名稱:cat-bbs,代碼行數:23,

    示例4: _make_layer

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def _make_layer(self, block, planes, blocks, stride=1, dilation=1):

    downsample = None

    if stride != 1 or self.inplanes != planes * block.expansion:

    downsample = nn.Sequential(

    nn.Conv2d(self.inplanes, planes * block.expansion,

    kernel_size=1, stride=stride, bias=False),

    nn.BatchNorm2d(planes * block.expansion),

    )

    layers = []

    layers.append(block(self.inplanes, planes, stride, 1, downsample))

    self.inplanes = planes * block.expansion

    for i in range(1, blocks):

    # here with dilation

    layers.append(block(self.inplanes, planes, dilation=dilation))

    return nn.Sequential(*layers)

    開發者ID:aleju,項目名稱:cat-bbs,代碼行數:19,

    示例5: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self, block, layers, num_classes=1000):

    self.inplanes = 64

    super(ResNet, self).__init__()

    self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,

    bias=False)

    self.bn1 = nn.BatchNorm2d(64)

    self.relu = nn.ReLU(inplace=True)

    # maxpool different from pytorch-resnet, to match tf-faster-rcnn

    self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

    self.layer1 = self._make_layer(block, 64, layers[0])

    self.layer2 = self._make_layer(block, 128, layers[1], stride=2)

    self.layer3 = self._make_layer(block, 256, layers[2], stride=2)

    # use stride 1 for the last conv4 layer (same as tf-faster-rcnn)

    self.layer4 = self._make_layer(block, 512, layers[3], stride=1)

    for m in self.modules():

    if isinstance(m, nn.Conv2d):

    n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels

    m.weight.data.normal_(0, math.sqrt(2. / n))

    elif isinstance(m, nn.BatchNorm2d):

    m.weight.data.fill_(1)

    m.bias.data.zero_()

    開發者ID:Sunarker,項目名稱:Collaborative-Learning-for-Weakly-Supervised-Object-Detection,代碼行數:24,

    示例6: _make_layer

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def _make_layer(self, block, planes, blocks, stride=1):

    downsample = None

    if stride != 1 or self.inplanes != planes * block.expansion:

    downsample = nn.Sequential(

    nn.Conv2d(self.inplanes, planes * block.expansion,

    kernel_size=1, stride=stride, bias=False),

    nn.BatchNorm2d(planes * block.expansion),

    )

    layers = []

    layers.append(block(self.inplanes, planes, stride, downsample))

    self.inplanes = planes * block.expansion

    for i in range(1, blocks):

    layers.append(block(self.inplanes, planes))

    return nn.Sequential(*layers)

    開發者ID:Sunarker,項目名稱:Collaborative-Learning-for-Weakly-Supervised-Object-Detection,代碼行數:18,

    示例7: init_weights

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def init_weights(self, pretrained=None):

    """Initialize the weights in the module.

    Args:

    pretrained (str, optional): Path to pre-trained weights.

    Defaults to None.

    """

    if isinstance(pretrained, str):

    logger = get_root_logger()

    load_checkpoint(self, pretrained, strict=False, logger=logger)

    elif pretrained is None:

    for m in self.modules():

    if isinstance(m, nn.Conv2d):

    kaiming_init(m)

    elif isinstance(m, nn.BatchNorm2d):

    constant_init(m, 1)

    else:

    raise TypeError('pretrained must be a str or None')

    開發者ID:open-mmlab,項目名稱:mmdetection,代碼行數:20,

    示例8: fuse_module

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def fuse_module(m):

    last_conv = None

    last_conv_name = None

    for name, child in m.named_children():

    if isinstance(child, (nn.BatchNorm2d, nn.SyncBatchNorm)):

    if last_conv is None: # only fuse BN that is after Conv

    continue

    fused_conv = fuse_conv_bn(last_conv, child)

    m._modules[last_conv_name] = fused_conv

    # To reduce changes, set BN as Identity instead of deleting it.

    m._modules[name] = nn.Identity()

    last_conv = None

    elif isinstance(child, nn.Conv2d):

    last_conv = child

    last_conv_name = name

    else:

    fuse_module(child)

    return m

    開發者ID:open-mmlab,項目名稱:mmdetection,代碼行數:21,

    示例9: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self):

    super(CW2_Net, self).__init__()

    self.conv1 = nn.Conv2d(3, 32, 3)

    self.bnm1 = nn.BatchNorm2d(32, momentum=0.1)

    self.conv2 = nn.Conv2d(32, 64, 3)

    self.bnm2 = nn.BatchNorm2d(64, momentum=0.1)

    self.conv3 = nn.Conv2d(64, 128, 3)

    self.bnm3 = nn.BatchNorm2d(128, momentum=0.1)

    self.conv4 = nn.Conv2d(128, 128, 3)

    self.bnm4 = nn.BatchNorm2d(128, momentum=0.1)

    self.fc1 = nn.Linear(3200, 256)

    #self.dropout1 = nn.Dropout(p=0.35, inplace=False)

    self.bnm5 = nn.BatchNorm1d(256, momentum=0.1)

    self.fc2 = nn.Linear(256, 256)

    self.bnm6 = nn.BatchNorm1d(256, momentum=0.1)

    self.fc3 = nn.Linear(256, 10)

    #self.dropout2 = nn.Dropout(p=0.35, inplace=False)

    #self.dropout3 = nn.Dropout(p=0.35, inplace=False)

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:20,

    示例10: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self, in_planes, cardinality=32, bottleneck_width=4, stride=1):

    super(Block, self).__init__()

    group_width = cardinality * bottleneck_width

    self.conv1 = nn.Conv2d(in_planes, group_width, kernel_size=1, bias=False)

    self.bn1 = nn.BatchNorm2d(group_width)

    self.conv2 = nn.Conv2d(group_width, group_width, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False)

    self.bn2 = nn.BatchNorm2d(group_width)

    self.conv3 = nn.Conv2d(group_width, self.expansion*group_width, kernel_size=1, bias=False)

    self.bn3 = nn.BatchNorm2d(self.expansion*group_width)

    self.shortcut = nn.Sequential()

    if stride != 1 or in_planes != self.expansion*group_width:

    self.shortcut = nn.Sequential(

    nn.Conv2d(in_planes, self.expansion*group_width, kernel_size=1, stride=stride, bias=False),

    nn.BatchNorm2d(self.expansion*group_width)

    )

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:18,

    示例11: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self, last_planes, in_planes, out_planes, dense_depth, stride, first_layer):

    super(Bottleneck, self).__init__()

    self.out_planes = out_planes

    self.dense_depth = dense_depth

    self.conv1 = nn.Conv2d(last_planes, in_planes, kernel_size=1, bias=False)

    self.bn1 = nn.BatchNorm2d(in_planes)

    self.conv2 = nn.Conv2d(in_planes, in_planes, kernel_size=3, stride=stride, padding=1, groups=32, bias=False)

    self.bn2 = nn.BatchNorm2d(in_planes)

    self.conv3 = nn.Conv2d(in_planes, out_planes+dense_depth, kernel_size=1, bias=False)

    self.bn3 = nn.BatchNorm2d(out_planes+dense_depth)

    self.shortcut = nn.Sequential()

    if first_layer:

    self.shortcut = nn.Sequential(

    nn.Conv2d(last_planes, out_planes+dense_depth, kernel_size=1, stride=stride, bias=False),

    nn.BatchNorm2d(out_planes+dense_depth)

    )

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:20,

    示例12: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self, in_planes, planes, stride=1):

    super(BasicBlock, self).__init__()

    self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)

    self.bn1 = nn.BatchNorm2d(planes)

    self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)

    self.bn2 = nn.BatchNorm2d(planes)

    self.shortcut = nn.Sequential()

    if stride != 1 or in_planes != planes:

    self.shortcut = nn.Sequential(

    nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride, bias=False),

    nn.BatchNorm2d(planes)

    )

    # SE layers

    self.fc1 = nn.Conv2d(planes, planes//16, kernel_size=1) # Use nn.Conv2d instead of nn.Linear

    self.fc2 = nn.Conv2d(planes//16, planes, kernel_size=1)

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:19,

    示例13: _make_layers

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def _make_layers(self, cfg):

    layers = []

    in_channels = 3

    for x in cfg:

    if x == 'M':

    layers += [nn.MaxPool2d(kernel_size=2, stride=2)]

    else:

    layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),

    nn.BatchNorm2d(x),

    nn.ReLU(inplace=True)]

    in_channels = x

    layers += [nn.AvgPool2d(kernel_size=1, stride=1)]

    return nn.Sequential(*layers)

    # net = VGG('VGG11')

    # x = torch.randn(2,3,32,32)

    # print(net(Variable(x)).size())

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:19,

    示例14: __init__

    ​點讚 6

    # 需要導入模塊: from torch import nn [as 別名]

    # 或者: from torch.nn import BatchNorm2d [as 別名]

    def __init__(self, in_planes, out_planes, stride, groups):

    super(Bottleneck, self).__init__()

    self.stride = stride

    mid_planes = out_planes/4

    g = 1 if in_planes==24 else groups

    self.conv1 = nn.Conv2d(in_planes, mid_planes, kernel_size=1, groups=g, bias=False)

    self.bn1 = nn.BatchNorm2d(mid_planes)

    self.shuffle1 = ShuffleBlock(groups=g)

    self.conv2 = nn.Conv2d(mid_planes, mid_planes, kernel_size=3, stride=stride, padding=1, groups=mid_planes, bias=False)

    self.bn2 = nn.BatchNorm2d(mid_planes)

    self.conv3 = nn.Conv2d(mid_planes, out_planes, kernel_size=1, groups=groups, bias=False)

    self.bn3 = nn.BatchNorm2d(out_planes)

    self.shortcut = nn.Sequential()

    if stride == 2:

    self.shortcut = nn.Sequential(nn.AvgPool2d(3, stride=2, padding=1))

    開發者ID:StephanZheng,項目名稱:neural-fingerprinting,代碼行數:19,

    注:本文中的torch.nn.BatchNorm2d方法示例整理自Github/MSDocs等源碼及文檔管理平台,相關代碼片段篩選自各路編程大神貢獻的開源項目,源碼版權歸原作者所有,傳播和使用請參考對應項目的License;未經允許,請勿轉載。

    展开全文
  • BatchNorm2d()理解

    2020-12-08 19:36:00
    BatchNorm2d()理解基本原理在卷积神经网络的卷积层之后总会添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定,BatchNorm2d()函数数学原理如下:BatchNorm2d()...

    BatchNorm2d()理解

    基本原理

    在卷积神经网络的卷积层之后总会添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定,BatchNorm2d()函数数学原理如下:

    BatchNorm2d()内部的参数如下:

    1.num_features:一般输入参数为batch_sizenum_featuresheight*width,即为其中特征的数量

    2.eps:分母中添加的一个值,目的是为了计算的稳定性,默认为:1e-5

    3.momentum:一个用于运行过程中均值和方差的一个估计参数(我的理解是一个稳定系数,类似于SGD中的momentum的系数)

    4.affine:当设为true时,会给定可以学习的系数矩阵gamma和beta

    上面的讲解还不够形象,我们具体通过如下的代码进行讲解:

    代码演示

    #encoding:utf-8

    import torch

    import torch.nn as nn

    #num_features - num_features from an expected input of size:batch_sizenum_featuresheight*width

    #eps:default:1e-5 (公式中为数值稳定性加到分母上的值)

    #momentum:动量参数,用于running_mean and running_var计算的值,default:0.1

    m=nn.BatchNorm2d(2,affine=True) #affine参数设为True表示weight和bias将被使用

    input=torch.randn(1,2,3,4)

    output=m(input)

    print(input)

    print(m.weight)

    print(m.bias)

    print(output)

    print(output.size())

    具体的输出如下:

    tensor([[[[ 1.4174, -1.9512, -0.4910, -0.5675],

    [ 1.2095, 1.0312, 0.8652, -0.1177],

    [-0.5964, 0.5000, -1.4704, 2.3610]],

    [[-0.8312, -0.8122, -0.3876, 0.1245],

    [ 0.5627, -0.1876, -1.6413, -1.8722],

    [-0.0636, 0.7284, 2.1816, 0.4933]]]])

    Parameter containing:

    tensor([0.2837, 0.1493], requires_grad=True)

    Parameter containing:

    tensor([0., 0.], requires_grad=True)

    tensor([[[[ 0.2892, -0.4996, -0.1577, -0.1756],

    [ 0.2405, 0.1987, 0.1599, -0.0703],

    [-0.1824, 0.0743, -0.3871, 0.5101]],

    [[-0.0975, -0.0948, -0.0347, 0.0377],

    [ 0.0997, -0.0064, -0.2121, -0.2448],

    [ 0.0111, 0.1232, 0.3287, 0.0899]]]],

    grad_fn=)

    torch.Size([1, 2, 3, 4])

    分析:输入是一个1234 四维矩阵,gamma和beta为一维数组,是针对input[0][0],input[0][1]两个34的二维矩阵分别进行处理的,我们不妨将input[0][0]的按照上面介绍的基本公式来运算,看是否能对的上output[0][0]中的数据。首先我们将input[0][0]中的数据输出,并计算其中的均值和方差。

    print(“输入的第一个维度:”)

    print(input[0][0]) #这个数据是第一个3*4的二维数据

    #求第一个维度的均值和方差

    firstDimenMean=torch.Tensor.mean(input[0][0])

    firstDimenVar=torch.Tensor.var(input[0][0],False) #false表示贝塞尔校正不会被使用

    print(m)

    print(‘m.eps=’,m.eps)

    print(firstDimenMean)

    print(firstDimenVar)

    输出结果如下:

    输入的第一个维度:

    tensor([[ 1.4174, -1.9512, -0.4910, -0.5675],

    [ 1.2095, 1.0312, 0.8652, -0.1177],

    [-0.5964, 0.5000, -1.4704, 2.3610]])

    BatchNorm2d(2, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

    m.eps= 1e-05

    tensor(0.1825)

    tensor(1.4675)

    我们可以通过计算器计算出均值和方差均正确计算。最后通过公式计算input[0][0][0][0]的值,代码如下:

    batchnormone=((input[0][0][0][0]-firstDimenMean)/(torch.pow(firstDimenVar,0.5)+m.eps))

    *m.weight[0]+m.bias[0]

    print(batchnormone)

    输出结果如下:

    tensor(0.2892, grad_fn=)

    batchnorm2d()中的参数为实际的输入的特征数也就是通道数,对其进行归一化的时候,每个通道分别对应batchnorm2d()的参数。

    如:

    bn = nn.BatchNorm2d(4)

    那么bn.weight.shape应该是(4,)

    也就是说在归一化中第一个通道用到的均值和方差以及gamma均为bn.weight.data[0]

    ————————————————

    原文链接:https://blog.csdn.net/bigFatCat_Tom/article/details/91619977

    展开全文
  • nn.BatchNorm2d——批量标准化操作 torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None) 功能:对输入的四维数组进行批量标准化处理,...

    nn.BatchNorm2d——批量标准化操作

    torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)
    

    功能:对输入的四维数组进行批量标准化处理,具体计算公式如下:
    y = x − m e a n [ x ] V a r [ x ] + e p s ∗ g a m m a + b e t a y=\frac{x-mean[x]}{\sqrt{Var[x]+eps}}*gamma+beta y=Var[x]+eps xmean[x]gamma+beta

    对于所有的batch中的同一个channel的数据元素进行标准化处理,即如果有C个通道,无论有多少个batch,都会在通道维度上进行标准化处理,一共进行C次。

    训练阶段的均值和方差计算方法相同,将所有batch相同通道的值取出来,一块计算均值和方差,即计算当前观测值的均值和方差。

    测试阶段的均值和方差有两种计算方法:
    ①估计所有图片的均值和方差,即做全局计算,具体计算方法如下:
    模型分别储存各个通道(通道数需要预先定义)的均值和方差数据(初始为0和1),在每次训练过程中,每标准化一组数据,都利用计算得到的局部观测值的均值和方差对储存的数据做更新测试阶段利用模型存储的两个数据做标准化处理,更新公式如下:
    X n e w = ( 1 − m o m e n t u m ) × X o l d + m o m e n t u m × X t 其 中 , X n e w 是 模 型 的 新 参 数 , X o l d 是 模 型 原 来 的 参 数 , X t 是 当 前 观 测 值 的 参 数 X_{new}=(1-momentum)\times X_{old} + momentum\times X_t\\ 其中,X_{new}是模型的新参数,X_{old}是模型原来的参数,X_t是当前观测值的参数 Xnew=(1momentum)×Xold+momentum×XtXnewXoldXt
    ②采用和训练阶段相同的计算方法,即只计算当前输入数据的均值和方差

    输入:

    • num_features:输入图像的通道数量。
    • eps:稳定系数,防止分母出现0。
    • momentum:模型均值和方差更新时的参数,见上述公式。
    • affine:代表gamma,beta是否可学。如果设为True,代表两个参数是通过学习得到的;如果设为False,代表两个参数是固定值,默认情况下,gamma是1,beta是0。
    • track_running_stats:代表训练阶段是否更新模型存储的均值和方差,即测试阶段的均值与方差的计算方法采用第一种方法还是第二种方法。如果设为True,则代表训练阶段每次迭代都会更新模型存储的均值和方差(计算全局数据),测试过程中利用存储的均值和方差对各个通道进行标准化处理;如果设为False,则模型不会存储均值和方差,训练过程中也不会更新均值和方差的数据,测试过程中只计算当前输入图像的均值和方差数据(局部数据)。具体区别见代码案例。

    注意:

    • 训练阶段的标准化过程中,均值和方差来源途径只有一种方式,即利用当前输入的数据进行计算。
    • 测试阶段的标准化过程中,均值和方差来源途径有两种方式,一是来源于全局的数据,即模型本身存储一组均值和方差数据,在训练过程中,不断更新它们,使其具有描述全局数据的统计特性;二是来源于当前的输入数据,即和训练阶段计算方法一样,但这样会在测试过程中带来统计特性偏移的弊端,一般track_running_stats设置为True,即采用第一种来源途径。
    • 换句话说,就是训练阶段和测试阶段所承载的任务不同,训练阶段主要是通过已知的数据去优化模型,而测试阶段主要是利用已知的模型去预测未知的数据。

    用途:

    • 训练过程中遇到收敛速度很慢的问题时,可以通过引入BN层来加快网络模型的收敛速度
    • 遇到梯度消失或者梯度爆炸的问题时,可以考虑引入BN层来解决
    • 一般情况下,还可以通过引入BN层来加快网络的训练速度

    批量标准化的具体原理请参考论文:Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift

    代码案例

    一般用法

    import torch
    from torch import nn
    # 在(0-1)范围内随机生成数据
    img=torch.rand(2,2,2,3)
    bn=nn.BatchNorm2d(2)
    img_2=bn(img)
    print(img)
    print(img_2)
    

    输出

    # 标准化前
    tensor([[[[0.5330, 0.7753, 0.6192],
              [0.9190, 0.1657, 0.5841]],
    
             [[0.7766, 0.7864, 0.2004],
              [0.9379, 0.3253, 0.1964]]],
    
    
            [[[0.7448, 0.9222, 0.1860],
              [0.3829, 0.8812, 0.2508]],
    
             [[0.0130, 0.0405, 0.2205],
              [0.8997, 0.5143, 0.9414]]]])
    # 标准化后
    tensor([[[[-0.1764,  0.7257,  0.1446],
              [ 1.2605, -1.5434,  0.0140]],
    
             [[ 0.8332,  0.8615, -0.8287],
              [ 1.2987, -0.4685, -0.8403]]],
    
    
            [[[ 0.6121,  1.2726, -1.4678],
              [-0.7350,  1.1199, -1.2269]],
    
             [[-1.3693, -1.2899, -0.7707],
              [ 1.1883,  0.0769,  1.3088]]]], grad_fn=<NativeBatchNormBackward>)
    

    标准化过程是以通道为维度计算的,即所有batch下,相同通道(channel)下的数据合并到一块,做标准化处理。若有C个通道,无论batch是多少,都会有C次标准化。

    import torch
    from torch import nn
    img=torch.rand(2,2,2,3)
    # 取出两个batch下第一个维度的数据
    a=torch.cat((img[0,0,:,:],img[1,0,:,:]),dim=0)
    # 转化为numpy格式,便于计算均值方差
    b=a.numpy()
    import numpy as np
    mean=np.mean(b)
    std=np.std(b)+1e-5
    # 手动标准化
    img_2=(b-mean)/std
    bn=nn.BatchNorm2d(2)
    # 利用BatchNorm2d标准化
    img_3=bn(img)
    print(img_2)
    print(img_3)
    

    输出

    手动标准化得到的数据,前两行代表第一个batch下第一个通道标准化后的数据,与利用BatchNorm2d的前两行数据相等;后两行代表第二个batch下第一个通道标准化后的数据,与利用BatchNorm2d的前五六行数据相等。

    # 手动标准化
    [[-0.8814389  -1.3535967   0.05035681]
     [-0.5180839  -1.396645    1.8198812 ]
     [ 0.9151892   0.9469903  -0.7903797 ]
     [ 0.35690263  1.135288   -0.28446582]]
    # 利用BatchNorm2d标准化
    tensor([[[[-0.8814, -1.3535,  0.0504],
              [-0.5181, -1.3966,  1.8198]],
    
             [[-1.5779, -0.5996, -1.0233],
              [-0.3919, -0.6692,  0.6693]]],
    
    
            [[[ 0.9151,  0.9469, -0.7903],
              [ 0.3569,  1.1352, -0.2844]],
    
             [[ 0.5829, -0.7664,  1.1329],
              [ 1.4469, -0.4100,  1.6063]]]], grad_fn=<NativeBatchNormBackward>)
    
    track_running_stats设为TrueFasle的区别

    训练过程

    import torch
    from torch import nn
    img=torch.rand(2,2,2,3)
    bn_t=nn.BatchNorm2d(2,track_running_stats=True)
    bn_f=nn.BatchNorm2d(2,track_running_stats=False)
    # 输出初始的模型存储值
    print('bn_t,mean:',bn_t.running_mean,'var:',bn_t.running_var)
    print('bn_f,mean:',bn_f.running_mean,'var:',bn_f.running_var)
    # 转化为训练阶段
    bn_t.train()
    bn_f.train()
    img_t=bn_t(img)
    img_f=bn_f(img)
    print(img_t)
    print(img_f)
    print('一次迭代更新bn_t,mean:',bn_t.running_mean,'var:',bn_t.running_var)
    img_t=bn_t(img)
    print('两次迭代更新bn_t,mean:',bn_t.running_mean,'var:',bn_t.running_var)
    

    输出

    # 初始过程,track_running_stats设为True时,模型存储全局均值与方差
    # 初始化为0和1,两个值对应两个通道
    bn_t,mean: tensor([0., 0.]) var: tensor([1., 1.])
    # track_running_stats设为False时,模型不存储均值与方差
    bn_f,mean: None var: None
    # 由下面的结果易知,track_running_stats设为True与False,对训练过程的标准化结果无影响
    tensor([[[[-1.0599,  0.9532, -0.2647],
              [ 0.8146,  0.2971, -1.7099]],
    
             [[ 1.0554,  0.9239,  1.9331],
              [ 0.0334, -1.3058, -0.0804]]],
    
    
            [[[ 1.0146,  0.7528, -0.1986],
              [ 1.3564, -1.6232, -0.3325]],
    
             [[-1.6591, -0.7690, -0.3045],
              [ 0.7691,  0.1344, -0.7306]]]], grad_fn=<NativeBatchNormBackward>)
    tensor([[[[-1.0599,  0.9532, -0.2647],
              [ 0.8146,  0.2971, -1.7099]],
    
             [[ 1.0554,  0.9239,  1.9331],
              [ 0.0334, -1.3058, -0.0804]]],
    
    
            [[[ 1.0146,  0.7528, -0.1986],
              [ 1.3564, -1.6232, -0.3325]],
    
             [[-1.6591, -0.7690, -0.3045],
              [ 0.7691,  0.1344, -0.7306]]]], grad_fn=<NativeBatchNormBackward>)
    # track_running_stats设为Ture时,模型每标准化一组数据,都会更新自己存储的数据一次
    一次迭代更新bn_t,mean: tensor([0.0562, 0.0586]) var: tensor([0.9092, 0.9043])
    两次迭代更新bn_t,mean: tensor([0.1068, 0.1114]) var: tensor([0.8275, 0.8183])
    

    测试过程

    import torch
    from torch import nn
    # img和上个训练过程的数据一样,为了便于做比较
    bn_t=nn.BatchNorm2d(2,track_running_stats=True)
    bn_f=nn.BatchNorm2d(2,track_running_stats=False)
    # 输出初始的模型存储值,测试过程中,bn_t利用该值进行标准化
    print('bn_t,mean:',bn_t.running_mean,'var:',bn_t.running_var)
    # 转化为测试过程
    bn_t.eval()
    bn_f.eval()
    img_t=bn_t(img)
    img_f=bn_f(img)
    print(img)
    print(img_t)
    print(img_f)
    bn_t.train()
    img_t=bn_t(img)
    bn_t.eval()
    img_t=bn_t(img)
    print('更新后bn_t,mean:',bn_t.running_mean,'var:',bn_t.running_var)
    print(img_t)
    

    输出

    # track_running_stats设为Ture时
    # 在测试过程中利用running_mean和running_var做标准化计算
    bn_t,mean: tensor([0., 0.]) var: tensor([1., 1.])
    # 如果不进行训练,则默认初始值为0和1,用这两个数做标准化时的结果与输入相同
    # 输入数据
    tensor([[[[0.2542, 0.8395, 0.4854],
              [0.7992, 0.6488, 0.0652]],
    
             [[0.7970, 0.7707, 0.9722],
              [0.5929, 0.3256, 0.5702]]],
    
    
            [[[0.8574, 0.7813, 0.5046],
              [0.9568, 0.0904, 0.4657]],
    
             [[0.2550, 0.4327, 0.5255],
              [0.7398, 0.6131, 0.4404]]]])
    # track_running_stats设为Ture时,拿初始化数据进行标准化计算结果
    # 可见与上述结果相同
    tensor([[[[0.2542, 0.8395, 0.4854],
              [0.7992, 0.6488, 0.0652]],
    
             [[0.7970, 0.7707, 0.9722],
              [0.5929, 0.3256, 0.5702]]],
    
    
            [[[0.8574, 0.7813, 0.5046],
              [0.9568, 0.0904, 0.4657]],
    
             [[0.2550, 0.4327, 0.5255],
              [0.7398, 0.6131, 0.4404]]]], grad_fn=<NativeBatchNormBackward>)
    # track_running_stats设为Fasle时,标准化计算结果和训练过程一样,因此结果相同
    # 这里的输入数据和上一个案例一样,可以和上个过程的结果做比较。
    tensor([[[[-1.0599,  0.9532, -0.2647],
              [ 0.8146,  0.2971, -1.7099]],
    
             [[ 1.0554,  0.9239,  1.9331],
              [ 0.0334, -1.3058, -0.0804]]],
    
    
            [[[ 1.0146,  0.7528, -0.1986],
              [ 1.3564, -1.6232, -0.3325]],
    
             [[-1.6591, -0.7690, -0.3045],
              [ 0.7691,  0.1344, -0.7306]]]], grad_fn=<NativeBatchNormBackward>)
    # 经过一次训练过程,running_mean与running_var都有所改变
    更新后bn_t,mean: tensor([0.0562, 0.0586]) var: tensor([0.9092, 0.9043])
    # 再进行测试时,用新的running_mean和running_var做标准化计算
    tensor([[[[0.2076, 0.8215, 0.4501],
              [0.7792, 0.6214, 0.0094]],
    
             [[0.7764, 0.7488, 0.9607],
              [0.5619, 0.2807, 0.5380]]],
    
    
            [[[0.8402, 0.7604, 0.4702],
              [0.9444, 0.0358, 0.4294]],
    
             [[0.2065, 0.3934, 0.4909],
              [0.7163, 0.5831, 0.4015]]]], grad_fn=<NativeBatchNormBackward>)
    

    官方文档

    nn.BatchNorm2d:https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm2d.html?highlight=norm2d#torch.nn.BatchNorm2d

    展开全文
  • nn.BatchNorm2D() 详细解析 paddle.nn.BatchNorm2D(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCHW', name=None): 目的 加速神经网络的收敛过程以及提高训练...
  • 1.nn.BatchNorm1d(num_features) 1.对小批量(mini-batch)的2d或3d输入进行批标准化(Batch Normalization)操作 2.num_features: 来自期望输入的特征数,该期望输入的大小为’batch_size x num_features [x width]’ ...
  • 完全解读BatchNorm2d归一化算法原理

    千次阅读 2020-01-14 08:30:00
    最近小编在研究yolo3的算法源码,在调试过程中发现中间层的BatchNorm2d的结果竟然出现了Nan。第一次遇到这种情况,为了找出其中的原因,小编查阅了Pytorch官网关于Batc...
  • BatchNorm2d的使用

    2020-12-18 21:22:43
    bn = nn.BatchNorm2d(num_features=2) res = bn(input) print(res) 2. 作用 其实就是将一批feature map进行标准化处理。我们都学过正态分布的表达,xˉi=x−μσ2{\bar x_i} = \frac{{x - \mu }}{{{\sigma ^2}}}x...
  • BN原理、做用: 函数参数讲解:BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)1.num_features:通常输入参数为batch_sizenum_featuresheight*width,即为其中特征的数量,即为...
  • Pytorch:nn.BatchNorm2d()函数

    千次阅读 多人点赞 2020-05-18 09:47:24
    1 BatchNorm2d()函数 class torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True) parameters: num_features: 一般输入参数为batch_size*num_features*height*width,即为其中特征的数量...
  • PyTorch基础——torch.nn.BatchNorm2d

    千次阅读 2020-10-17 11:59:07
    batchNorm2d:对输入batch进行batch normalize 以2 x 3 x 4 x 5输入为例,其中 2:batch中样本数量 3:每个样本通道数 4:每个样本行数 5:每个样本列数 第一个样本:3(通道) x 4(行) x 5(列) 141 ...
  • 【PyTorch】详解pytorch中nn模块的BatchNorm2d()函数

    万次阅读 多人点赞 2019-06-12 21:45:34
    在卷积神经网络的卷积层之后总会添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定,BatchNorm2d()函数数学原理如下: BatchNorm2d()内部的参数如下: 1....
  • Conv2d https://pytorch.org/docs/stable/nn.html#conv2d torch.nn.Conv2d( in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros' ) s...
  • PyTorch中的BatchNorm2d

    2020-12-08 19:36:03
    先来看看pytorch中对于类的定义:CLASS torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)解析一下每个参数的作用:num_features:BatchNorm是针对每一个通道做...
  • 有关Pytorch中BatchNorm2d权重加载的问题 >>> import torch.nn as nn >>> bn = nn.BatchNorm2d(3) >>> list(bn.parameters()) [Parameter containing: tensor([1., 1., 1.], requires_...
  • nn.BatchNorm2d() 首先这个方法就是进行归一化,默认第一个参数就是传入的数据的通道数,老是记不住,这样理解就好了,因为是归一化,那肯定要对每一个channel都要进行归一化
  • BatchNorm2d()函数

    2021-07-19 14:27:37
    在卷积神经网络的卷积层之后总会添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定,BatchNorm2d()函数数学原理如下: BatchNorm2d()内部的参数如下: 1...
  • BatchNorm2d()内部的参数如下: num_features:一般情况下输入的数据格式为batch_size * num_features * height * width,即为特征数,channel数eps:分母中添加的一个值,目的是为了计算的稳定性,默认:1e-5...
  • PyTorch踩坑指南(1)nn.BatchNorm2d()函数

    万次阅读 多人点赞 2020-04-16 14:46:50
    BatchNorm2d()内部的参数如下: num_features:一般情况下输入的数据格式为batch_size * num_features * height * width,即为特征数,channel数 eps:分母中添加的一个值,目的是为了计算的稳定性,默认:1e-5 ...
  • pytorch中批量归一化BatchNorm1d和BatchNorm2d函数

    万次阅读 多人点赞 2019-12-24 16:05:42
    class torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True) [source] 对小批量(mini-batch)的2d或3d输入进行批标准化(Batch Normalization)操作 在每一个小批量(mini-batch)数据中,...
  • class MyBatchNorm2d: def __init__(self, gamma=1, beta=0, eps=0.001, momentum=0.99): self.gamma = gamma self.beta = beta self.eps = eps self.momentum = momentum self.running_mean = 0.0
  • nn.BatchNorm2d

    千次阅读 2019-06-04 20:12:00
    今天查资料看到说batchnorm2d的作用如下 nn.BatchNorm2d(out_channel), #BatchNorm2d最常用于卷积网络中(防止梯度消失或爆炸),设置的参数就是卷积的输出通道数 转一篇文章可以看看 Pytorch中的Batch ...
  • torch.nn.BatchNorm2d()计算

    千次阅读 2021-11-17 10:39:35
    from torch.nn import MSELoss import torch class Model(torch.nn.Module): def __init__(self): super(Model, self).__init__() ... torch.nn.BatchNorm2d(2, affine=True) ]) def forward(s
  • 参考链接: class torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) 实验代码展示: 在这里插入代码片
  • pytorch nn.BatchNorm2d() 参数解释

    万次阅读 多人点赞 2020-03-19 09:29:59
    在使用pytorch的 nn.BatchNorm2d() 层的时候,经常地使用方式为在参数里面只加上待处理的数据的通道数(特征数量),但是有时候会在后面再加入一个小数,比如这样 nn.BatchNorm2d(64,0.8),这里面的0.8有什么作用呢...
  • 1.nn.BatchNorm1d(num_features) 1.对小批量(mini-batch)的2d或3d输入进行批标准化(Batch Normalization)操作 2.num_features: 来自期望输入的特征数,该期望输入的大小为'batch_size x num_features [x width...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,605
精华内容 5,442
关键字:

batchnorm2d