layernorm pytorch（batch norm和layer norm）

本文目录

• batch norm和layer norm
• pytorch模型压缩方法总结
• pytorch踩坑之model.eval()和model.train()输出差距很大
• 论文笔记-Learning to Simulate Complex Physics with Graph Networks图网络模拟器
• pytorch常用normalization函数
• 为什么layernorm在深度学习NLP下有效，batchnorm则不是
• pytorch-torch3:张量计算和连接
• pix2pix网络，Pytorch代码中， valid 和 fake 两个参数表示什么

batch norm和layer norm

***隐藏网址***

计算batch个μ和batch个σ

我以前一直以为是对seq轴上做类似于batch norm的操作，结果是hidden轴上。

例如，input是，则layer norm首先在hidden维度求出batch × seq_len个标准差和均值，再使用它们进行归一化，但γ和β只有hidden个，因此LayerNorm归一化之后的缩放是再特征维度上进行。

Batch Normalization，它去除了不同特征之间的大小关系，但是保留了不同样本间的大小关系，所以在CV领域用的多。
Layer Normalization，它去除了不同样本间的大小关系，但是保留了一个样本内不同特征之间的大小关系，所以在NLP领域用的多。

1）layer normalization 有助于得到一个球体空间中符合0均值1方差高斯分布的 embedding， batch normalization不具备这个功能。

pytorch模型压缩方法总结

一个是在channel粒度上做剪枝，另一个是在神经元Unit维度上做剪枝

1.torch.quantize_per_tensor()函数的scale和zero_point需要自己设定。
所谓动态是指这个函数torch.quantization.quantize_dynamic能自动选择最合适的scale和zero_point。

QuantStub使用的是HistogramObserver，根据输入从的分布，HistogramObserver计算得到min_val、max_val分别是-3、2.9971，而qmin和qmax又分别是0、127，其schema为per_tensor_affine，因此套用上面的per_tensor_affine逻辑可得：

Post Training Dynamic Quantization，简称为Dynamic Quantization，也就是动态量化，或者叫作Weight-only的量化，是提前把模型中某些op的参数量化为INT8，然后在运行的时候动态的把输入量化为INT8，然后在当前op输出的时候再把结果requantization回到float32类型。动态量化默认只适用于Linear以及RNN的变种。

当对整个模型进行转换时，默认只对以下的op进行转换：
Linear
LSTM
LSTMCell
RNNCell
GRUCell
为啥呢？因为dynamic quantization只是把权重参数进行量化，而这些layer一般参数数量很大，在整个模型中参数量占比极高，因此边际效益高。对其它layer进行dynamic quantization几乎没有实际的意义。

与其介绍post training static quantization是什么，我们不如先来说明下它和dynamic quantization的相同点和区别是什么。相同点就是，都是把网络的权重参数转从float32转换为int8；不同点是，需要把训练集或者和训练集分布类似的数据喂给模型（注意没有反向传播），然后通过每个op输入的分布特点来计算activation的量化参数（scale和zp）——称之为Calibrate（定标）。是的，静态量化包含有activation了，也就是post process，也就是op forward之后的后处理。为什么静态量化需要activation呢？因为静态量化的前向推理过程自(始+1)至(终-1)都是INT计算，activation需要确保一个op的输入符合下一个op的输入。

PyTorch会使用五部曲来完成模型的静态量化：

这一步不是训练。是为了获取数据的分布特点，来更好的计算activation的scale和zp。至少要喂上几百个迭代的数据，

per tensor 和 per channel。Per tensor 是说一个tensor里的所有value按照同一种方式去scale和offset； per channel是对于tensor的某一个维度（通常是channel的维度）上的值按照一种方式去scale和offset，也就是一个tensor里有多种不同的scale和offset的方式（组成一个vector），如此以来，在量化的时候相比per tensor的方式会引入更少的错误。PyTorch目前支持conv2d()、conv3d()、linear()的per channel量化。

pytorch踩坑之model.eval()和model.train()输出差距很大

问题描述:
本人使用pytorch1.5版本，构建EfficientNet网络，在训练之前使用model.train()设置为训练模式。每次训练结束后进行验证集的推理测试；对于含有dropout和batchnorm层的神经网络在推理前需要用model.eval()设置dropout和batchnorm的冻结。但是对于推理结果，不同的输入，具有相同的输出；错误率很高，并且loss值也于训练时差距巨大。
解决方法：
这个错误可能是由于在batchnorm中的动量（momentum）设置而导致。在进行推理时，设置较大的动量值可以解决这个问题。如下：
nn.BatchNorm2d(out_planes, eps=1e-3, momentum=1))

参考：
***隐藏网址***
***隐藏网址***
***隐藏网址***

论文笔记-Learning to Simulate Complex Physics with Graph Networks图网络模拟器

论文原文

在这里，我们提供了一个学习模拟的通用框架，并提供了一个单一模型的实现，该模型可在各种具有挑战性的物理领域（包括流体，刚性固体和可变形材料彼此相互作用）中产生最先进的性能。我们的框架（我们称为“基于图网络的模拟器”（GNS））表示带有粒子的物理系统的状态，表示为图中的节点，并通过学习的消息传递来计算动力学。我们的结果表明，我们的模型可以从训练期间包含数千个粒子状态的单一时间步长的预测，推广到不同的初始条件，数千个时间步长，以及在测试时至少增加一个数量级的粒子。我们的模型对于跨各种评估指标的超参数选择具有鲁棒性：长期表现的主要决定因素性能是消息传递步骤的数量，并通过用噪声破坏训练数据来减轻错误的累积。我们的GNS框架是迄今为止最准确的通用学习型物理模拟器，它有望解决各种复杂的正反问题。

复杂物理学的现实仿真器对许多科学和工程学科而言都是无价的，但是传统仿真器的创建和使用可能非常昂贵。 构建模拟器可能需要多年的工程工作，并且通常必须在狭窄的设置范围内牺牲通用性才能获得准确性。 高质量的模拟器需要大量的计算资源，因此需要扩展起来让人望而却步。 由于对基本物理和参数的了解不足或难以近似，即使最好的也常常是不准确的。 一种有吸引力的传统模拟器的替代方法是使用机器学习直接从观察到的数据中训练模拟器，但是对于大型的状态空间和复杂的动力学而言，标准的端到端学习方法很难克服。

在这里，我们提出了一个从数据中学习模拟的通用框架-“基于图形网络的模拟器”（GNS）。 我们的框架强加了归纳偏见，其中丰富的物理状态由相互作用粒子的图表示，而复杂的动力学则通过在节点之间学习到的消息传递来近似。

我们在一个深度学习架构中实现了GNS框架，发现它可以学习准确地模拟流体，刚性固体和可变形材料相互影响的各种物理系统。 我们的模型还可以很好地推广到比经过训练的系统更大的系统和更长的时间范围。 虽然以前的学习模拟方法高度专注于特定任务，但我们发现单个GNS模型在数十个实验中表现良好，并且通常对超参数选择具有鲁棒性。 我们的分析表明，性能是由以下几个关键因素决定的：其计算远程交互作用的能力，空间不变性的归因偏差以及可减轻长时间模拟轨迹上的误差累积的训练程序。

一般的可学习模拟

我们假设 是世界在时间t的状态。在K个时间步上应用物理动力学可得出状态轨迹， 。一个模拟器，s：X→ X, 通过将先前的状态映射到因果的未来状态来对动力学建模。 我们将模拟的“展开”轨迹表示为： ，它由 迭代计算 时间步长。 模拟器计算反映当前状态如何变化的动力学信息，并使用它来将当前状态更新为预测的未来状态。 一个例子是数值微分方程求解器：这些方程计算动力学信息，即时间导数，而积分器是更新机制。

一个可学习的模拟器 使用参数化函数近似器( )计算动力学信息，其参数可以针对某些训练目标进行优化。 表示动力学信息，其语义由更新机制确定。 可以将更新机制视为采用 的函数，并使用 来预测下一个状态，即 。 在这里，我们假设一个简单的更新机制（一个Euler积分器）和代表加速度的Y。 但是，也可以使用更复杂的更新程序，这些更新程序不止一次调用 ，例如高阶积分器。

模拟图上的消息传递

我们可学习的模拟方法采用物理系统的基于粒子的表示形式，即 ，其中N个粒子的每个xi表示其状态。物理动力学是通过粒子之间的相互作用来进行近似的，例如，在粒子之间进行能量和动量的交换。粒子间相互作用的建模方式决定了模拟方法的质量和普遍性，例如，可以模拟的效果和材料的类型，方法在哪种情况下效果良好或较差等。我们对学习这些相互作用感兴趣，从原则上讲，它应该允许学习任何系统的动力学可以表示为粒子动力学。因此至关重要的是，不同的 值应使 跨越很大范围的粒子间相互作用函数。

基于粒子的模拟可以看作是图形上的消息传递。节点对应于粒子，并且边缘对应于粒子之间的成对关系，在该关系上计算相互作用。我们可以在此框架中理解SPH之类的方法-节点之间传递的消息可能对应于使用密度内核评估压力。

我们利用基于粒子的模拟器与图上的消息传递之间的对应关系来定义基于GN的通用 。 我们的 分为三个步骤-编码器，处理器和解码器。

编码器定义 。 编码器： 将基于粒子的状态表示,X嵌入为潜图(latent graph), ，其中 ）。 节点嵌入 ，是粒子状态的学习函数。添加有向边以在具有某些潜在交互作用的粒子节点之间创建路径。边缘嵌入 是相应粒子ri; j的成对属性的学习函数，例如，它们的位置之间的位移，弹簧常数等。图形级嵌入 可以表示诸如重力和磁场之类的全局属性（ 尽管在我们的实现中，我们只是将它们附加为输入节点功能）。

处理器定义 。 处理器： 通过M个学习的消息传递步骤来计算节点之间的交互，以生成一系列更新的潜图(latent graph) ）。 它返回最终图形 。 消息传递允许信息传播并遵守约束：所需的消息传递步骤数可能会随着交互的复杂性而扩展。

解码器定义 。 解码器： 从最终潜图的节点 )。 学习 应该使 表示反映相关的动力学信息，例如加速度，以便在语义上对更新过程有意义。

输入和输出表示 。 每个粒子的输入状态向量分别代表位置， 的先前速度序列，并具有捕获静态材料特性（例如，水，沙，团，刚性，边界粒子）的特征， 。 如果适用，系统的整体特性g包括外力和整体材料特性。 监督学习的预测目标是每粒子平均加速度 。 请注意，在我们的数据集中，我们只需要 向量：使用有限差分从 计算出 和 。

编码器详细信息 。 ENCODER通过为每个粒子分配一个节点并在“连接半径” R内的粒子之间添加边来构造图形结构G0，该半径反映了粒子的局部相互作用，并且对于相同分辨率的所有模拟均保持不变。 为了生成卷展栏，在每个时间步上，图形的边缘都由最近的邻居算法重新计算，以反映当前粒子的位置。

ENCODER将 和 实现为多层感知器（MLP），它们将节点特征和边缘特征编码为大小为128的潜在向量 和 。

我们测试了两种ENCODER变体，以其使用绝对位置还是相对位置信息来区分。 对于绝对变量， 的输入是上述的xi，并带有全局特征。 的输入，即ri; j实际上没有携带任何信息，因此被丢弃，其中 为 设置为可训练的固定偏差矢量。 相对的ENCODER变体旨在对绝对空间位置施加不变的归纳偏差。 被迫通过遮蔽来忽略xi内的pi信息。 被提供了相对位置位移，其大小为 。 两种变体都将全局属性g连接到每个xi上，然后传递给“ 。

处理器详细信息 。 我们的处理器使用具有相同结构的MGN（其中M为超参数）堆栈，作为内部边缘和节点更新功能的MLP，以及共享或不共享的参数。 我们使用没有全局功能或全局更新（类似于交互网络）的GN，并且在输入和输出潜在节点与边属性之间存在残余连接。

解码器详细信息 。 我们解码器的学习函数 ,是MLP。 在DECODER之后，使用Euler积分器更新将来的位置和速度，因此 对应于加速度 ，具有2D或**尺寸，具体取决于物理域。 如上所述，监督训练目标只是这些 向量。

神经网络参数化 。 所有MLP都有两个隐藏层（具有ReLU激活），其后是一个未激活的输出层，每个层的大小为128。所有MLP（输出解码器除外）之后是LayerNorm（层。 我们通常发现训练稳定性得到了改善。

软件 。 我们使用TensorFlow 1，Sonnet 1和“ Graph Nets”库实施了模型。

训练噪声 。 对复杂而混乱的仿真系统进行建模需要模型减轻长时间部署时的错误累积。 因为我们在基本事实单步数据上训练我们的模型，所以永远不会为它们提供被此类累积噪声破坏的输入数据。 这意味着，当我们通过向模型提供自己的噪声，先前的预测作为输入来生成推广时，其输入不在训练分布范围内这一事实可能导致其产生更大的误差，从而迅速累积进一步的误差。 我们使用一种简单的方法使模型对嘈杂的输入更具鲁棒性：在训练过程中，我们以随机行走噪声 破坏模型的输入位置和速度，因此训练分布更加 与推出期间产生的分布相似。

正则化 。我们使用训练期间在线计算的统计数据，将所有输入和目标向量的元素归一化为零均值和单位方差。初步实验表明，归一化可加快训练速度，但融合性能并未得到明显改善。

损失函数和优化程序 。我们从训练轨迹中随机采样粒子状态对 ，计算目标加速度 ，并根据预测的每个粒子加速度计算L2损失，即 。我们使用最小批量大小2，使用Adam优化器针对这种损失优化了模型参数 。我们最多执行了20M梯度更新步骤，指数学习速率从 下降到 。尽管模型可以以更少的步骤进行训练，但我们避免使用过高的学习率来减少数据集之间的差异，并使设置之间的比较更加公平。

我们在训练过程中通过在5个保持不变的验证轨迹上进行全长展示来定期评估我们的模型，并记录了相关的模型参数以获得最佳展示MSE。当我们观察到MSE的下降幅度可忽略不计时，我们停止了训练，在GPU / TPU硬件上，对于较小，较简单的数据集，MSE通常在几个小时内；对于较大，更复杂的数据集，则长达一周。

***隐藏网址***

pytorch常用normalization函数

将输入的图像shape记为，这几个方法主要的区别就是在，
batchNorm是在batch上，对NHW做归一化，对小batchsize效果不好；
layerNorm在通道方向上，对CHW归一化，主要对RNN作用明显；
instanceNorm在图像像素上，对HW做归一化，用在风格化迁移；
GroupNorm将channel分组，然后再做归一化；
SwitchableNorm是将BN、LN、IN结合，赋予权重，让网络自己去学习归一化层应该使用什么方法。

归一化与反归一化
***隐藏网址***

pytorch优雅的反归一化
***隐藏网址***

重点关注

图片保存：torchvision.utils.save_image(img, imgPath)
***隐藏网址***

为什么layernorm在深度学习NLP下有效，batchnorm则不是

Layer normalization (layernorm) 和 batch normalization (batchnorm) 都是用来解决神经网络训练时的梯度**和消失问题的一种技术。在这两种方法中，layernorm 通常更适合在深度学习中自然语言处理（NLP）的任务中使用。这是因为，在 NLP 任务中，每个样本的长度通常都不一样，因此使用 layernorm 来对每个神经元的输入进行标准化（即，使输入的均值为0，方差为1）可能更有效。而在使用 batchnorm 时，由于每个 mini-batch 中的样本数量通常是固定的，因此如果在 NLP 任务中使用 batchnorm 的话，那么就会有一些样本会被忽略，从而导致效果不佳。

pytorch-torch3:张量计算和连接

torch.cat(seq,dim=0,out=None)-》Tensor
在给定维度上对输入张量序列seq进行连接操作由这可以想到卷积神经网络
的全连接层
torch.cat() 可以看做 torch.split() 和 torch.chunk() 的逆运算

torch.chunk(tensor,chunks,dim)-》》tensors
将张量沿给定维度分块

torch.gather(input,dim,index,out=None,sparse_grad=Flase,out=None)-》Tensor

通俗点解释就是把指定索引dim的下标进行替换

torch.index_select(input,dim,index,out=None)-》》Tensor

torch.masked_select(input,mask,out=None)-》》Tensor
根据mask输出一个一维张量

torch.split(tensor,split_size,dim=0)-》》tensor
如果可分,张量沿着指定维度指定大小进行分割,直到大小不足则停止

torch.t(input,out=None)-》Tensor
张量转置相当于
torch.transpose(input,o,1)

torch.bernoulli(input,out=None)

从伯努利分布中抽取二元随机数(0或者1)这里的bernoulli概率p是随机的
输入张量值需是一个概率

torch.multinomial(input,num_samples,replacement=Flase,out=None)-》》LongTensor
从输入张量中每行取num_samples个样本,可以设置replacement设置是否重复取值
返回取值的下标

torch.normal(means,std,out)-》》tensor
按照指定均值和方差选取样本,均值个数决定样本个数
若均值和方差都为张量则两个张量元素个数必须相等

torch.abs(input,out)-》tensor 输出张量元素绝对值

torch.acos(input,out) 求反余弦

torch.add(input,value,out) 对每个张量元素逐个加上value

torch.addcdiv(tensor,value=1,tensor1,tensor2) 张量(tensor1/tensor2)*value+tensor

torch.addmul 相乘相加

torch.ceil(input,out) 向上取整

torch.clamp(input,min,max,out=None)
将元素调整至区间

torch.div(input,value) 除

torch.exp(tensor,out) 指数

torch.floor(input,out) 向下去整

torch.fmod(input,divisor,out) 取余数

torch.frac 取分数部分

torch.lerp(start, end, weight, out=None)
线性插值:out = start+weight*(end-start)

torch.log 取自然对数

torch.mul(input, value, out=None)

torch.mul(input, other, out=None) 哈达玛积

torch.neg 取复数

torch.pow(input, exponent, out=None) 求幂

torch.reciprocal(input, out=None) → Tensor 去倒数

torch.remainder(input, divisor, out=None) → Tensor 取余数

torch.rsqrt(input, out=None) → Tensor 平方根倒数

torch.sigmoid(input, out=None) → Tensor sigmoid值

torch.sigmoid(input, out=None) → Tensor 符号函数

torch.cumprod(input, dim, out=None) → Tensor 按指定维度累积

torch.cumsum(input, dim, out=None) → Tensor 指定维度累加

torch.dist(input, other, p=2, out=None) → Tensor 求P范数

torch.mean(input) → float 均值

torch.mean(input, dim, out=None) → Tensor 指定维度均值

torch.median(input, dim=-1, values=None, indices=None) -》 (Tensor, LongTensor) 指定维度中位数

torch.mode(input, dim=-1, values=None, indices=None) -》 (Tensor, LongTensor) 众数

torch.norm(input, p, dim, out=None) → Tensor 指定维度p范数

torch.prod(input) → float 所有积

torch.prod(input, dim, out=None) → Tensor 指定维度积

torch.std(input, dim, out=None) → Tensor 标准差

torch.sum(input, dim, out=None) → Tensor 按维度求和

torch.sum(input) → float 所有元素和

var 按行方差，所有元素方差

torch.eq(input, other, out=None) → Tensor 相等比较操作 返回01

torch.equal(tensor1, tensor2) → bool 张量比较shape and value返回bool

torch.ge(input, other, out=None) → Tensor 大于

torch.gt(input, other, out=None) → Tensor 与equal类似返回不同

torch.kthvalue(input, k, dim=None, out=None) -》 (Tensor, LongTensor) 取指定维度最小值

torch.le(input, other, out=None) → Tensor 小于等于

torch.lt(input, other, out=None) → Tensor 小于

torch.max(input, dim, max=None, max_indices=None) -》 (Tensor, LongTensor) 返回指定维度最大值和索引

pix2pix网络，Pytorch代码中， valid 和 fake 两个参数表示什么

class UNetDown(nn.Module):
def __init__(self, in_size, out_size, normalize=True, dropout=0.0):
super(UNetDown, self).__init__()
layers =
if normalize:
layers.append(nn.InstanceNorm2d(out_size))
layers.append(nn.LeakyReLU(0.2))
if dropout:
layers.append(nn.Dropout(dropout))
self.model = nn.Sequential(*layers)
def forward(self, x):
return self.model(x)
class UNetUp(nn.Module):
def __init__(self, in_size, out_size, dropout=0.0):
super(UNetUp, self).__init__()
layers = [ nn.ConvTranspose2d(in_size, out_size, 4, 2, 1, bias=False),
nn.InstanceNorm2d(out_size),
nn.ReLU(inplace=True)]
if dropout:
layers.append(nn.Dropout(dropout))
self.model = nn.Sequential(*layers)
def forward(self, x, skip_input):
x = self.model(x)
x = torch.cat((x, skip_input), 1)
return x
class GeneratorUNet(nn.Module):
def __init__(self, in_channels=3, out_channels=3):
super(GeneratorUNet, self).__init__()
self.down1 = UNetDown(in_channels, 64, normalize=False)
self.down2 = UNetDown(64, 128)
self.down3 = UNetDown(128, 256)
self.down4 = UNetDown(256, 512, dropout=0.5)
self.down5 = UNetDown(512, 512, dropout=0.5)
self.down6 = UNetDown(512, 512, dropout=0.5)
self.down7 = UNetDown(512, 512, dropout=0.5)
self.down8 = UNetDown(512, 512, normalize=False, dropout=0.5)
self.up1 = UNetUp(512, 512, dropout=0.5)
self.up2 = UNetUp(1024, 512, dropout=0.5)
self.up3 = UNetUp(1024, 512, dropout=0.5)
self.up4 = UNetUp(1024, 512, dropout=0.5)
self.up5 = UNetUp(1024, 256)
self.up6 = UNetUp(512, 128)
self.up7 = UNetUp(256, 64)
self.final = nn.Sequential(
nn.Upsample(scale_factor=2),
nn.ZeroPad2d((1, 0, 1, 0)),
nn.Conv2d(128, out_channels, 4, padding=1),
nn.Tanh()
)
def forward(self, x):
# U-Net generator with skip connecti*** from encoder to decoder
d1 = self.down1(x)
d2 = self.down2(d1)
d3 = self.down3(d2)
d4 = self.down4(d3)
d5 = self.down5(d4)
d6 = self.down6(d5)
d7 = self.down7(d6)
d8 = self.down8(d7)
u1 = self.up1(d8, d7)
u2 = self.up2(u1, d6)
u3 = self.up3(u2, d5)
u4 = self.up4(u3, d4)
u5 = self.up5(u4, d3)
u6 = self.up6(u5, d2)
u7 = self.up7(u6, d1)
return self.final(u7)
---------------------