标签: batch-normalization

我是DL和Keras的新手.目前我尝试实现类似Unet的CNN,现在我想将批量规范化层包含到我的非顺序模型中,但现在还没有.

这是我目前尝试包含它:

input_1 = Input((X_train.shape[1],X_train.shape[2], X_train.shape[3]))

conv1 = Conv2D(16, (3,3), strides=(2,2), activation='relu', padding='same')(input_1)
batch1 = BatchNormalization(axis=3)(conv1)
conv2 = Conv2D(32, (3,3), strides=(2,2), activation='relu', padding='same')(batch1)
batch2 = BatchNormalization(axis=3)(conv2)
conv3 = Conv2D(64, (3,3), strides=(2,2), activation='relu', padding='same')(batch2)
batch3 = BatchNormalization(axis=3)(conv3)
conv4 = Conv2D(128, (3,3), strides=(2,2), activation='relu', padding='same')(batch3)
batch4 = BatchNormalization(axis=3)(conv4)
conv5 = Conv2D(256, (3,3), strides=(2,2), activation='relu', padding='same')(batch4)
batch5 = BatchNormalization(axis=3)(conv5)
conv6 = Conv2D(512, (3,3), strides=(2,2), activation='relu', padding='same')(batch5)
drop1 = Dropout(0.25)(conv6)

upconv1 = Conv2DTranspose(256, (3,3), strides=(1,1), padding='same')(drop1)
upconv2 = Conv2DTranspose(128, (3,3), strides=(2,2), padding='same')(upconv1)
upconv3 = …

我对BatchNorm(后来的BN)的理解有疑问.

我有一个很好的工作,我正在编写测试来检查形状和输出范围.我注意到当我设置batch_size = 1时,我的模型输出零(logits和激活).

我用BN制作了最简单的节目原型:

输入=> Conv + ReLU => BN => Conv + ReLU => BN => Conv Layer + Tanh

使用xavier初始化初始化模型.我猜测训练期间的 BN 做了一些需要Batch_size> 1的计算.

我在PyTorch中发现了一个似乎在谈论这个问题:https://github.com/pytorch/pytorch/issues/1381

有人能解释一下吗？它对我来说仍然有点模糊.

示例运行:

重要说明:此脚本需要运行Tensorlayer Library:pip install tensorlayer

import tensorflow as tf
import tensorlayer as tl

import numpy as np

def conv_net(inputs, is_training):

    xavier_initilizer = tf.contrib.layers.xavier_initializer(uniform=True)
    normal_initializer = tf.random_normal_initializer(mean=1., stddev=0.02)

    # Input Layers
    network = tl.layers.InputLayer(inputs, name='input')

    fx = [64, 128, 256, 256, 256]

    for i, n_out_channel …

我使用TensorFlow训练DNN。我了解到批处理规范化对DNN很有帮助，因此我在DNN中使用了它。

我使用“ tf.layers.batch_normalization”并按照API文档的说明构建网络：训练时，将其参数设置为“ training = True ”，验证时，将其设置为“ training = False ”。并添加tf.get_collection（tf.GraphKeys.UPDATE_OPS）。

这是我的代码：

# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np

input_node_num=257*7
output_node_num=257

tf_X = tf.placeholder(tf.float32,[None,input_node_num])
tf_Y = tf.placeholder(tf.float32,[None,output_node_num])
dropout_rate=tf.placeholder(tf.float32)
flag_training=tf.placeholder(tf.bool)
hid_node_num=2048

h1=tf.contrib.layers.fully_connected(tf_X, hid_node_num, activation_fn=None)
h1_2=tf.nn.relu(tf.layers.batch_normalization(h1,training=flag_training))
h1_3=tf.nn.dropout(h1_2,dropout_rate)

h2=tf.contrib.layers.fully_connected(h1_3, hid_node_num, activation_fn=None)
h2_2=tf.nn.relu(tf.layers.batch_normalization(h2,training=flag_training))
h2_3=tf.nn.dropout(h2_2,dropout_rate)

h3=tf.contrib.layers.fully_connected(h2_3, hid_node_num, activation_fn=None)
h3_2=tf.nn.relu(tf.layers.batch_normalization(h3,training=flag_training))
h3_3=tf.nn.dropout(h3_2,dropout_rate)

tf_Y_pre=tf.contrib.layers.fully_connected(h3_3, output_node_num, activation_fn=None)

loss=tf.reduce_mean(tf.square(tf_Y-tf_Y_pre))

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
    train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for i1 in range(3000*num_batch):
        train_feature=... # …

作为一个没有强大统计背景的人,有人可以向我解释批量重整化旨在解决的批量标准化的主要限制,特别是在它与批量标准化的区别方面吗？

我正在尝试制作一个简单的GAN，以从MNIST数据集生成数字。但是，当我开始接受培训时（这是自定义的），我会得到这个烦人的警告，我怀疑这是我不习惯的原因造成的。

请记住，使用默认的急切执行，这一切都在tensorflow 2.0中。

获取数据（不是那么重要）

(train_images,train_labels),(test_images,test_labels) = tf.keras.datasets.mnist.load_data()

train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5 # Normalize the images to [-1, 1]

BUFFER_SIZE = 60000
BATCH_SIZE = 256

train_dataset = tf.data.Dataset.from_tensor_slices((train_images,train_labels)).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

生成器模型（这是批处理归一化的位置）

def make_generator_model():
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
    model.add(tf.keras.layers.BatchNormalization())
    model.add(tf.keras.layers.LeakyReLU())

    model.add(tf.keras.layers.Reshape((7, 7, 256)))
    assert model.output_shape == (None, 7, 7, 256) # Note: None is the batch size

    model.add(tf.keras.layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    assert model.output_shape == (None, 7, 7, 128)  
    model.add(tf.keras.layers.BatchNormalization())
    model.add(tf.keras.layers.LeakyReLU()) …

当我使用批量标准化但设置时会发生什么batch_size = 1？

因为我使用 3D 医学图像作为训练数据集，由于 GPU 限制，batch size 只能设置为 1。通常，我知道，当 时batch_size = 1，方差将为 0。并且(x-mean)/variance会因除以0 而导致错误。

但是为什么我设置的时候没有出现错误batch_size = 1呢？为什么我的网络训练得和我预期的一样好？有人能解释一下吗？

有人认为：

ZeroDivisionError由于两种情况，可能不会遇到 。首先，异常在trycatch 块中被捕获。其次，1e-19在方差项中添加一个小的有理数 ( )，使其永远不会为零。

但也有人不同意。他们说：

您应该计算批次图像中所有像素的均值和标准差。（所以即使batch_size = 1，batch中仍然有很多像素。所以batch_size=1仍然可以工作的原因不是因为1e-19）

我查过Pytorch的源码，从代码上我觉得后一种是对的。

有人有不同意见吗？？？

我想知道我可以从running_mean和处running_var拨打电话nn.BatchNorm2d。

示例代码在这里，其中 bn 表示nn.BatchNorm2d。

vector = torch.cat([
    torch.mean(self.conv3.bn.running_mean).view(1), torch.std(self.conv3.bn.running_mean).view(1),
    torch.mean(self.conv3.bn.running_var).view(1), torch.std(self.conv3.bn.running_var).view(1),
    torch.mean(self.conv5.bn.running_mean).view(1), torch.std(self.conv5.bn.running_mean).view(1),
    torch.mean(self.conv5.bn.running_var).view(1), torch.std(self.conv5.bn.running_var).view(1)
])

我无法弄清楚Pytorch 官方文档和用户社区中的running_mean和是什么意思。running_var

nn.BatchNorm2.running_mean和是什么nn.BatchNorm2.running_var意思？

考虑以下代码片段

model = models.Sequential()
model.add(layers.Dense(256, activation='relu'))     # Layer 1
model.add(BatchNormalization())
model.add(layers.Dense(128, activation='relu'))     # Layer 2

我正在使用带有 Tensorflow 后端的 Keras。

我的问题是 - 在 Keras 的实现中，BN 是在激活函数之前还是之后执行？

为了增加清晰度，

1. BN 应该在激活之前还是之后应用存在争议，原始（Ioffe 和 Szegedy 2015）论文建议“之前”，但来自以下线程的评论显示了不同的意见。 批量标准化和辍学的顺序？

2. 在 Keras 文档 ( https://keras.io/layers/normalization/ ) 中，它说“标准化每批上一层的激活，即应用保持平均激活接近 0 和激活标准偏差接近的转换到 1。”

Keras 的文档似乎表明 BN 在激活后应用（即在上面的示例代码中，BN 在第 1 层上的“relu”之后应用）。我想确认是否是这种情况？

另外，是否可以配置BN是在激活函数之前还是之后应用？

谢谢！

我正在使用 PyTorch 来实现基于骨架的动作识别的分类网络。该模型由三个卷积层和两个全连接层组成。这个基本模型在 NTU-RGB+D 数据集中给了我大约 70% 的准确率。我想了解更多关于批量归一化的知识，所以我为除最后一层之外的所有层添加了批量归一化。令我惊讶的是，评估准确率下降到了 60% 而不是提高，但训练准确率却从 80% 提高到了 90%。谁能说我做错了什么？或者添加批量标准化不需要提高准确性？

批量归一化模型

class BaseModelV0p2(nn.Module):

    def __init__(self, num_person, num_joint, num_class, num_coords):
        super().__init__()
        self.name = 'BaseModelV0p2'
        self.num_person = num_person
        self.num_joint = num_joint
        self.num_class = num_class
        self.channels = num_coords
        self.out_channel = [32, 64, 128]
        self.loss = loss
        self.metric = metric
        self.bn_momentum = 0.01

        self.bn_cv1 = nn.BatchNorm2d(self.out_channel[0], momentum=self.bn_momentum)
        self.conv1 = nn.Sequential(nn.Conv2d(in_channels=self.channels, out_channels=self.out_channel[0],
                                             kernel_size=3, stride=1, padding=1),
                                   self.bn_cv1,
                                    nn.ReLU(),
                                    nn.MaxPool2d(kernel_size=2, stride=2))

        self.bn_cv2 = nn.BatchNorm2d(self.out_channel[1], momentum=self.bn_momentum)
        self.conv2 = nn.Sequential(nn.Conv2d(in_channels=self.out_channel[0], out_channels=self.out_channel[1],
                                            kernel_size=3, stride=1, padding=1),
                                   self.bn_cv2,
                                nn.ReLU(),
                                nn.MaxPool2d(kernel_size=2, …

以下内容来自Keras教程

此行为已在 TensorFlow 2.0 中引入，目的是使 layer.trainable = False 能够在 convnet 微调用例中产生最常见的预期行为。

为什么在微调卷积神经网络时要冻结层？是因为tensorflow keras中的某些机制还是因为批量归一化的算法？我自己进行了一个实验，我发现如果 trainable 没有设置为 false，模型往往会灾难性地忘记之前学到的东西，并在最初的几个时期返回非常大的损失。这是什么原因？

我在使用BatchNorm1d时遇到错误，代码：

##% first I set a model\nclass net(nn.Module):\n    def __init__(self, max_len, feature_linear, rnn, input_size, hidden_size, output_dim, num__rnn_layers, bidirectional, batch_first=True, p=0.2):\n        super(net, self).__init__()\n        self.max_len = max_len\n        self.feature_linear = feature_linear\n        self.input_size = input_size\n        self.hidden_size = hidden_size\n        self.bidirectional = bidirectional\n        self.num_directions = 2 if bidirectional == True else 1\n        self.p = p\n        self.batch_first = batch_first\n        self.linear1 = nn.Linear(max_len, feature_linear) \n        init.kaiming_normal_(self.linear1.weight, mode='fan_in')\n        self.BN1 = BN(feature_linear) \n        \n    def forward(self, xb, seq_len_crt):\n        rnn_input = torch.zeros(xb.shape[0], self.feature_linear, self.input_size)\n        for i in range(self.input_size): \n            out …

尝试训练一个 Robust CNN 模型，其定义如下：

from keras.datasets import cifar10
from keras.utils import np_utils
from keras import metrics
from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D, LSTM, merge
from keras.layers import BatchNormalization
from keras import metrics
from keras.losses import categorical_crossentropy
from keras.optimizers import SGD
import pickle
import matplotlib.pyplot as plt
import numpy as np 
from keras.preprocessing.image import ImageDataGenerator
from keras import layers
from keras.callbacks import EarlyStopping



def Robust_CNN():
    
    model = Sequential()
    model.add(Conv2D(256, (3, 3), activation='relu', padding='same', init='glorot_uniform', input_shape=(2,128,1)))
    model.add(BatchNormalization()) …

火炬\xef\xbc\x9a\'1.9.0+cu111\'

Tensorflow-gpu\xef\xbc\x9a\'2.5.0\'

我遇到一个奇怪的事情，当使用tensorflow 2.5的Batch Normal层和Pytorch 1.9的BatchNorm2d层计算相同的Tensor时，结果有很大不同（TensorFlow接近1，Pytorch接近0）。我一开始以为是动量和epsilon的区别，但是把它们改成相同后，结果是一样的。

from torch import nn\nimport torch\nx = torch.ones((20, 100, 35, 45))\na = nn.Sequential(\n            # nn.Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), padding=0, bias=True),\n            nn.BatchNorm2d(100)\n        )\nb = a(x)\n\nimport tensorflow as tf\nimport tensorflow.keras as keras\nfrom tensorflow.keras.layers import *\nx = tf.ones((20, 35, 45, 100))\na = keras.models.Sequential([\n            # Conv2D(128, (1, 1), (1, 1), padding=\'same\', use_bias=True),\n            BatchNormalization()\n        ])\nb = a(x)\n