pytorch常用函数API简析与汇总——以备查询

向右看齐 2021-12-10 00:19 310阅读 0赞

### 文章目录 ###

*  Tensor
 *   *  运算
     *  变换
     *   *  torch.Tensor.transpose()&torch.Tensor.permute()
         *  torch.cat() & torch.stack()
         *  torch.squeeze()&torch.unsqueeze()
         *  torch.Tensor.expand()&torch.Tensor.expand\_as()
         *  torch.contiguous()
         *  torch.Tensor.view(\*args)->Tensor
 *  常用层
 *   *  nn.Sequential()
     *  nn.Linear()
     *  nn.Conv2d()
     *  归一化层
     *  池化层
     *  Dropout层
 *  常用激活函数
 *  常用损失函数

# Tensor #

## 运算 ##

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>torch.abs</td> 
   <td>绝对值</td> 
  </tr> 
  <tr> 
   <td>torch.add</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>torch.clamp</td> 
   <td>裁剪</td> 
  </tr> 
  <tr> 
   <td>torch.div</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>torch.mul</td> 
   <td>逐元素求积</td> 
  </tr> 
  <tr> 
   <td>torch.pow</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><a href="http://torch.mm" rel="nofollow">torch.mm</a></td> 
   <td>矩阵乘法</td> 
  </tr> 
  <tr> 
   <td><a href="http://torch.mv" rel="nofollow">torch.mv</a></td> 
   <td>矩阵向量乘法</td> 
  </tr> 
 </tbody> 
</table>

## 变换 ##

### torch.Tensor.transpose()&torch.Tensor.permute() ###

transpose一次只能操作矩阵的两个维度，只接收两个维度的参数。

permute可以同时对多个维度进行操作

a=torch.rand(2,3,4)#torch.Size([2,3,4])
    b=a.transpose(0,1)#torch.Size([3,2,4])
    
    c=a.transpose(0,1).transpose(1,2)#torch.Size([3,4,2])
    d=a.permute(1,2,0)#torch.Size([3,4,2])

### torch.cat() & torch.stack() ###

cat是对数据沿着某一个维度对seq中的Tensor进行拼接，操作之后总维数不变，只在统一维度进行拼接。

**torch.cat(seq, dim=0, out=None)** → Tensor

**参数：**

*  seq (sequence of Tensors) - Python序列或相同类型的张量序列
 *  dim (int, optional) - 沿着此维度连接张量
 *  out (Tensor, optional) - 输出参数

除了在拼接的维度外，其余维度必须相等才能拼接。

a=torch.rand(2,3)
    b=torch.rand(4,3)
    c=torch.cat((a,b),axis=0)#torch.Size([6,3])

stack是在增加新的维度后进行“堆叠”，而不是直接拼接。会增加维度。

在对数据进行加载组合为一个batch时常常用到。

a=torch.rand([2,224,224])
    b=torch.rand([3,224,224])
    c=torch.stack((a,b),0)#torch.Size([2,3,224,224])
    d=torch.stack((a,b),3)#torch.Size([3,224,224,2])

### torch.squeeze()&torch.unsqueeze() ###

squeeze(dim\_n)压缩，去掉元素数为1的dim\_n的维度。

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

**参数:**

*  input (Tensor) – 输入张量
 *  dim (int, optional) – 如果给定，则只会在给定维度压缩
 *  out (Tensor, optional) – 输出张量

unsqueeze(dim\_n)增加dim\_n维度，元素数目为1，与squeeze相反。

a=torch.rand(2,1,4)#torch.Size([2,1,4])
    b=a.squeeze()#torch.Size([2,4]),去掉了元素个数为1的第二个维度
    c=a.squeeze(1)#torch.Size([2,4]),同上
    d=a.squeeze(2)#torch.Size([2,1,4]),第三个维度的元素个数不为1，不能去掉
    
    e=a.unsqueeze(0)#torch.Size([1,2,1,4])，新增了第1个维度

### torch.Tensor.expand()&torch.Tensor.expand\_as() ###

torch.Tensor.expand(sizes) → Tensor

扩大张量，并且将张量复制使之变为对应size大小

x=torch.Tensor([[1],[2],[3]])#torch.Size([3,1])
    x.expand(3,4)#torch.Size([3,4]),[[1,1,1,1],[2,2,2,2],[3,3,3,3]]

torch.Tensor.expand\_as(size)

扩大张量，并且将张量变为对应Tensor的大小

a=torch.Tensor([[1],[2],[3]])
    b=torch.Tensor([[4]])
    c=b.expand_as(a)
    #tensor([[4],[4],[4]])

### torch.contiguous() ###

contiguous：view只能用在contiguous的variable上。如果在view之前用了transpose, permute等，需要用contiguous()来返回一个contiguous copy。 因为view需要tensor的内存是整块的。有些tensor并不是占用一整块内存，而是由不同的数据块组成，而tensor的view()操作依赖于内存是整块的，这时只需要执行contiguous()这个函数，把tensor变成在内存中连续分布的形式。判断是否contiguous用torch.Tensor.is\_contiguous()函数

x=torch.ones(10,10)
    x.is_contiguous()  #True
    x.transpose(0,1).is_contiguous()  #False
    x.transpose(0, 1).contiguous().is_contiguous()  #True

**因此，在调用view之前最好先contiguous一下，x.contiguous().view()** 。

### torch.Tensor.view(\*args)->Tensor ###

**参数：**

*  args (torch.Size or int…) - 理想的指定尺寸

返回具有相同数据，但是形状与args所述相同的新的Tensor

a=torch.rand(4,4)#torch.Size([4,4])
    b=x.view(16)#torch.Size([16])

# 常用层 #

## nn.Sequential() ##

参数：若干其他层

torch.nn.Sequential 其实就是 Sequential 容器，该容器将一系列操作按先后顺序给包起  
来，方便重复使用。将若干简单的层组合起来，方便结构显示与重用。

nn.Sequential(
    	nn.Conv2d(in_dim,6,3,stride=1,padding=1),
    	nn.ReLU(True),
    	nn.MaxPool2d(2,2),
    	nn.Conv2d(6,16,5,stride=1,padding=0),
    	nn.ReLU(True),
    	nn.MaxPool2d(2,2)
    )

## nn.Linear() ##

参数：输入维度，输出维度

nn.Linear(dim_in,dim_out)

y = x W T + b y=xW^\{T\}+b y=xWT\+b

作用：全连接

import torch
    
    x = torch.randn(128, 20)  # 输入的维度是（128，20）
    m = torch.nn.Linear(20, 30)  # 20,30是指维度
    output = m(x)
    print('m.weight.shape:\n ', m.weight.shape)
    print('m.bias.shape:\n', m.bias.shape)
    print('output.shape:\n', output.shape)
    
    # ans = torch.mm(input,torch.t(m.weight))+m.bias 等价于下面的
    ans = torch.mm(x, m.weight.t()) + m.bias#y=x*W^T+b,weight要转置
    print('ans.shape:\n', ans.shape)
    
    print(torch.equal(ans, output))

m.weight.shape:
      torch.Size([30, 20])
    m.bias.shape:
     torch.Size([30])
    output.shape:
     torch.Size([128, 30])
    ans.shape:
     torch.Size([128, 30])
    True

nn.Linear()与nn.Conv1d()在kernel\_size=1时等价，但是nn.Linear()启动更快

## nn.Conv2d() ##

参数：in\_channels, out\_channels, kernel\_size, stride=1, padding=0, dilation=1, groups=1, bias=True

输入大小、输出大小、卷积核个数groups、卷积核大小kernel\_size、滑动步长stride和填充量padding

kernel\_size, stride, padding, dilation 不但可以是一个单个的int——表示在高度和宽度使用这个相同的int作为参数

nn.Conv2d(6, 16, 5, stride=1, padding=0)

## 归一化层 ##

nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True)
    nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)
    nn.BatchNorm3d(num_features, eps=1e-05, momentum=0.1, affine=True)
    nn.InstanceNorm1d(num_features, eps=1e-05, momentum=0.1, affine=False)
    nn.InstanceNorm2d(num_features, eps=1e-05, momentum=0.1, affine=False)
    nn.InstanceNorm3d(num_features, eps=1e-05, momentum=0.1, affine=False)

## 池化层 ##

nn.MaxPl1d(knl_iz, tid=Nn, padding=0, dilatin=1, tn_indi=Fal, il_md=Fal)
    nn.MaxPl2d(knl_iz, tid=Nn, padding=0, dilatin=1, tn_indi=Fal, il_md=Fal)
    nn.MaxPl3d(knl_iz, tid=Nn, padding=0, dilatin=1, tn_indi=Fal, il_md=Fal)
    nn.Maxnpl1d(knl_iz, tid=Nn, padding=0)
    nn.Maxnpl2d(knl_iz, tid=Nn, padding=0)
    nn.Maxnpl3d(knl_iz, tid=Nn, padding=0)
    nn.AvgPl1d(knl_iz, tid=Nn, padding=0, il_md=Fal, nt_inld_pad=T)
    nn.AvgPl2d(knl_iz, tid=Nn, padding=0, il_md=Fal, nt_inld_pad=T)
    nn.AvgPl3d(knl_iz, tid=Nn, padding=0, il_md=Fal, nt_inld_pad=T)
    nn.FatinalMaxPl2d(knl_iz, tpt_iz=Nn, tpt_ati=Nn, tn_indi=Fal, _andm_ampl=Nn)
    nn.LPPl2d(nm_typ, knl_iz, tid=Nn, il_md=Fal)
    nn.AdaptivMaxPl1d(tpt_iz, tn_indi=Fal)
    nn.AdaptivMaxPl2d(tpt_iz, tn_indi=Fal)
    nn.AdaptivMaxPl3d(tpt_iz, tn_indi=Fal)
    nn.AdaptivAvgPl1d(tpt_iz)
    nn.AdaptivAvgPl2d(tpt_iz)
    nn.AdaptivAvgPl3d(tpt_iz)

## Dropout层 ##

nn.Dropout(p=0.5, inplace=False)
    nn.Dropout2d(p=0.5, inplace=False)
    nn.Dropout3d(p=0.5, inplace=False)
    nn.AlphaDropout(p=0.5)

# 常用激活函数 #

nn.ReLU(inplace=False)
    nn.ReLU6(inplace=False)
    nn.ELU(alpha=1.0, inplace=False)
    nn.SELU(inplace=False)
    nn.PReLU(num_parameters=1, init=0.25)
    nn.LeakyReLU(negative_slope=0.01, inplace=False)
    nn.Threshold(threshold, value, inplace=False)
    nn.Hardtanh(min_val=-1, max_val=1, inplace=False, min_value=None, max_value=None)
    nn.Sigmoid
    nn.LogSigmoid
    nn.Tanh
    nn.Tanhshrink
    nn.Softplus(beta=1, threshold=20)
    nn.Softmax(dim=None)
    nn.LogSoftmax(dim=None)
    nn.Softmax2d
    nn.Softmin(dim=None)
    nn.Softshrink(lambd=0.5)
    nn.Softsign

# 常用损失函数 #

nn.L1Loss(size_average=True, reduce=True)
    nn.MSELoss(size_average=True, reduce=True)
    nn.CrossEntropyLoss(weight=None, size_average=True, ignore_index=-100, reduce=True)
    nn.NLLLoss(weight=None, size_average=True, ignore_index=-100, reduce=True)
    nn.PoissonNLLLoss(log_input=True, full=False, size_average=True, eps=1e-08)
    nn.NLLLoss2d(weight=None, size_average=True, ignore_index=-100, reduce=True)
    nn.KLDivLoss(size_average=True, reduce=True)
    nn.BCELoss(weight=None, size_average=True)
    nn.BCEWithLogitsLoss(weight=None, size_average=True)
    nn.MarginRankingLoss(margin=0, size_average=True)
    nn.HingeEmbeddingLoss(margin=1.0, size_average=True)
    nn.MultiLabelMarginLoss(size_average=True)
    nn.SmoothL1Loss(size_average=True, reduce=True)
    nn.SoftMarginLoss(size_average=True)
    nn.CosineEmbeddingLoss(margin=0, size_average=True)