1 张量的数据操作

1.1 torch.reshape()实现数据维度变化

import torch
a = torch.tensor([[1,2],[3,4]])
print(torch.reshape(a,(1,-1))) # 将其转化为只有1行数据的张量,参数-1表示自动计算
# tensor([[1, 2, 3, 4]])
print(a.reshape((1,-1))) # # 将其转化为只有1行数据的张量,参数-1表示自动计算
# tensor([[1, 2, 3, 4]])
print(a.view((1,-1))) # # 将其转化为只有1行数据的张量,参数-1表示自动计算
# tensor([[1, 2, 3, 4]])

1.2 张量数据的矩阵转置

import torch
b = torch.tensor([[5,6,7],[2,8,0]]) # 定义二维张量
print(torch.t(b)) # 转置矩阵
# 输出 tensor([[5, 2],
#         [6, 8],
#         [7, 0]])
print(torch.transpose(b,dim0=1,dim1=0)) # 转置矩阵，将原有数据的第1个维度切换到第0个维度
# 输出 tensor([[5, 2],
#         [6, 8],
#         [7, 0]])
print(b.permute(1,0)) # 转置矩阵，将原有数据的第1个维度切换到第0个维度
# 输出 tensor([[5, 2],
#         [6, 8],
#         [7, 0]])

1.3 view()与contignous()方法

1.3.1 概述

view()只能作用于整块内存上的张量，若对于非连续内存上的张量则不可以用该函数处理。也无法对transpose()与permute()等改变后的张量再进行变化。

view()需要与contiguous()进行连用，进而保证该张量在同一个内存块中。

1.3.2 代码

import torch
b = torch.tensor([[5,6,7],[2,8,0]]) #定义二维张量
print(b.is_contiguous()) #判断内存是否连续
# 输出 True
c = b.transpose(0,1)
print(c.is_contiguous()) #判断内存是否连续
# 输出 False
print(c.contiguous().is_contiguous()) #判断内存是否连续
# 输出 True
print(c.contiguous().view(-1)) #判断内存是否连续
# 输出 tensor([5, 2, 6, 8, 7, 0])

1.4 torch.cat()数据拼接函数

1.4.1 概述

torch.cat()函数会实现将两个张量沿着指定方向进行拼接===》在神经网络中较为常见

1.4.2 代码

import torch
a = torch.tensor([[1,2],[3,4]]) #定义二维张量
b = torch.tensor([[5,6],[7,8]])print(torch.cat([a,b],dim=0)) #沿着0维度进行连接
# 输出 tensor([[1, 2],
#         [3, 4],
#         [5, 6],
#         [7, 8]])
print(torch.cat([a,b],dim=1)) #沿着1维度进行连接
# 输出 tensor([[1, 2, 5, 6],
#         [3, 4, 7, 8]])

1.5 torch.chunk()实现数据的均匀分割

1.5.1 概述

torch.chunk()将一个多维张量按照指定的维度和拆分数量进行分割，其返回值是元组，不可修改。

1.5.2 代码

import torch
a = torch.tensor([[1,2],[3,4]])print(torch.chunk(a,chunks=2,dim=0)) #将张量a按照第0维度分成两个部分
# 输出 (tensor([[1, 2]]), tensor([[3, 4]]))
print(torch.chunk(a,chunks=2,dim=1)) #将张量a按照第1维度分成两个部分
# 输出 (tensor([[1],[3]]), tensor([[2],[4]]))

1.6 torch.split()实现数据的不均匀分割

import torch
b = torch.tensor([[5,6,7],[2,8,0]])
#按照第1维度分成2个部分
### split_size_or_sections 将按照指定的元素个数对张量数据进行数据拆分，不满足个数的剩余数据将会作为分割数据的最后一部分
print(torch.split(b,split_size_or_sections=(1,2),dim=1) )
# 输出 (tensor([[5],[2]]), tensor([[6, 7],[8, 0]]))

1.7 torch.gather()对张量数据进行检索

1.7.1 概述

torch.gather()对于张量数据中的值按照指定的索引与顺序进行排列，index参数必须是张量类型，要与输入的维度相同

1.7.2 代码

import torch
b = torch.tensor([[5,6,7],[2,8,0]])
# 沿着第1维度，按照index的形状进行取值排列
print(torch.gather(b,dim=1,index=torch.tensor([[1,0],[1,2]])))
#输出 tensor([[6, 5],[8, 0]])# 沿着第0维度，按照index的形状进行取值排列
print(torch.gather(b,dim=0,index=torch.tensor([[1,0,0]])))
#输出 tensor([[2, 6, 7]])print(torch.index_select(b,dim=0,index=torch.tensor(1))) #取出整行或者整列
#输出 tensor([[2, 8, 0]])

1.8 按照指定的阈值对于张量数据进行过滤展示

1.8.1 概述

torch.gt()：大于

torch.ge()：大于或等于

torch.lt()：小于

torch.le()：小于或等于

1.8.2 代码

import torch
b = torch.tensor([[1,2],[2,8]])
mask = b.ge(2) #大于或者等于2
print(mask)
# 输出 tensor([[False,  True],
#         [ True,  True]])
print(torch.masked_select(b,mask))
# 输出 tensor([2, 2, 8])

1.9 找出张量中的非零数值的索引

import torch
eye = torch.eye(3) # 生成一个对角矩阵
print(eye)
# 输出 tensor([[1., 0., 0.],
#         [0., 1., 0.],
#         [0., 0., 1.]])
print(torch.nonzero(eye)) # 找出对角矩阵中的非零值索引
# 输出 tensor([[0, 0],
#         [1, 1],
#         [2, 2]])

1.10 根据条件实现对张量的数值取值

import torch
b = torch.tensor([[5,6,7],[2,8,0]])
c = torch.ones_like(b) #生成数值均为1的矩阵
print(c)
# 输出 tensor([[1, 1, 1],
#           [1, 1, 1]])
print(torch.where(b>5,b,c)) #将b中大于5的元素提取出来，值不大于5的部分从c中取得
# 输出 tensor([[1, 6, 7],
#            [1, 8, 1]])

1.11 根据阈值进行数据截断

1.11.1 概述

根据阈值进行数据截断===》用于梯度计算中，为梯度设置一个固定的阈值，避免训练过程中的梯度爆炸。

梯度爆炸：模型每次训练的调整值变得很大，最终导致训练结果难以收敛。

1.11.2 代码

import torch
a = torch.tensor([[1,2],[3,4]])
b = torch.clamp(a,min=2,max=3) #按照最小值2，最大值3进行截断
print(b)
# 输出 tensor([[2, 2],
#              [3, 3]])

1.12 获取数据中的最大值、最小值索引

1.12.1 概述

torch.argmax()：返回最大索引

torch.argmin()：返回最小索引

1.12.2 代码

import torch
a = torch.tensor([[1,2],[3,4]])
print(torch.argmax(a,dim=0)) # 按照第0维度找出最大索引值
# 输出 tensor([1, 1])
print(torch.argmin(a,dim=1)) # 按照第1维度找出最小索引值
# 输出 tensor([0, 0])
print(torch.max(a,dim=0)) # 按照第0维度找出最大索引值与对应数值
# 输出  torch.return_types.max(values=tensor([3, 4]),indices=tensor([1, 1]))
print(torch.min(a,dim=1)) # 按照第1维度找出最小索引值与对应数值
# 输出 torch.return_types.min(values=tensor([1, 3]),indices=tensor([0, 0]))