pytorch学习总结

import torch.nn as nn

import torch

nn.sequential()

作用：用来简化代码。sequential对象以顺序方式运行其中包含的每个模块。

nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’, device=None, dtype=None)

作用：进行卷积操作。
参数：
in_channels（输入图片通道数）、
out_channels（输出图片通道数）、
kernel_size（filter的尺寸）、
stride（卷积步长）、
padding（原始图像周围填充的像素点个数，参数可以是valid、same）、dilation（用于控制内核点之间的距离）、
groups（控制输入与输出之间的连接），=1，输出是所有输入的卷积；=2，相当于有并排的两个卷积层，每个卷积层计算输入通道的一半，并且产生的输出是输出通道的一半，随后将这两个输出连接起来；
bias（偏置项），boolean类型，true表示添加偏置；？
参考
卷积、反卷积、扩张卷积animations

nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)

作用：对小批量（min-batch）3d数据组成的4d输入进行标准化（Batch Normalization）操作
参数：
num_features：期望输入的特征数
eps：为保证数据稳定性（分母不能趋近或取0），给分母加的值，有默认值
momentum：动态均值和动态方差所使用的动量。
参考

nn.ReLU（inplace=False）

作用：对输入运用修正线性单元函数
参数：
inplace：选择是否进行覆盖运算。
参考

nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

作用：对于输入信号的通道数，提供2维最大池化（max pooling）操作。
参数：
return_indices：等于true，会返回输出最大值的序列，对于上采样操作会有帮助；
ceil_mode：等于true，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作。
输入输出：（N,C,Hin,Win）（N,C,Hout,Wout）
改变图像高和宽，
参考

nn.Linear(in_features, out_features, bias=True)

作用：对输入数据做线性变换：y = Ax+b
参数：
in_features：每个输入样本的大小
out_features：每个输出样本的大小
bias：设置为false，这层不会学习偏置，默认值是true
形状：
输入:（N,in_features）
输出：(N,out_features)

nn.sigmoid()

作用：对每个元素用sigmoid函数。
形状：
输入：(N,*),表示任意维度组合
输出：(N,)，与输入有相同的shape属性

torch.cat(inputs,dimension=0)

作用：在给定维度上对输入的张量序列seq进行连接操作
参数：
inputs（sequence of Tensor）：可以是任意先相同Tensor类型的python序列
dimension（int，optional）：沿着此维连接张量序列。

x = torch.randn（2,3）
x.shape 输出 (2,3)
y = torch.cat((x,x,x),0)
y.shape 输出（6,3）按行连接张量序列
z = torch.cat((x,x,x),1)
z.shape 输出（2,9） 按列连接张量序列

tensor.view(*args)

作用：返回一个有相同数据但大小不同的tensor，即返回的tensor必须与原tensor具有相同的数据和相同数目的元素，但可以有不同的大小。
参数：
*args：出现-1，表示这一维需要通过别的dimension推出来。
参考

torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

作用：返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。
输出形状中，将dim维设定为1，其它与输入形状保持一致。
参数：
input（Tensor）：输入张量
dim（int）：指定维度
结果：
Tensor：结果张量，包含给定维度上的最大值。
LongTensor：结果张量，包含给定维度上每个最大值的位置索引。
参考

torch.mean(input, dim, out=None) → Tensor

作用：返回输入张量给定维度dim上每行的均值。
参数：
input（Tensor）：输入张量
dim（int）：指定维度
输出：结果张量。

模型.eval()

作用：

• 将模型设置成evaluation模式（测试模式），不会更新k/b（权重、偏置）模型参数。
• 通知dropout层和batchnorm层在train和val中间进行切换。

模式	dropout层	batchnorm层
train模式	会按照设定的参数p设置保留激活单元的概率（保留概率=p，例如keep_prob=0.8）	会继续计算数据的mean和var（均值和方差）并进行更新
val模式	会让所有的激活单元都通过	会停止计算和更新mean和var，直接使用在训练阶段已经学出的mean和var值

• 不会影响各层的gradient计算行为，即gradient计算和存储与training模式一样，只是不进行反向传播（backprobagation）

仅仅当模型中有Dropout和BatchNorm时才会有影响
等价于模型.train（False）模式。

totch.no_gard（）

作用：用于停止autogard模块的工作，起到加速和节省显存的作用；
不会影响dropout和batchnorm层的行为；

with torch.no_grad()

解释：
使用pytorch时，并不是所有的操作都需要进行计算图的生成（=计算过程的构建，用于梯度反向传播等操作）。
对于tensor的计算操作，默认是要进行计算图的构建的，在这种情况下，可以使用 with torch.no_grad():，强制之后的内容不进行计算图构建。
例子：

使用with torch.no_gard：
网络的预测结果tensor是没有属性的；
未使用：
网络的预测结果tensor有grad_fn=<AddmmBackward>属性，表示，计算的结果在一计算图当中，可以进行梯度反转等操作。

相当于一个修饰器：它的作用是为已经存在的对象添加额外的功能。

模型.cuda(device_id = None)

作用：将所有的模型参数（parameter）和buffers赋值GPU
参数：
device_id（int）：如果指定的话，所有的模型参数都会复制到指定的设备上。

torch.randn（*size,out=None）→Tensor

作用：返回一个张量，包含了从标准正态分布（均值为0，方差为1，即高斯白噪声）中抽取一组随机数，形状由可变参数sizes定义。
参数：
size（int…）：整数序列，定义了输出形状
out（Tensor，optional）：结果张量
参考

torch.nn.MSELoss(size_average = True)

作用：创建一个衡量输入y hat（模型预测输出）和y（标签）之间均方误差标准。
参数：
size_average = False，求出来的平方和将不会除以n（y hat 和 y，每个包含n个元素）

torch.nn.DataParallel(module, device_ids=None, output_device=None, dim=0)

作用：在模块级别上实现数据并行。
解释：

1. 此容器通过将mini-batch划分到不同的设备上来实现给定module的并行。在forward过程中，module会在每个设备上都复制一遍，每个副本都会处理部分输入。在backward过程中，副本上的梯度会累加到原始module上。
2. batch的大小应该大于所使用的GPU的数量，还应当是GPU个数的整数倍，这样划分出来的每一块都会有相同的样本数量。（理解：假设GPU是4个，那么batch的大小4x）。
3. 除了Tensor，任何位置参数和关键字参数都可以传到DataParallel中。所有的变量会通过指定的dim来划分（默认值为0）。
4. 原始类型将会被广播，但是所有的其它类型都会被浅复制。所以如果在模型的forward过程中写入的话，将会被损坏。
   参数：
   module：要被并行的module
   device_ids：CUDA设备，默认为所有设备
   output_device：输出设备，默认为device_ids[0]
   参考

module.load_state_dict（state_dict）

作用：将state_dict中的parameters和buffers复制到此module和它的后代中。
参数：
state_dict中的key必须和 model.state_dict()返回的key一致。 NOTE：用来加载模型参数。
state_dict (dict) ：保存parameters和persistent buffers的字典
参考

module.state_dict()

作用：返回一个字典，保存着module的所有状态（state）。
解释：
parameters和persistent buffers都会包含在字典中，字典的key就是parameter和buffer的 names。

torch.load(f, map_location=None, pickle_module=<module ‘pickle’ from ‘/home/jenkins/miniconda/lib/python3.5/pickle.py’>)

作用：从磁盘文件中读取一个通过torch.save()保存的对象。

torch.load() 可通过参数map_location 动态地进行内存重映射，使其能从不动设备中读取文件。一般调用时，需两个参数: storage 和 location tag. 返回不同地址中的storage，或着返回None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话，意味着其是从文件的地址标记到当前系统的地址标记的映射。 默认情况下， location tags中 "cpu"对应host tensors，‘cuda:device_id’ (e.g. ‘cuda:2’) 对应cuda tensors。 用户可以通过register_package进行扩展，使用自己定义的标记和反序列化方法。

from torch.utils.data import Dataset

torch.utils.data.Dataset是代表数据集的抽象类。 您的自定义数据集应继承Dataset并覆盖以下方法：

len，以便 len(dataset)返回数据集的大小。
__getitem__支持索引，以便可以使用dataset[i]获取第 个样本

loss_fuction.item()

作用：返回的是一个浮点型数据。
在求loss或者accuracy时，一般使用item()，而不是直接取它对应的值。

import torchvision.transforms as transforms

介绍：torchvision是pytorch的一个图形库，它服务于PyTorch深度学习框架的，主要用来构建计算机视觉模型。torchvision.transforms主要是用于常见的一些图形变换。
以下是torchvision的构成：
torchvision.datasets：一些加载数据的函数及常用的数据集接口;
torchvision.models：包含常用的模型结构(含预训练模型)，例如AlexNet、 VGG、 ResNet等;
torchvision.transforms：常用的图片变换，例如裁剪、旋转等;
torchvision.utils：其他的一些有用的方法。

torchvision.transforms.Compose(transform)类

作用：主要作用是串联多个图片变换的操作。
参数：transforms：就是一个列表，里面的元素是要执行的transform操作。
具体执行：Compose()类会将transforms列表里面的transform操作进行遍历。

torchvision.transforms.Resize（size，interpolation=2）

作用：把给定的图片resize到given size。
参数：
size(sequence 或者 int)：需要输出的图片的大小。如果size是类似于(h,w)的序列，输出的尺寸将会跟(h,w)一致。如果size是整型，图片较小的边界将会被置为这个尺寸。例如，如果height->width, 图片将会被置为 (size*height/width, size)
Interpolation (int, 可选)：默认为 PIL.Image.BILINEAR

torchvision.transforms.ToTensor（）

作用：将PIL图片或者numpy.ndarray转成Tensor类型的、将PIL图片或者numpy.ndarray(HxWxC) (范围在0-255) 转成torch.FloatTensor (CxHxW) (范围为0.0-1.0)
参考

torch.nn.AdaptiveAvgPool2d(output_size)

作用：对输入信号，提供2维的自适应平均池化操作。
对于任何输入大小的输入，可以将输出尺寸指定为HW，也可以用单个数字H（表示输出的尺寸是HH），但是输入和输出特征的数目不会变化。

torch.unsqueeze(input,dim,out=None)

作用：返回一个新的张量，对输入的制定位置插入维度 1。
注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
如果dim为负，则将会被转化dim+input.dim()+1
参考

tensor.squeeze(dim)

作用: 如果dim指定的维度的值为1，则将该维度删除，若指定的维度值不为1，则返回原来的tensor。
参数：dim表示指定的维度数。

tensor.unsqueeze（dim）

作用：主要是对数据维度进行扩充，给指定位置加上维数为1的维度。
参数：dim表示指定的维度数。

tensor_new.expand_as（tensor）

作用：将tensor_new扩展为参数tensor的大小.
等价于tensor_new.expand(tensor.size())

torch.tensor.data

解释：data是torch.Tensor类的一个成员变量。
作用：想修改tensor的值，但又不希望被autograd记录，则可以使用tensor.data。

a = torch.ones(3,4,requires_grad= True)
print("a",type(a))
# a <class 'torch.Tensor'>
print("a.data",a.data)
# a.data tensor([[1., 1., 1., 1.],
        #[1., 1., 1., 1.],
        #[1., 1., 1., 1.]])
print("a.data.requires_grad",a.data.requires_grad)
# a.data.requires_grad False

autograd，自动求导（automatic differentiation）

PyTorch 中所有神经网络的核心是autograd包。

从后向中排除子图

每个变量都有两个标志：requires_grad 和 volatile
都允许从梯度计算中精细地排除子图，并可以提高效率。

requires_grad

如果有一个单一的输入操作需要梯度，它的输出也需要梯度。相反，只有所有输入都不需要梯度，输出才不需要。如果其中所有的变量都不需要梯度进行，后向计算不会在子图中执行。

>>> x = Variable(torch.randn(5, 5))
>>> y = Variable(torch.randn(5, 5))
>>> z = Variable(torch.randn(5, 5), requires_grad=True)
>>> a = x + y
>>> a.requires_grad
False
>>> b = a + z
>>> b.requires_grad
True

这个标志特别有用，想要冻结部分模型时，或者您事先知道不会使用某些参数的梯度。例如，如果要对预先训练的CNN进行优化，只要切换冻结模型中的requires_gnad标志就足够了，直到计算到最后一层才会保存中间缓冲区，其中的仿射变换将使用需要梯度的权重并且网络的输出也将需要它们。

model = torchvision.models.resnet18(pretrained=True)
for param in model.parameters():
    param.requires_grad = False
# Replace the last fully-connected layer
# Parameters of newly constructed modules have requires_grad=True by default
model.fc = nn.Linear(512, 100)

# Optimize only the classifier
optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)
# 这段代码的意思是：使用预训练模型resnet18，只更改模型最后一个全连接层，也就是将模型整体参数requires_grad设置为False-冻结参数的梯度；模型的优化只是用针对更改的全连接层进行。

张量（Tensor）

torch.Tensor是包的核心类。如果将其属性.requires_grad设置为True，则会开始跟踪其上的所有操作。完成计算后，您可以调用.backward()并自动计算所有梯度。此张量的梯度将累积到.grad属性中。
要阻止张量跟踪历史记录，可以调用.detach()或者.data()将其从计算历史记录中分离出来，并防止将来的计算被跟踪。

function

Tensor和Function互相连接并构建一个非循环图来构建一个完整的计算过程。每个张量都有一个.grad_fn属性，该属性引用已创建Tensor的Function（除了用户创建的Tensors - 它们的grad_fn为None）。
参考

requires_grad

解释：是Pytorch中通用数据结构Tensor的一个属性，用于说明当前量是否需要在计算中保留对应的梯度信息，以线性回归为例，容易知道权重w和偏差b为需要训练的对象，为了得到最合适的参数值，我们需要设置一个相关的损失函数，根据梯度回传的思路进行训练。

pytorch中的tensor在CPU与GPU之间转换，以及numpy之间转换。

操作说明	操作命令
CPU tensor转GPU tensor	cpu_imgs.cuda()
GPU tensor 转CPU tensor	gpu_imgs.cpu()
numpy转为CPU tensor	torch.from_numpy( imgs )
CPU tensor转为numpy数据	cpu_imgs.numpy()

注意：

GPU tensor不能直接转为numpy数组，必须先转到CPU tensor

gpu_imgs.cpu().numpy()

tensor是标量的话，可以直接使用 item() 函数（只能是标量）将值取出来。

print loss_output.item()

torch.optim是一个实现了各种优化算法的库。

使用torch.optim的前提条件是：构建一个optimizer对象，此对象能够保持当前参数状态并基于计算得到的梯度进行参数更新。
构建的optimizer，需要包含优化的参数（都是variable（变量）对象）的iterable。

iterable

理解：

1. iterable被认为是一类对象（适合迭代）；
2. 一个iterable对象，表示它可以被遍历。任何具有__iter__（）或__getitem__()方法的对象，python都认为它是一个iterable；
3. python里面有大量内置的iterable类型。如list、str、tuple、dict、file、xrange等。

pytorch中的变量

有三个属性：

属性	属性含义
data	变量中的具体值
grad	变量反向传播的梯度
grad_fn	通过什么操作得到这个变量的

为每个参数单独设置选项

参数单独设置选项，需要传入dict的iterable。

进行单次优化step()

所有的optimizer都实现了step()方法，它会更新所有的参数。

实现方法	说明
optimizer.step()	简化版本，一旦梯度被类似backward()之类的函数计算好，就可以使用这个函数更新参数
optimizer.step(closure)	有些优化算法Conjugate Gradient 和 LBFGS需要重复多次计算函数，需要传入一个闭包去允许它们重新计算模型，闭包的作用应当清空梯度、计算损失，然后返回。

load_state_dict(state_dict)

加载optimizer状态，也就是预测代码中加载模型的部分。

optimzier优化器

作用：就是需要根据网络反向传播的梯度信息来更新网络的参数，以起到降低loss函数计算值的作用，这也是机器学习里面最一般的方法论
optimizer.step()需要放在每一个batch训练中，而不是epoch训练中，这是因为现在的mini-batch训练模式是假定每一个训练集就只有mini-batch这样大。
注意：
一般正则化，只是对模型的权重W参数进行惩罚，而偏置参数b是不进行惩罚的，而torch.optim的优化器weight_decay参数指定的权值衰减是对网络中的所有参数，包括权值w和偏置b同时进行惩罚。
优化器使用流程：

#选择优化器、以及加载网络的参数
optimizer_seg = torch.optim.Adam(segment_net.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
#在使用之前做清零处理
optimizer_seg.zero_grad()
#计算损失的反向传播
loss_seg.backward()
#知道反向传播的梯度信息
optimizer_seg.step()

参考

优化器介绍

参考

优化器分两类：
一类：SGD及其改进（加momentum）
class torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)
二类：逐参数适应学习率方法
class torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0)
class torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)
class torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)

class torch.optim.Adadelta(params, lr=1.0, rho=0.9, eps=1e-06, weight_decay=0)
class torch.optim.Adamax(params, lr=0.002, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)
class torch.optim.ASGD(params, lr=0.01, lambd=0.0001, alpha=0.75, t0=1000000.0, weight_decay=0)
class torch.optim.LBFGS(params, lr=1, max_iter=20, max_eval=None, tolerance_grad=1e-05, tolerance_change=1e-09, history_size=100, line_search_fn=None)
class torch.optim.Rprop(params, lr=0.01, etas=(0.5, 1.2), step_sizes=(1e-06, 50))

torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

解决的问题：
当训练集N很大的时候，使用总的成本函数来求梯度代价太大。所以通过计算训练集中的小批量（minibatches），即SGD。
参数：
momentum动量，通常设置为0.9/0.8
weight_decay权值衰减系数，也就是L2正则项的系数。
注意点：
minibatch的大小是一个超参数，通常是2的倍数（实际许多向量化操作实现的过程中，输入数据是2的倍数可以运算更快）
缺点：
在浅维度上进展非常慢，并沿陡峭方向抖动。
在局部极小值（local minima）或者鞍点（saddle point）会导致梯度（gradient）为0，无法移动。鞍点问题在高维问题中更加常见。
易受样本噪声影响，训练集中错误的标签。

torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)[source]（AMSGrad）

Adam是一种自适应学习率的优化方法，Adam利用梯度的一阶矩估计和二阶矩估计动态的调整学习率。Adam是结合了Momentum和RMSprop，并进行了偏差修正。
参数：
params——待优化参数的iterable
lr——学习率
betas——用于计算梯度以及梯度平方的运行平均值的系数，也就是公式中的两个参数
eps——为了增加数值计算的稳定性而加到分母里的项
weight_decay——权重衰减，即L2
特点：
①结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点;
②对内存需求较小；
③为不同的参数计算不同的自适应学习率;
④也适用于大多非凸优化-适用于大数据集和高维空间。
注意：
在实际操作中，推荐使用Adam作为默认的算法那，一般都会比RMSprop要好。

torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)

介绍：
RMSProp简单修改了Adagrad方法，它做了一个梯度平方的滑动平均（it uses a moving average of squared gradients instead）
参数：
weight_decay：常用值是0.9、0.99、0.999
优点：
不会让学习率单调变小。
相较于Adagrad来说，它在鞍点呆的越久，学习率会越大。

学习率衰减

学习率，作为权重更新步幅的控制因子。常见的学习率有0.01,0.001,0.0001等。
参考
参考

torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode=‘min’, factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode=‘rel’, cooldown=0, min_lr=0, eps=1e-08)

作用：发现loss不再减低或者acc不再提高之后，降低学习率。
参数：
mode——min模式检测metric是否不再减小、max模式检测metric是否不再增大；
factor——出发条件后lr*=factor
patience——不再减小（增大）的累计次数
verbose——触发条件后print
threshold——只关注超过阈值的显著变化
threshold_mode——有rel和abs两种阈值计算模式，rel规则：max模式下如果超过best(1+threshold)为显著，min模式下如果低于best(1-threshold)为显著；abs规则：max模式下如果超过best+threshold为显著，min模式下如果低于best-threshold为显著
cooldown——触发一次条件后，等待一定epoch再进行检测，避免lr下降过速
min_lr——最小的允许lr
eps——如果新旧lr之间的差异小与1e-8，则忽略此次更新
参考

使用scheduler.step（）

作用：scheduler.step（）是调整学习率的，如果调用scheduler.step（），则会改变optimizer中的学习率。
位置：由于scheduler.step（）的作用是更新学习率，所以要放在optimizer.step()之后。

权重衰减

是一种正则化的方法，最终会使神经网络的某些权重变成零。

xrange（start,stop[,step]）函数

作用：用法和range完全相同，所不同的是生成的不是一个数组，而是一个生成器。
参数：
start：计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)
stop：计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1)
返回值：生成器。

numpy.nanmean(a, axis=None, dtype=None, out=None, keepdims=)

作用：用于计算忽略NAN值的数组平均值，如果数组具有NAN值，可以找出不受NAN值影响的均值。
参数：
a（arr_like）输入数组；axis：=1行方向、=0列方向；out：输出数组；dype：数组的数据类型；keepdims：为True，则缩小的轴将保留为尺寸1的尺寸。
返回值：返回数组元素的平均值。

torch.nn.functional.dropout(input,p=0.5,training=False,inplace=False)

作用：随机将输入张量中部分元素设置为0.对于每次前向调用，被置0的元素都是随机的。
参数：
p：将元素置0的概率，默认值是0.5
inplace：设置为True，会在原地执行操作。默认值是False。
注意点：
F.dropout（x）只是使用，但是不改变training值的话，是没有启用dropout的。

tensor.size（）

作用：返回tensor张量的batch_size、通道数、图片高、图片宽，具体形式是torch.Size([batch_size, 通道数, 图片高, 图片宽])

class torch.nn.PixleShuffle(upscale_factor)

作用：上采样，将一个H × W的低分辨率输入图像（Low Resolution），通过Sub-pixel操作将其变为rH x rW的高分辨率图像（High Resolution）。
参数：upscale_factor表示放大的倍数，数值类型是int。
参考

Tensor

在pytorch中，Tensor是存储和变换数据的重要工具；
Tensor提供GPU计算和自动求梯度等功能；
pytorch中，可以使用Tensor对模型的输入和输出以及模型的参数进行编码；
Tensor与Numpy的Ndarray类似，只是张量可以在GPU或其他硬件加速器上运行。

torch.Tensor（data,type = None,device = None,requires_gard = False）

torch.Tensor() 是python类，是默认张量torch.FloatTensor()的别名；

torch.prod（input,*,dtype = None）→Tensor

返回input张量中所有元素的乘积；

tensor对象.type()

可以得到张量的数据类型，data的类型可以是list、tuple、Numpy、ndarray、scalar和其他类型。

F.avg_pool2d（）

表示数据是四维输入；
input维度：（batch_size、channels、height、width）
kernel维度：（二维：表示width的跨度），channel和输入的channel一致；

torch.Tensor.to()

torch.from_numpy()

从一个Numpy array初始化一个Tensor

torch.device()

代表torch.Tensor分配到的设备的对象。

np.ones(shape，dtype = None，order = ‘C’ )

np = import numpy as np
该函数返回给定形状和数据类型的新数组，其中元素的值设置为1，此函数与numpy zeros()类似；
shape = 一个整数类型（一维数组）或一个整数元组（返回给定形状的数组），用于定义数组的大小；
dtype = 默认是float，用于指定数组的数据类型；
order = 指定内存重以行优先（‘C’）还是列优先（‘F’）

模型后缀名

weights一般是YOLO darknet的模型保存格式。
pth一般是PyTorch的模型保存格式
ckpt一般是tenseflow的模型保存格式
h5是HDF5文件格式的后缀。h5文件对于存储大量数据而言拥有极大的优势，这里安利大家多使用h5文件来存储数据，既高逼格又高效率。
HDF(Hierarchical Data Format层次数据格式)是一种设计用于存储和组织大量数据的文件格式，最开始由美国国家超算中心研发，后来由一个非盈利组织HDF Group支持。

对于nn.Sequential中某层的输出

class PrintLayer(nn.Module):
    def __init__(self):
        super(PrintLayer, self).__init__()
    
    def forward(self, x):
        # Do your print / debug stuff here
        print(x)      #print(x.shape)
        return x

参考