Pytorch常用API汇总(持续更新)

Pytorch常用API汇总

张量创建

torch.tensor()

从data创建tensor

• data: 数据, 可以是list, numpy
• dtype : 数据类型，默认与data的一致
• device : 所在设备, cuda/cpu
• requires_grad：是否需要梯度
• pin_memory：是否存于锁页内存

torch.zeros()

依size创建全0张量

• size: 张量的形状, 如(3, 3)、(3, 224,224)
• out : 输出的张量layout : 内存中布局形式, 有
  strided,sparse_coo等
• device : 所在设备, gpu/cpu
• requires_grad：是否需要梯度

torch.zeros_like()

依input形状创建全0张量

• intput: 创建与input同形状的全0张量
• dtype : 数据类型
• layout : 内存中布局形式

torch.ones()

torch.ones_like()

依input形状创建全1张量

• size: 张量的形状, 如(3, 3)、(3, 224,224)
• dtype : 数据类型
• layout : 内存中布局形式
• device : 所在设备, gpu/cpu
• requires_grad：是否需要梯度

torch.full()

torch.full_like()

依input形状创建指定数据的张量

• size: 张量的形状, 如(3, 3)
• fill_value : 张量的值

torch.arange()

创建等差的1维张量，数值区间为[start, end)

• start: 数列起始值
• end : 数列“结束值”
• step: 数列公差，默认为1

torch.linspace()

创建均分的1维张量，数值区间为[start, end]

• start: 数列起始值
• end : 数列结束值
• steps: 数列长度

torch.logspace()

创建对数均分的1维张量，长度为steps, 底为base

• start: 数列起始值
• end : 数列结束值
• steps: 数列长度
• base : 对数函数的底，默认为10

torch.eye()

创建单位对角矩阵（ 2维张量），默认为方阵

• n: 矩阵行数
• m : 矩阵列数

torch.normal()

生成正态分布（高斯分布）

• mean : 均值
• std : 标准差

torch.randn()

torch.randn_like()

生成标准正态分布

• size : 张量的形状

torch.rand()

torch.rand_like()

在区间[0, 1)上，生成均匀分布

torch.randint()

torch.randint_like()

区间[low, high)生成整数均匀分布

• size : 张量的形状

在区间[0, 1)上，生成均匀分布

torch.randperm()

生成生成从0到n-1的随机排列

• n : 张量的长度

torch.bernoulli()

以input为概率，生成伯努力分布（0-1分布，两点分布）

• input : 概率值

张量操作

torch.topk()

找出前k大的数据，及其索引序号

• input：张量
• k：决定选取k个值
• dim：索引维度

返回：

• Tensor：前k大的值
• LongTensor：前k大的值所在的位置

torch.cat()

将张量按维度dim进行拼接

• tensors: 张量序列
• dim : 要拼接的维度

torch.stack()

在新创建的维度dim上进行拼接

• tensors:张量序列
• dim :要拼接的维度

torch.chunk()

将张量按维度dim进行平均切分，返回值为张量列表，若不能整除，最后一份张量小于其他张量

• input: 要切分的张量
• chunks : 要切分的份数
• dim : 要切分的维度

torch.split()

将张量按维度dim进行切分，返回值为张量列表

• tensor: 要切分的张量
• split_size_or_sections : 为int时，表示每一份的长度；为list时，按list元素切分
• dim : 要切分的维度

torch.index_select()

在维度dim上，按index索引数据，返回值为依index索引数据拼接的张量

• input: 要索引的张量
• dim: 要索引的维度
• index : 要索引数据的序号

torch.masked_select()

按mask中的True进行索引，返回值为一维张量

• input: 要索引的张量
• mask: 与input同形状的布尔类型张量

torch.reshape()

变换张量形状，当张量在内存中是连续时，新张量与input共享数据内存

• input: 要变换的张量
• shape: 新张量的形状

torch.transpose()

交换张量的两个维度

• input: 要变换的张量
• dim0: 要交换的维度
• dim1: 要交换的维度

torch.t()

2维张量转置，对矩阵而言，等价于torch.transpose(input, 0, 1)

torch.squeeze()

压缩长度为1的维度（轴）

• dim: 若为None，移除所有长度为1的轴；若指定维度，当且仅当该轴长度为1时，可以被移除；

torch.unsqueeze()

依据dim扩展维度

• dim: 扩展的维度

张量数学运算

• torch.add()
• torch.addcdiv()
• torch.addcmul()
• torch.sub()
• torch.div()
• torch.mul()
• torch.log(input, out=None)
• torch.log10(input, out=None)
• torch.log2(input, out=None)
• torch.exp(input, out=None)
• torch.pow()
• torch.abs(input, out=None)
• torch.acos(input, out=None)
• torch.cosh(input, out=None)
• torch.cos(input, out=None)
• torch.asin(input, out=None)
• torch.atan(input, out=None)
• torch.atan2(input, other, out=None)

自动求导系统

• 梯度不自动清零

2. 依赖于叶子结点的结点，requires_grad默认为True
3. 叶子结点不可执行in-place

torch.autograd.backward

自动求取梯度

• tensors: 用于求导的张量，如 loss
• retain_graph : 保存计算图
• create_graph : 创建导数计算图，用于高阶求导
• grad_tensors：多梯度权重

torch.autograd.grad

求取梯度

• outputs: 用于求导的张量，如 loss
• inputs : 需要梯度的张量
• create_graph : 创建导数计算图，用于高阶求导
• retain_graph : 保存计算图
• grad_outputs：多梯度权重

数据导入

• Epoch: 所有训练样本都已输入到模型中，称为一个Epoch
• Iteration：一批样本输入到模型中，称之为一个Iteration
• Batchsize：批大小，决定一个Epoch有多少个Iteration

torch.utils.data.DataLoader

构建可迭代的数据装载器

• dataset: Dataset类，决定数据从哪读取及如何读取
• batchsize : 批大小
• num_works: 是否多进程读取数据
• shuffle: 每个epoch是否乱序
• drop_last：当样本数不能被batchsize整除时，是否舍弃最后一批数据

torch.utils.data.Dataset

Dataset抽象类，所有自定义的Dataset需要继承它，并且复写_getitem__()

getitem :接收一个索引，返回一个样本

数据预处理

transforms.Normalize

逐channel的对图像进行标准化：output = (input - mean) / std

• mean：各通道的均值
• std：各通道的标准差
• inplace：是否原地操作

裁剪

transforms.CenterCrop

从图像中心裁剪图片

• size：所需裁剪图片尺寸

transforms.RandomCrop

从图片中随机裁剪出尺寸为size的图片

• size：所需裁剪图片尺寸
• padding：设置填充大小当为a时，上下左右均填充a个像素；当为(a, b)时，上下填充b个像素，左右填充a个像素；当为(a, b, c, d)时，左，上，右，下分别填充a, b, c, d
• pad_if_need：若图像小于设定size，则填充
• padding_mode：填充模式，有4种模式
  1、constant：像素值由fill设定
  2、edge：像素值由图像边缘像素决定
  3、reflect：镜像填充，最后一个像素不镜像，eg：[1,2,3,4] → [3,2,1,2,3,4,3,2]
  4、symmetric：镜像填充，最后一个像素镜像，eg：[1,2,3,4] → [2,1,1,2,3,4,4,3]
• fill：constant时，设置填充的像素值

transforms.RandomResizedCrop

随机大小、长宽比裁剪图片

• size：所需裁剪图片尺寸
• scale：随机裁剪面积比例, 默认(0.08, 1)
• ratio：随机长宽比，默认(3/4, 4/3)
• interpolation：插值方法

FiveCrop and TenCrop

在图像的上下左右以及中心裁剪出尺寸为size的5张图片，TenCrop对这5张图片进行水平或者垂直镜像获得10张图片

• size：所需裁剪图片尺寸
• vertical_flip：是否垂直翻转

旋转和翻转

• transforms.RandomHorizontalFlip
• transforms.RandomVerticalFlip
• transforms.RandomRotation

图像变换

• transforms.Pad
• transforms.ColorJitter
• transforms.Grayscale
• transforms.RandomGrayscale
• transforms.RandomAffine
• transforms.LinearTransformation
• transforms.RandomErasing
• transforms.Lambda
• transforms.Resize
• transforms.Totensor
• transforms.Normalize

transform的操作

• transforms.RandomChoice
• transforms.RandomApply
• transforms.RandomOrder

模型容器

nn.Sequential

nn.module的容器，用于按顺序包装一组网络层

• 顺序性：各网络层之间严格按照顺序构建
• 自带forward()：自带的forward里，通过for循环依次执行前向传播运算

nn.ModuleList

nn.module的容器，用于包装一组网络层，以迭代方式调用网络层

• append()：在ModuleList后面添加网络层
• extend()：拼接两个ModuleList
• insert()：指定在ModuleList中位置插入网络层

nn.ModuleDict

nn.module的容器，用于包装一组网络层，以索引方式调用网络层

• clear()：清空ModuleDict
• items()：返回可迭代的键值对(key-value pairs)
• keys()：返回字典的键(key)
• values()：返回字典的值(value)
• pop()：返回一对键值，并从字典中删除

容器总结

• nn.Sequential：顺序性，各网络层之间严格按顺序执行，常用于block构建
• nn.ModuleList：迭代性，常用于大量重复网构建，通过for循环实现重复构建
• nn.ModuleDict：索引性，常用于可选择的网络层

模型构建

nn.Conv2d

对多个二维信号进行二维卷积

• in_channels：输入通道数
• out_channels：输出通道数，等价于卷积核个数
• kernel_size：卷积核尺寸
• stride：步长
• padding ：填充个数
• dilation：空洞卷积大小
• groups：分组卷积设置
• bias：偏置

nn.ConvTranspose2d

转置卷积实现上采样

• in_channels：输入通道数
• out_channels：输出通道数，等价于卷积核个数
• kernel_size：卷积核尺寸
• stride：步长
• padding ：填充个数
• dilation：空洞卷积大小
• groups：分组卷积设置
• bias：偏置

nn.MaxPool2d

对二维信号（图像）进行最大值池化

• kernel_size：池化核尺寸
• stride：步长
• padding ：填充个数
• dilation：池化核间隔大小
• ceil_mode：尺寸向上取整
• return_indices：记录池化像素索引

nn.AvgPool2d

对二维信号（图像）进行平均值池化

• kernel_size：池化核尺寸
• stride：步长
• padding ：填充个数
• ceil_mode：尺寸向上取整
• count_include_pad：填充值用于计算
• divisor_override ：除法因子

nn.MaxUnpool2d

：对二维信号（图像）进行最大值池化
上采样

• kernel_size：池化核尺寸
• stride：步长
• padding ：填充个数

nn.Linear

对一维信号（向量）进行线性组合

• in_features：输入结点数
• out_features：输出结点数
• bias ：是否需要偏置

nn.Sigmoid

nn.ReLU

nn.tanh

权值初始化

Xavier均匀分布

torch.nn.init.xavier_uniform_(tensor, gain=1)

Xavier正态分布

torch.nn.init.xavier_normal_(tensor, gain=1)

Kaiming均匀分布

torch.nn.init.kaiming_uniform_(tensor, a=0, mode=‘fan_in’, nonlinearity=‘leaky_relu’)

Kaiming正态分布

torch.nn.init.kaiming_normal_(tensor, a=0, mode=‘fan_in’, nonlinearity=‘leaky_relu’)

均匀分布

torch.nn.init.uniform_(tensor, a=0, b=1)

正态分布

torch.nn.init.normal_(tensor, mean=0, std=1)

常数分布

torch.nn.init.constant_(tensor, val)

正交矩阵初始化

torch.nn.init.orthogonal_(tensor, gain=1)

单位矩阵初始化

torch.nn.init.eye_(tensor)

稀疏矩阵初始化

torch.nn.init.sparse_(tensor, sparsity, std=0.01)

损失函数

nn.CrossEntropyLoss()

$$los{s}_i=w_{y_i}(-x_i+log(\sum _j{e}^{x_j}))$$

将nn.LogSoftmax()与nn.NLLLoss()结合，进行交叉熵计算

• weight：各类别的loss设置权值，类别即标签，是向量形式，要对每个样本都设置权重，默认均为1；
• ignore_index：忽略某个类别；
• reduction：计算模式，可分为none:逐个元素计算，输出为各个input的loss；sum:none模式所有元素求和，返回标量；mean:none模式所有元素加权平均，返回标量，若设置了weight，则mean计算时，分母为weight的和；

nn.NLLLoss

$$los{s}_i=-w_{y_i}\ast x_i$$

实现负对数似然函数中的负号功能

• weight
• ignore_index
• reduction

nn.BCELoss

$$los{s}_i=-w_{y_i}[y_i\ast log(x_i)+(1-y_i)\ast log(1-x_i)]$$

二分类交叉熵，输入值取值需要在[0,1]上，因为要符合概率取值，所以使用时，可以把输出值输入Sigmoid()后再计算loss。

• weight
• ignore_index
• reduction

nn.BCEWithLogitsLoss

$$los{s}_i=-w_{y_i}[y_n\ast log(Sigmoid(x_i)+(1-y_i)\ast log(1-Sigmoid(x_i)]$$

结合Sigmoid与二分类交叉熵(因为有时不希望最后一层是Sigmoid，但是BCELoss又需要，故设置一个集成函数)

• pos_weight：正样本的权值，顾名思义，标签为正数的权值；
• weight
• ignore_index
• reduction

nn.L1Loss

$$Los{s}_i=|x_i-y_i|$$

计算inputs与target之差的绝对值。

• reduction

nn.MSELoss

$$Los{s}_i=(x_i-y_i{)}^2$$

计算inputs与target之差的平方

• reduction

nn.SmoothL1Loss