pytorch 常用函数总结

Re:fused

已于 2022-03-20 15:36:26 修改

阅读量5.5k

点赞数 17

分类专栏：知识图谱补全文章标签： pytorch 深度学习 python

于 2022-03-11 19:25:01 首次发布

本文链接：https://blog.csdn.net/REfusing/article/details/123431267

版权

知识图谱补全专栏收录该内容

14 篇文章 14 订阅

订阅专栏

在进行使用pytorch进行数据处理的使用，对于其中涉及的函数不是特别了解，导致在使用的时候，需要不断的翻阅资料，去查找某个方法如何使用，对于其产生的结果不是十分了解。以下对于pytorch中我遇到的常用函数进行归纳总结，并不进行完善，以供学习。

1 常用的几种参数总结

1.1 dim参数

dim 这一参数通常指的是维度，其维度设置如下图所示：
在这里插入图片描述
图片源于【PyTorch】PyTorch 中的 dim
其中参考实例如下：

import torch
a = torch.Tensor([[[1, 2, 3],[7, 8, 9]],
                  [[4, 5, 6],[1, 1, 1]]])
print(a.sum(dim = 0))
print(a.sum(dim = 1))
print(a.sum(dim = 2))
#结果
tensor([[ 5.,  7.,  9.],
        [ 8.,  9., 10.]])
tensor([[ 8., 10., 12.],
        [ 5.,  6.,  7.]])
tensor([[ 6., 24.],
        [15.,  3.]])

1.2 keepdim参数

顾名思义，保持keepdim的维度，具体示例如下图所示：

import torch
a = torch.Tensor([[1, 2, 3],[7, 8, 9],
                  [4, 5, 6],[1, 1, 1]])
print(a.sum(dim = 0, keepdim = True))
print(a.sum(dim = 0))
#结果
tensor([[13., 16., 19.]])
tensor([13., 16., 19.])

2 torch.cat和torch.chunk

这两个函数在使用的时候，正好相反，torch.cat将张量进行组合，而torch.chunk将张量进行拆分。

2.1 torch.cat

torch.cat是将两个张量（tensor）拼接在一起，cat是concatnate的意思，即拼接，联系在一起。
outputs = torch.cat(inputs, dim=?) → Tensor
示例参考：torch.cat() 函数用法

C = torch.cat( (A,B),0 )  #按维数0拼接（竖着拼）
C = torch.cat( (A,B),1 )  #按维数1拼接（横着拼）

具体使用：

>>> import torch
>>> A=torch.ones(2,3) #2x3的张量（矩阵）                                     
>>> A
tensor([[ 1.,  1.,  1.],
        [ 1.,  1.,  1.]])
>>> B=2*torch.ones(4,3)#4x3的张量（矩阵）                                    
>>> B
tensor([[ 2.,  2.,  2.],
        [ 2.,  2.,  2.],
        [ 2.,  2.,  2.],
        [ 2.,  2.,  2.]])
>>> C=torch.cat((A,B),0)#按维数0（行）拼接
>>> C
tensor([[ 1.,  1.,  1.],
         [ 1.,  1.,  1.],
         [ 2.,  2.,  2.],
         [ 2.,  2.,  2.],
         [ 2.,  2.,  2.],
         [ 2.,  2.,  2.]])
>>> C.size()
torch.Size([6, 3])
>>> D=2*torch.ones(2,4) #2x4的张量（矩阵）
>>> C=torch.cat((A,D),1)#按维数1（列）拼接
>>> C
tensor([[ 1.,  1.,  1.,  2.,  2.,  2.,  2.],
        [ 1.,  1.,  1.,  2.,  2.,  2.,  2.]])
>>> C.size()
torch.Size([2, 7])

注意咋使用时合并的维度必须符合要求，如上例所示。

2.2 torch.chunk

torch.chunk(tensor, chunk_num, dim)与torch.cat()原理相反，它是将tensor按dim（行或列）分割成chunk_num个tensor块，返回的是一个元组。
示例：

c = torch.tensor([[1., 2., 4.],
        [4., 5., 7.],
        [3., 9., 8.],
        [9., 6., 7.]])
 #在dim=1这一个维度进行拆分， chunk_num是拆分的块数，当其大于等于dim=1中元
 #素的个数n, 则拆成n块，小于则平分。
 torch.chunk(c,4,dim = 1)
 结果：
 (tensor([[1.],
         [4.],
         [3.],
         [9.]]),
 tensor([[2.],
         [5.],
         [9.],
         [6.]]),
 tensor([[4.],
         [7.],
         [8.],
         [7.]]))
torch.chunk(c,3,dim = 1)
结果：
(tensor([[1.],
         [4.],
         [3.],
         [9.]]),
 tensor([[2.],
         [5.],
         [9.],
         [6.]]),
 tensor([[4.],
         [7.],
         [8.],
         [7.]]))
torch.chunk(c,2,dim = 1)
结果：
(tensor([[1., 2.],
         [4., 5.],
         [3., 9.],
         [9., 6.]]),
 tensor([[4.],
         [7.],
         [8.],
         [7.]]))

3 squeeze和unsequeeze

先看torch.squeeze() 这个函数主要对数据的维度进行压缩，去掉维数为1的的维度，比如是一行或者一列这种，一个一行三列（1,3）的数去掉第一个维数为一的维度之后就变成（3）行。squeeze(a)就是将a中所有为1的维度删掉。不为1的维度没有影响。a.squeeze(N) 就是去掉a中指定的维数为一的维度。还有一种形式就是b=torch.squeeze(a，N) a中去掉指定的定的维数为一的维度。
再看torch.unsqueeze()这个函数主要是对数据维度进行扩充。给指定位置加上维数为一的维度，比如原本有个三行的数据（3），在0的位置加了一维就变成一行三列（1,3）。a.squeeze(N) 就是在a中指定位置N加上一个维数为1的维度。还有一种形式就是b=torch.squeeze(a，N) a就是在a中指定位置N加上一个维数为1的维度
参考博客：pytorch学习中 torch.squeeze() 和torch.unsqueeze()的用法

3.1 squeeze

示例：

c = torch.tensor([[[1., 2., 4.],
        [4., 5., 7.],
        [3., 9., 8.],
        [9., 6., 7.]]])
c.shape
#torch.Size([1, 4, 3])
b = c.squeeze(0)
print(b, b.shape)
tensor([[1., 2., 4.],
        [4., 5., 7.],
        [3., 9., 8.],
        [9., 6., 7.]]) torch.Size([4, 3])

3.2 unsqueeze

示例：

c = torch.tensor([[1., 2., 4.],
        [4., 5., 7.],
        [3., 9., 8.],
        [9., 6., 7.]])
c.shape
#torch.Size([4, 3])
b = c.unsqueeze(1)
print(b, b.shape)
tensor([[[1., 2., 4.]],

        [[4., 5., 7.]],

        [[3., 9., 8.]],

        [[9., 6., 7.]]]) torch.Size([4, 1, 3])

4 数据处理

数据处理主要讲解TensorDataset，Dataset的自定义，以及DataLoader，其在使用是先使用Dataset类型的函数，再与DataLoader配合使用从而实现获取batch的处理。TensorDataset处理比较简单的数据，而复杂的数据，则进行Dataset的自定义。

4.1 TensorDataset

TensorDataset将简单的数据进行绑定，使其相对应的数据何以同时获取。

from torch.utils.data import TensorDataset
import torch
from torch.utils.data import DataLoader
 
a = torch.tensor([[11, 22, 33], [44, 55, 66], [77, 88, 99], [11, 22, 33], [44, 55, 66], [77, 88, 99], [11, 22, 33], [44, 55, 66], [77, 88, 99], [11, 22, 33], [44, 55, 66], [77, 88, 99]])
b = torch.tensor([0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2])
train_ids = TensorDataset(a, b)

train_loader = DataLoader(dataset=train_ids, batch_size=4, shuffle=True)
for i, data in enumerate(train_loader, 1):  # 注意enumerate返回值有两个,一个是序号，一个是数据（包含训练数据和标签）
    x_data, label = data
    print(' batch:{0} x_data:{1}  label: {2}'.format(i, x_data, label))

在这里插入图片描述

4.2 Dataset

Dataset主要用于自定义类型，实现不同的复杂类型，其核心点在两个基础的函数

__len__：一般用来返回数据集大小。
__getitem__：实现这个方法后，可以通过下标的方式 dataset[i] 的来取得第 i 个数据。

具体使用方法，如下：

#创建子类
class subDataset(Dataset.Dataset):
    #初始化，定义数据内容和标签
    def __init__(self, Data, Label):
        self.Data = Data
        self.Label = Label
    #返回数据集大小
    def __len__(self):
        return len(self.Data)
    #得到数据内容和标签
    def __getitem__(self, index):
        data = torch.Tensor(self.Data[index])
        label = torch.Tensor(self.Label[index])
        return data, label

4.3 DataLoader

对来自Dataset的数据进行shuffle和batch等操作。

loader = Data.DataLoader(
    dataset=torch_dataset,      # torch TensorDataset format
    batch_size=BATCH_SIZE,      # mini batch size
    shuffle=True,               # 要不要打乱数据 (打乱比较好)
    num_workers=2,              # 多线程来读数据
)
for step, (batch_x, batch_y) in enumerate(loader):
	print(batch_x, batch_y)

4.4 单独shuffle

当我们处理完的数据，需要进行shuffle时，不能采用上述操作DataLoader进行shuffle时，我们可以采用其他的方法进行shuffle，采用random类中的shuffle函数数据进行shuffle。

import torch
from random import shuffle
a = torch.Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])
print("原始数据:", a)
index = [i for i in range(a.shape[0])]
shuffle(index)
print(index)
print("shuffle之后的数据：",a[index])

在这里插入图片描述

5 torch.sum 和torch.mean

5.1 torch.sum

参考博客：（pytorch）torch.sum的用法及dim参数的使用
１．torch.sum(input, dtype=None)
２．torch.sum(input, list: dim, bool: keepdim=False, dtype=None) → Tensor
input:输入一个tensor
dim:要求和的维度，可以是一个列表
keepdim:求和之后这个dim的元素个数为１，所以要被去掉，如果要保留这个维度，则应当keepdim=True

import torch

a = torch.ones((2, 3))
a1 =  torch.sum(a)
a2 =  torch.sum(a, dim=0)
a3 =  torch.sum(a, dim=1)

print(a)
print(a1)
print(a2)
print(a3)

在这里插入图片描述

5.2 torch.mean

参考博客：
mean()函数的参数：dim=0,按列求平均值，返回的形状是（1，列数）；dim=1,按行求平均值，返回的形状是（行数，1）,默认不设置dim的时候，返回的是所有元素的平均值。

x=torch.arange(12).view(4,3)
'''
注意：在这里使用的时候转一下类型，否则会报RuntimeError: Can only calculate the mean of floating types. Got Long instead.的错误。
查看了一下x元素类型是torch.int64,根据提示添加一句x=x.float()转为tensor.float32就行
'''
x=x.float()
x_mean=torch.mean(x)
x_mean0=torch.mean(x,dim=0,keepdim=True)
x_mean1=torch.mean(x,dim=1,keepdim=True)
print('x:')
print(x)
print('x_mean0:')
print(x_mean0)
print('x_mean1:')
print(x_mean1)
print('x_mean:')
print(x_mean)
x:
tensor([[ 0.,  1.,  2.],
        [ 3.,  4.,  5.],
        [ 6.,  7.,  8.],
        [ 9., 10., 11.]])
x_mean0:
tensor([[4.5000, 5.5000, 6.5000]])
x_mean1:
tensor([[ 1.],
        [ 4.],
        [ 7.],
        [10.]])
x_mean:
tensor(5.5000)

6 增加维度

参考博客：np.append()函数用法
函数np.append(arr, values, axis=None)
作用：为原始array添加一些values
参数：

arr:需要被添加values的数组
values:添加到数组arr中的值（array_like，类数组）
axis:可选参数，如果axis没有给出，那么arr，values都将先展平成一维数组。注：如果axis被指定了，那么arr和values需要有相同的shape，否则报错。
补充对axis的理解
axis的最大值为数组arr的维数-1，如arr维数等于1，axis最大值为0；arr维数等于2，axis最大值为1，以此类推。
当arr的维数为2(理解为单通道图)，axis=0表示沿着行方向添加values；axis=1表示沿着列方向添加values
当arr的维数为3(理解为多通道图)，axis=0，axis=1时同上；axis=2表示沿着深度方向添加values

具体使用

不考虑axis
arr，values都将先展平成一维数组,然后沿着axis=0的方向在arr后添加value

import numpy as np
a=[1,2,3]
b=[4,5]
c=[[6,7],[8,9]]
print(np.append(a,b))
print(np.append(a,c))
#结果
[1 2 3 4 5]
[1 2 3 6 7 8 9]

考虑axis
arr,values的shape相同


import numpy as np
a=[1,2,3]
b=[4,5]
c=[[6,7],[8,9]]
d=[[10,11],[12,13]]
print('在一维数组a后添加values,结果如下：{}'.format(np.append(a,b,axis=0)))
print('沿二维数组c的行方向添加values结果如下：'.format(np.append(c,d,axis=0)))
print('沿二维数组c的列方向添加values结果如下：'.format(np.append(c,d,axis=1)))
print('使用了axis，若arr和values的形状不同，则报错：'.format(np.append(a,c,axis=0))
#结果
在一维数组a后添加values,结果如下：
[1 2 3 4 5]
沿二维数组c的行方向添加values结果如下：
[[ 6  7]
 [ 8  9]
 [10 11]
 [12 13]]
沿二维数组c的列方向添加values结果如下：
[[ 6  7 10 11]
 [ 8  9 12 13]

考虑axis，如果arr和values的形状不同，则报错：

import numpy as np
a=[1,2,3]
c=[[6,7],[8,9]]
print(np.append(a,c,axis=0))
#结果
Traceback (most recent call last):
  File "F:\eclipse-workspace\test\t1.py", line 4, in <module>
    print(np.append(a,c,axis=0))
  File "E:\anaconda\anzhuang\lib\site-packages\numpy\lib\function_base.py", line 4694, in append
    return concatenate((arr, values), axis=axis)
ValueError: all the input arrays must have same number of dimensions

7 张量乘法

7.1 torch.mm

该方法用于矩阵乘法，mat1 是(n×m) 的张量, mat2是(m×p)的张量, out结果将是(n×p) 的张量。

torch.mm(mat1, mat2, *, out=None) → Tensor
注意：mat1和mat1只能是矩阵matrix, 并且无法只用广播机制

示例：

a = torch.arange(1, 13).reshape( 6, 2).long()
print(a)
b = torch.Tensor([[1],[1]]).long()
print(b)
print(torch.mm(a, b))
#结果：
tensor([[ 1,  2],
        [ 3,  4],
        [ 5,  6],
        [ 7,  8],
        [ 9, 10],
        [11, 12]])
tensor([[1],
        [1]])
tensor([[ 3],
        [ 7],
        [11],
        [15],
        [19],
        [23]])

7.2 torch.matmul

该方法支持张量乘法，可以实现广播机制，参考博客:torch.matmul()用法介绍

torch.matmul(input, other, *, out=None) → Tensor

7.3 torch.mul

其方法与*在使用时没有区别，可以进行广播。

torch.mul(input, other, *, out=None) → Tensor

Re:fused

关注

17
点赞
踩
63

收藏

觉得还不错? 一键收藏
1
评论
pytorch 常用函数总结

在进行使用pytorch进行数据处理的使用，对于其中涉及的函数不是特别了解，导致在使用的时候，需要不断的翻阅资料，去查找某个方法如何使用，对于其产生的结果不是十分了解。以下对于pytorch中我遇到的常用函数进行归纳总结，并不进行完善，以供学习。1 常用的几种参数总结1.1 dim参数dim 这一参数通常指的是维度，其维度设置如下图所示：图片源于【PyTorch】PyTorch 中的 dim其中参考实例如下：import torcha = torch.Tensor([[[1, 2, 3
复制链接

扫一扫

专栏目录