【深度学习】PyTorch命令笔记

PyTorch文档

PyTorch中文文档
PyTorch documentation

.index_select

从指定维度，按索引保留tensor

pytorch的tensor.index_select(维度, 索引序号)

用例：

>>> import torch
>>> a = torch.linspace(0, 47, steps=48)
>>> a.size()
torch.Size([48])
>>> x = a.view(3, 4, 4)
>>> x
tensor([[[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [12., 13., 14., 15.]],

        [[16., 17., 18., 19.],
         [20., 21., 22., 23.],
         [24., 25., 26., 27.],
         [28., 29., 30., 31.]],

        [[32., 33., 34., 35.],
         [36., 37., 38., 39.],
         [40., 41., 42., 43.],
         [44., 45., 46., 47.]]])
>>> y = x.index_select(0, torch.LongTensor([0, 2]))
>>> y
tensor([[[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [12., 13., 14., 15.]],

        [[32., 33., 34., 35.],
         [36., 37., 38., 39.],
         [40., 41., 42., 43.],
         [44., 45., 46., 47.]]])

.numel

得到tensor的元素总个数

pytorch的tensor.numel()  

用例：

>>> import torch
>>> a = torch.rand(3, 4, 4)
>>> a.numel()
48
>>>  

.repeat

按指定的维度复制tensor

如果指定的维度数量多余tensor的实际维度数量，则在最前面扩充维度

pytorch的tensor.repeat(维度1的复制倍数, 维度2的复制倍数, ..) 

用例：

>>> import torch
>>> a = torch.linspace(1, 12, 12)
>>> a
tensor([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.])
>>> a = a.view(3, 4)
>>> a
tensor([[ 1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.],
        [ 9., 10., 11., 12.]])
>>> b = a.repeat(1, 2)
>>> b
tensor([[ 1.,  2.,  3.,  4.,  1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.,  5.,  6.,  7.,  8.],
        [ 9., 10., 11., 12.,  9., 10., 11., 12.]])
>>> b.size()
torch.Size([3, 8])
>>> c = a.repeat(1, 2, 2)
>>> c
tensor([[[ 1.,  2.,  3.,  4.,  1.,  2.,  3.,  4.],
         [ 5.,  6.,  7.,  8.,  5.,  6.,  7.,  8.],
         [ 9., 10., 11., 12.,  9., 10., 11., 12.],
         [ 1.,  2.,  3.,  4.,  1.,  2.,  3.,  4.],
         [ 5.,  6.,  7.,  8.,  5.,  6.,  7.,  8.],
         [ 9., 10., 11., 12.,  9., 10., 11., 12.]]])
>>> c.size()
torch.Size([1, 6, 8])
>>> 

.view

将pytorch的tensor resize

pytorch的tensor.view(参数1, 参数2...)  

用例：

>>> import torch
>>> tensor = torch.rand(3, 4, 4)
>>> tensor_ = tensor.view(3, -1)
>>> tensor_.size()
torch.Size([3, 16])
>>> 

from torchvision.transforms import transforms

PyTorch的图片变换方法

对PIL.Image进行变换

transforms.CenterCrop(size)

将给定的PIL.Image进行中心切割，得到给定的size大小的中心区域

transforms.CenterCrop(size)(image)  

• size是tuple：(target_height, target_width)
• size是Integer：(size, size)
• image：PIL.Image
• 返回切割后的PIL.Image

类型转换

transforms.ToTensor

将PIL图片或者ndarray转换成Tensor
将PIL图片或者numpy.ndarray(h, w, c)（数值范围[0, 255]）转换成(c, h, w)（数值范围[0.0, 1.0]）的浮点型Tensor

# 用例
data = np.random.randint(0, 255, size=300)
img = data.reshape(10,10,3)
print(img.shape)
img_tensor = transforms.ToTensor()(img)
print(img_tensor)

Compose

将多个变换方式结合在一起

transforms.Compose([transforms.ToTensor(), transforms.CenterCrop(size), ...])(image)

torch.backends.cudnn.benchmark

如果网络的输入数据维度或类型固定，设置该标志可以增加运行效率

torch.backends.cudnn.benchmark = True

torch.nn.BatchNorm2d

使用BN层，计算公式为：$y=\frac{x-mean(x)}{\sqrt{Var(x)}+eps}\ast gamma+beta$，是在batch间对每一个channel做操作

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

• num_features：之前卷积层的out_channels，也就是输入BN层的tensor的channel数
• eps：默认值为1e-5
• momentum：默认值为0.1
• affine：当设为True时，使用可以学习的系数矩阵gamma和beta

torch.nn.Conv2d

卷积操作

torch.nn.Conv2d(in_channels，out_channels，kernel_size，stride=1，padding=0，dilation=1，groups=1，bias=True)

• in_channels：输入张量的channel数
• out_channels：输出张量的channel数
• kernel_size：卷积核size
• stride：步长
• padding：如果是一个数，就填充这个数值的圈数的零(四周都填充)，然后再进行卷积操作

torch.nn.DataParallel

多GPU训练

model = torch.nn.DataParallel(model, device_ids=[0, 1, 2])

• model：继承torch.nn.Module的自定义网络实例
• device_ids：可见的GPU编号

torch.nn.L1Loss

L1损失函数，$loss(x,y)=\frac{1}{n}\sum |x_i-y_i|$

torch.nn.L1Loss(size_average=True)(output, label)

• size_average：如果设置为False，$loss(x,y)$将不除以$n$

torch.nn.LeakyReLU

使用LeakyReLU激活函数，和ReLU激活函数的区别是，当$x<0$时，LeakyReLU激活函数的值为$\lambda x$

torch.nn.LeakyReLU(lambda, inplace=False)(output, label)

• lambda：参数$\lambda$的值
• inplace：设置为True，则将计算得到的值直接覆盖之前的值

torch.nn.Linear

线性变换

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

torch.nn.MaxPool2d

使用最大池化层

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

• kernel_size：max pooling的窗口大小，可以为tuple
• stride：max pooling的窗口移动的步长，默认值是kernel_size
• padding：输入的每一条边补充0的层数
• return_indices ：如果等于True，会返回输出最大值的序号
• ceil_mode：如果等于True，计算输出张量size的时候，会使用向上取整，默认为向下取整的操作

torch.nn.Module

自定义层或网络必须继承torch.nn.Module，并且在其构造函数中需调用torch.nn.Module的构造函数，即：

class MyNet(nn.Module):
    def __init__(self, ...):
        super(MyNet, self).__init__()

或：

class MyNet(nn.Module):
    def __init__(self, ...):
        nn.Module.__init__(self)

除此之外，还需要在自定义层或网络的类中实现forward方法

把网络中具有可学习参数的层放在构造函数__init__()中，不具有可学习参数的层(如ReLU)可放在构造函数中，或在forward中使用nn.functional来代替

只要在nn.Module的子类中定义了forward函数，backward函数就会被自动实现

nn.Module 的__call__方法中调用的forward函数，也就是说nn.Module的子类可以当作函数调用，这个函数就是在子类中定义的forward函数

torch.nn.Module.load_state_dict(torch.load(".pt file path", map_location=))

加载模型

1. cpu -> cpu 或 gpu -> 同一个gpu

checkpoint = torch.load(".pt file path")
model.load_state_dict(checkpoint)
# model 是继承了nn.Module的子类

2. gpu -> cpu

checkpoint = torch.load(".pt file path", map_location="cpu")
model.load_state_dict(checkpoint)
# model 是继承了nn.Module的子类

3. cpu -> gpu编号0

checkpoint = torch.load(".pt file path", map_location=lambda storage, loc: storage.cuda(0))
model.load_state_dict(checkpoint)
# model 是继承了nn.Module的子类

4. gpu编号0 -> gpu编号1

checkpoint = torch.load(".pt file path", map_location={"cuda:0":"cuda:1"})
model.load_state_dict(checkpoint)
# model 是继承了nn.Module的子类

5. 另外
   有时候会有如下情况：

checkpoint = torch.load(".pt file path", map_location="cpu")
model.load_state_dict(checkpoint["model"])
# model 是继承了nn.Module的子类

这是因为checkpoint是一个字典，保存的key可以自己定义。可以保存除参数信息之外的其它信息，如epoch等。

torch.nn.MSELoss

均方损失函数，$loss(x,y)=\frac{1}{n}\sum (x_i-y_i{)}^2$

torch.nn.MSELoss(size_average=True)(output, label)

• size_average：如果设置为False，$loss(x,y)$将不除以$n$

torch.nn.ReLU

使用ReLU激活函数

torch.nn.ReLU(inplace=False)

• inplace：设置为True，则将计算得到的值直接覆盖之前的值

torch.nn.SmoothL1Loss

SmoothL1损失函数，$if|x_i-y_i|<1，loss(x,y)=\frac{1}{n}\sum 0.5\ast (x_i-y_i{)}^2$，$if|x_i-y_i|>=1，loss(x,y)=\frac{1}{n}\sum (|x_i-y_i|-0.5)$

torch.nn.SmoothL1Loss(size_average=True)

• size_average：如果设置为False，$loss(x,y)$将不除以$n$

torch.nn.Softmax

torch.nn.Softmax(input, dim)

或者

m = torch.nn.Softmax(dim)
out_tensor = m(in_tensor)

torch.optim

实现了各种优化算法

torch.optim.lr_scheduler.MultiStepLR

按epoch时刻调整学习率

torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1)

• optimizer：优化器
• milestones：一个列表，里面是学习率要下降的epoch点
• gamma：学习率下降系数

torch.optim.SGD

随机梯度下降算法，momentum可选

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

• params ：待优化参数的iterable或者是定义了参数组的dict
• lr：float类型，学习率
• momentum：float类型，动量因子，默认为0
• weight_decay ：float类型，L2正则权重，默认为0
• dampening：float类型，动量的抑制因子，默认为0
• nesterov：bool类型，是否使用Nesterov动量，默认为False

结语

如果您有修改意见或问题，欢迎留言或者通过邮箱和我联系。
手打很辛苦，如果我的文章对您有帮助，转载请注明出处。