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

叁歲伎倆 2023-06-15 15:27 78阅读 0赞

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。  
本文链接：https://blog.csdn.net/sherpahu/article/details/95935845  
文章目录  
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  
运算  
操作 功能  
torch.abs 绝对值  
torch.add  
torch.clamp 裁剪  
torch.div  
torch.mul 逐元素求积  
torch.pow  
torch.mm 矩阵乘法  
torch.mv 矩阵向量乘法  
变换  
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\])  
1  
2  
3  
4  
5  
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\])  
1  
2  
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\])  
1  
2  
3  
4  
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个维度  
1  
2  
3  
4  
5  
6  
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\]\]  
1  
2  
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\]\])  
1  
2  
3  
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  
1  
2  
3  
4  
因此，在调用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\])  
1  
2  
常用层  
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)  
)  
1  
2  
3  
4  
5  
6  
7  
8  
nn.Linear()  
参数：输入维度，输出维度

nn.Linear(dim\_in,dim\_out)  
1  
y=xWT+b y=xW^\{T\}+by=xW  
T  
\+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))

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
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  
1  
2  
3  
4  
5  
6  
7  
8  
9  
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)  
1  
归一化层  
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)  
1  
2  
3  
4  
5  
6  
池化层  
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)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
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)  
1  
2  
3  
4  
常用激活函数  
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  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
常用损失函数  
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)  
————————————————  
版权声明：本文为CSDN博主「sherpahu」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/sherpahu/article/details/95935845