Pytorch数据类型Tensor张量操作的实现
作者：独行的喵
本文只简单介绍pytorch中的对于张量的各种操作，主要列举介绍其大致用法和简单demo。后续更为详细的介绍会进行补充…
一.创建张量的方式
1.创建无初始化张量
- torch.empty(3, 4) 创建未初始化内存的张量
2.创建随机张量
- x = torch.rand(3, 4) 服从0~1间均匀分布
- x = torch.randn(3, 4) 服从（0，1）的正态分布
- x = torch.rand_like(y) 以rand方式随机创建一个和y形状相同的张量
- x = torch.randint(1, 10, [3, 3]) 创建元素介于[1,10)的形状为（3，3）的随机张量
3.创建初值为指定数值的张量
- x = torch.zeros(3, 4) 生成形状为(3,4)的初值全为0的张量
- x = torch.full([3, 4], 6) 生成形状为(3,4)的初值全为6的张量
- x = torch.eye(5, 5) 生成形状为(5,5)的单位阵
4.从数据创建张量
- x = torch.tensor([1, 2, 3, 4, 5, 6]) 接收数据
- torch.Tensor(3, 4) 接收tensor的维度
5.生成等差数列张量
- x = torch.arange(0, 10) 生成[0,10)公差为1的等差数列张量
- x = torch.arange(0, 10, 3) 生成[0,10)公差为3的等差数列张量
二.改变张量形状
view()与reshape()方法功能用法完全一致
通过传入改变后每一个维度的大小来重塑张量的形状：
x = x.view(2, 3) x = x.reshape(2, 3)
view和reshape操作的示例：
a = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8]) b = a.reshape(2, 4) c = a.view(2, 4) print(b) print(c)
三.索引
y = x.index_select(0, torch.tensor([0, 2]))
第一个参数表示选择的维度，第二个参数以tensor的形式传入，选择该维度中的指定索引index
x = torch.tensor([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
])
y = x.index_select(0, torch.tensor([0, 2]))
print(y)
y = x.index_select(1, torch.tensor([1, 2]))
print(y)
根据掩码获得打平后的指定索引张量：
mask = x.ge(5) y = torch.masked_select(x, mask)
通过比较运算获得一个mask索引，然后将mask索引传入masked_select方法来获得打平后的新张量，具体示例如下：
x = torch.tensor([
[1, 2, 0, 2],
[3, 6, 1, 9],
[-1, 7, -8, 1],
])
mask = x.ge(5)
y = torch.masked_select(x, mask)
print(y)
mask = x.gt(0)
y = torch.masked_select(x, mask)
print(y)
mask = x.lt(1)
y = torch.masked_select(x, mask)
print(y)
四.维度变换
1.维度增加unsqueeze
unsqueeze操作可以让张量在指定非负维度前插入新的维度，在负维度后插入新的维度，传入参数n表示指定的维度，即n若大于等于0则在n前插入新的维度，若n小于0则在n后插入新的维度：
x.unsqueeze(n)
假设原张量x的shape为(4,3,28,28)，使用x.unsqueeze(0) 在0维度前插入新的维度后，张量的shape变为(1,4,3,28,28)。原张量y的shape为(2),使用y.unsqueeze(1)在维度1前插入新的维度后，张量的shape变为(2,1)。代码示例如下：
x = torch.randint(1, 10, [4, 3, 28, 28])
print(f"original shape: {x.shape}")
x = x.unsqueeze(0)
print(f"unsqueezed in dim 0: {x.shape}")
print("----------------------------------")
y = torch.tensor([3, 4])
print(f"original shape: {y.shape}")
m = y.unsqueeze(1)
print(f"unsqueezed in dim 1: {m.shape}\n{m}")
n = y.unsqueeze(0)
print(f"unsqueezed in dim 0: {n.shape}\n{n}")运行结果：
2.维度扩展expand
x.expand(a, b, c, d) 操作将原来维度扩展为(a，b ，c ，d),传入n个参数a，b，c，d…表示维度扩展后的形状，其中当传入的维度上的参数为-1时表示该维度保持不变。
x.expand(a, b, c, d)
使用expand只能扩张原来大小为1的维度，该维度扩张为n后的张量将在该维度上将数据复制n次，将原shape为(1,3,1)的张量扩展为shape为(2,3,4)的张量：
x = torch.randint(0, 2, [1, 3, 1])
y = x.expand(2, 3, 4)
print(f"original tensor in dim(1,3,1):\n{x}")
print(f"expanded tensor in dim(2,3,4):\n{y}")运行结果：
3.维度减少squeeze
x.squeeze(）操作可以压缩张量的维度，当不传入任何参数时，squeeze()操作压缩所有可以压缩的维度，当传入指定参数时，参数可以是负数，将压缩张量的指定维度。
x.squeeze() x.squeeze(n)
x = torch.tensor([1, 2, 3, 4, 5, 6])
y = x.unsqueeze(1).unsqueeze(2).unsqueeze(0)
print(f"original shape : {y.shape}")
print(f"squeezed in all dim: {y.squeeze().shape}")
print(f"squeezed in dim 0: {y.squeeze(0).shape}")
print(f"squeezed in dim 1: {y.squeeze(1).shape}")运行结果：
4.维度扩展repeat
x.repeat(a,b,c,d) 在原来维度上分别拷贝a,b,c,d次
x.repeat(a, b, c, d)
原张量x的shape为(1,2,1),通过执行repeat(2,1,2)操作后shape变为(2,2,2)，再通过repeat(1,3,5)操作后shape变为(2,6,10):
x = torch.tensor([1, 2]).reshape(1, 2, 1)
y = x.repeat(2, 1, 2)
z = y.repeat(1, 3, 5)
print(f"original tensor in dim(1,2,1): \n{x}")
print(f"repeated tensor in dim(2,2,2): \n{y}")
print(f"repeated tensor in dim(2,6,10): \n{z}")
五.维度交换
1.简单的二维转置函数t:
x.t()
2.交换任意两个维度transpose
x = torch.randint(1, 10, [2, 4, 3])y = x.transpose(0, 2)print(f"original tensor in shape(2,4,3):\n{<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->x}")print(f"transposed tensor in shape(3,4,2):\n{<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->y}")x = torch.randint(1, 10, [2, 4, 3])
y = x.transpose(0, 2)
print(f"original tensor in shape(2,4,3):\n{x}")
print(f"transposed tensor in shape(3,4,2):\n{y}")
3.重新排列原来的维度顺序permute
permute操作用于重新排列维度顺序，传入的参数代表维度的索引，即dim a，dim b…
x.permute(a, b, c, d)
x.permute(1,2,0)的意义是将原来的1维度放到0维度的位置，将原来的2维度放到1维度的位置，将原来的0维度放到2维度的位置，以此重新排列维度顺序：
x = torch.tensor([
[
[1, 2, 3, 1],
[4, 5, 3, 6],
[1, 1, 0, 1]
],
[
[7, 8, 9, 1],
[0, 2, 0, 3],
[6, 5, 1, 8],
]
])
y = x.permute(1, 2, 0)
print(f"original shape: {x.shape}")
print(f"permuted shape: {y.shape}")
print(f"permuted tensor:\n{y}")
六.张量合并
1.cat操作
代码示例：
torch.cat([a,b], dim=0)
cat()函数中首先传入一个列表[a, b, c…]表示要合并的张量集合，然后传入一个维度dim=n，表示将这些张量在维度n上进行合并操作。
注意concat操作合并的维度上两个张量的维度大小可以不同，但是其余维度上必须具有相同的大小，例如(3,4,5)可以和(2,4,5)在0维度上concat合并为(5,4,5)。但是不能在1维度上合并，因为0维度上两个张量的维度大小不同，分别为3和2。
x = torch.tensor([
[
[1, 2, 3, 1],
[4, 5, 3, 6],
[1, 1, 0, 1]
],
[
[7, 8, 9, 1],
[0, 2, 0, 3],
[6, 5, 1, 8],
]
])
y = x.permute(1, 2, 0)
print(f"original shape: {x.shape}")
print(f"permuted shape: {y.shape}")
print(f"permuted tensor:\n{y}")运行结果：
2.stack操作
stack操作在合并维度处创建一个新的维度。
代码示例：
torch.stack([a, b], dim=0)
tensorA = torch.tensor([
[1, 2, 3],
[4, 5, 6]
])
tensorB = torch.tensor([
[7, 8, 9],
[3, 2, 1]
])
print(f"tensorA.shape:{tensorA.shape}")
print(f"tensorB.shape:{tensorB.shape}")
print("try to stack A with B in dim0:")
tensorC = torch.stack([tensorA, tensorB], dim=0)
print(f"tensorC.shape:{tensorC.shape}\n{tensorC}\n--------------------------")
print("try to stack A with B in dim1:")
tensorC = torch.stack([tensorA, tensorB], dim=1)
print(f"tensorC.shape:{tensorC.shape}\n{tensorC}\n--------------------------")
print("try to stack A with B in dim2:")
tensorC = torch.stack([tensorA, tensorB], dim=2)
print(f"tensorC.shape:{tensorC.shape}\n{tensorC}\n--------------------------")
print("try to stack A with B in dim3:")
tensorC = torch.stack([tensorA, tensorB], dim=3)
print(f"tensorC.shape:{tensorC.shape}")
print(tensorC)运行结果：
七.张量的分割
1.split操作
split操作是对张量在指定维度上将张量进行分割，可以按给定长度等分，也可以通过列表传入分割方法。下面两种分割方式结果是相同的，第一种方式是将张量x在维度0上按照每一份长度为1进行等分；第二种方式是按照长度[1, 1, 1]的模式将张量x分成三份。
a, b, c = x.split(1, dim=0) a, b, c = x.split([1, 1, 1], dim=0)
x = torch.tensor([
[
[1, 2, 1, 3],
[0, 1, 2, 1],
[9, 8, 1, 2]
],
[
[1, 2, 1, 2],
[4, 2, 4, 4],
[1, 0, 0, 0]
],
[
[3, 3, 3, 1],
[1, 0, 2, 3],
[5, 1, 2, 5]
]
])
print(x.shape)
a, b, c = x.split(1, dim=0)
print(f"a.shape:{a.shape}\nb.shape:{b.shape}\nc.shape:{c.shape}")
print("------------------------------------")
a, b = x.split([1, 2], dim=0)
print(f"a.shape:{a.shape}\nb.shape:{b.shape}")
2.chunk操作
chunk操作是对张量的某一维度按数量进行分割,首先传入第一个参数代表要分割成的份数，第二个参数指定了在哪一个维度上分割，下面的API样例代表将张量在维度0上分割为3个张：
a, b, c = x.chunk(3, dim=0)
对上例split中的张量x用chunk做分割的示例如下：
a, b, c = x.chunk(3, dim=1)
print(a.shape)
print(b.shape)
print(c.shape)
print("---------------------")
a, b = x.chunk(2, dim=2)
print(a.shape)
print(b.shape)
到此这篇关于Pytorch数据类型Tensor张量操作的实现的文章就介绍到这了,更多相关Pytorch数据类型Tensor张量操作的实现内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！