pytorch之张量
文章目录
- 张量 torch.Tensor
-
- 张量的创建
- 张量形状相关函数
- 张量相关运算API
- 张量的极值和排序
- 矩阵乘法和张量的缩并
- 张量的拼接和分割
- 张量维度的扩增和压缩
张量 torch.Tensor
torch.Tensor是一种包含单一数据类型元素的多维矩阵。
| 数据类型 | Pytorch类型 | CPU上的张量 | GPU上的张量 |
|---|---|---|---|
| 32位浮点数 | torch.float32 torch.float |
torch.FloatTensor | torch.cuda.FloatTensor |
| 64位浮点数 | torch.float64 torch.double |
torch.DoubleTensor | torch.cuda.DoubleTensor |
| 16位浮点数 | torch.float16 torch.half |
torch.HalfTensor | torch.cuda.HalfTensor |
| 8位无符号整数 | torch.uint8 | torch.ByteTensor | torch.cuda.ByteTensor |
| 8位带符号整数 | torch.int8 | torch.CharTensor | torch.cuda.CharTensor |
| 16位带符号整数 | torch.int16 torch.short |
torch.ShortTensor | torch.cuda.ShortTensor |
| 32位带符号整数 | torch.int32 torch.int |
torch.IntTensor | torch.cuda.IntTensor |
| 64位带符号整数 | torch.int64 torch.long |
torch.LongTensor | torch.cuda.LongTensor |
| 布尔型 | torch.bool | torch.BoolTensor | torch.cuda.BoolTensor |
张量的创建
import torch
# torch.Tensor函数创建张量
torch.tensor([1,2,3,4])
# 指定形状生成张量
torch.rand(3,3) #生成3*3的矩阵，矩阵元素服从[0,1)的均匀分布
tensor([[0.2840, 0.3847, 0.3832],
[0.1252, 0.3213, 0.5853],
[0.5024, 0.8113, 0.7379]])
torch.randn(2,3,4) #生成2*3*4的张量，张量元素服从标准正太分布
tensor([[[-0.2611, -1.8370, 2.0686, -0.4847],
[ 0.0294, 0.0401, -0.7384, -1.4130],
[ 0.5026, 1.6850, 0.8888, 0.1861]],
[[-0.4993, -0.8312, 0.5838, -0.7682],
[ 0.1210, 0.2984, -0.0603, 0.9805],
[ 0.1415, 1.0772, -0.3144, 0.2104]]])
torch.zeros(2,2,2) #生成2*2*2的张量，张量元素全为0
tensor([[[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.]]])
torch.ones(1,2,3) #生成1*2*3的张量，张量元素全为1
tensor([[[1., 1., 1.],
[1., 1., 1.]]])
torch.eye(3) #生成3*3的单位矩阵
tensor([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
torch.randint(0,10,(3,3)) #生成0(包含)到10(不含)之间均匀分布整数的3*3矩阵
tensor([[3, 1, 6],
[3, 8, 9],
[3, 4, 5]])
# 通过已知张量创建形状相同的张量
t = torch.randn(3*3)
torch.zeros_like(t) #生成一个元素全为0的张量，形状和t相同
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0.])
torch.ones_like(t) #生成一个元素全为1的张量，形状和t相同
tensor([1., 1., 1., 1., 1., 1., 1., 1., 1.])
torch.rand_like(t) #生成一个服从从[0,1)上均匀分布的张量，形状和给定张量t相同
tensor([0.1028, 0.1721, 0.2348, 0.1490, 0.8338, 0.8679, 0.3076, 0.6863, 0.4816])
torch.randn_like(t) #生成一个元素服从标准正太分布的张量，形状和给定张量t相同
tensor([ 1.2402, 0.0505, 1.6948, -1.1413, -0.0042, 0.3968, 1.7340, 0.3044,
0.1969])
# 通过已知张量创建形状不同但数据类型相同的张量
t.new_tensor([1,2,3]).dtype
torch.float32
t.new_zeros(3,3) # 生成相同类型且元素全为0的张量
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
t.new_ones(3,3) #生成相同类型且元素全为1的张量
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
张量形状相关函数
t = torch.randn(3,4,5) #生成一个3*4*5的一个张量
t.ndimension() #获取维度的数目
3
t.nelement() #获取该张量的总元素数目
60
t.size() #获取该张量每个维度的大小，调用方法
torch.Size([3, 4, 5])
t.shape #获取该张量每个维度的大小，访问属性
torch.Size([3, 4, 5])
t.size(0) #获取该张量维度为0的大小，调用方法
3
t = torch.randn(12) #产生大小为12的向量
#view()方法不改变底层数据，改变view后张量会改变原来的张量
t.view(3,4) #向量改变形状为3*4的矩阵
tensor([[ 0.3067, -0.4927, 0.2934, -0.9114],
[ 1.5307, -1.4519, 0.3077, 0.7284],
[-1.0092, -0.2147, 0.0769, 0.6759]])
t.view(-1,4) #第一个维度为-1，pytorch会自动计算改维度的具体值
tensor([[ 0.3067, -0.4927, 0.2934, -0.9114],
[ 1.5307, -1.4519, 0.3077, 0.7284],
[-1.0092, -0.2147, 0.0769, 0.6759]])
t.data_ptr() #获取张量的数据指针
2821357586624
t.view(3,4).data_ptr() #数据指针不改变
2821357586624
t.view(3,4).transpose(0,1).data_ptr() #transpose方法交换两个维度的步长
2821357586624
张量相关运算API
t1 = torch.rand(3,4) #产生一个3*4的张量
tensor([[0.8076, 0.6687, 0.6467, 0.9070],
[0.6821, 0.0114, 0.9231, 0.3272],
[0.5947, 0.1504, 0.8652, 0.1312]])
t1.sqrt() #张量的平方根，张量的内部方法
tensor([[0.8987, 0.8178, 0.8041, 0.9524],
[0.8259, 0.1069, 0.9608, 0.5720],
[0.7712, 0.3879, 0.9301, 0.3623]])
torch.sqrt(t1) #张量的平方根，函数形式
# 前两个不改变张量的值
t1.sqrt_() #平方根原地操作，改变张量的值
torch.sum(t1) #默认对所有元素求和
tensor(6.7154)
torch.sum(t1,0) #对第0维的元素求和
tensor([2.0844, 0.8306, 2.4349, 1.3654])
torch.sum(t1,[0,1]) #对第0，1维的元素求和
tensor(6.7154)
t1.mean() #对所有元素求平均，也可用torch.mean函数
tensor(0.5596)
# 多个张量的运算
t1 = torch.rand(2,3)
t2 = torch.rand(2,3)
t1.add(t2) #加，四则运算，不改变参与运算张量的值
t1.sub(t2) #减
t1.mul(t2) #乘
t1.div(t2) #除
t1.add_(t2) #四则运算，改变参与运算张量的值
张量的极值和排序
t = torch.rand(3,4)
tensor([[0.6086, 0.0281, 0.6543, 0.7071],
[0.9933, 0.3584, 0.2573, 0.1269],
[0.3819, 0.6716, 0.2380, 0.6186]])
torch.argmax(t,0) #函数调用，返回沿着第0个维度，极大值所在位置
tensor([1, 2, 0, 0])
t.argmin(1) #内置方法调用，返回沿着第1个维度，极小值所在位置
tensor([1, 3, 2])
torch.max(t,-1) #函数调用，返回沿着最后一个维度，包含极大值和极大值所在位置的元组
torch.return_types.max(
values=tensor([0.7071, 0.9933, 0.6716]),
indices=tensor([3, 0, 1]))
t.min(0)
torch.return_types.min(
values=tensor([0.3819, 0.0281, 0.2380, 0.1269]),
indices=tensor([2, 0, 2, 1]))
t.sort(-1) #沿着最后一个维度排序，返回排序后的张量和张量元素在该位置的原始位置
torch.return_types.sort(
values=tensor([[0.0281, 0.6086, 0.6543, 0.7071],
[0.1269, 0.2573, 0.3584, 0.9933],
[0.2380, 0.3819, 0.6186, 0.6716]]),
indices=tensor([[1, 0, 2, 3],
[3, 2, 1, 0],
[2, 0, 3, 1]]))
矩阵乘法和张量的缩并
a = torch.randn(3,4)
b = torch.randn(4,3)
torch.mm(a,b) #矩阵乘法，调用函数，返回3*3的矩阵乘积
a.mm(b) #矩阵乘法，内置方法
a@b #矩阵乘法，@运算符号
torch.bmm(a,b) #(迷你)批次矩阵乘法，返回结果维2*3*3，函数形式
a.bmm(b)
a@b #运算符号形式，根据输入张量的形状决定 调用批次矩阵乘积
troch.einsum("bnk,bkl->bnl",a,b) #einsum函数的结果和a.bmm(b)结果一致
张量的拼接和分割
torch.stack() #通过传入的张量列表，同时指定并创建一个维度，把列表的张量沿着该维度堆叠起来，并返回堆叠以后的张量
torch.cat() #通过传入的张量列表指定某一个维度，把列表中的张量沿着该维度堆叠起来，并返回堆叠以后的张量
torch.split() #返回沿着某个维度分割后的列表
torch.chunk() #传入的整数参数是分割的段数，输入张量在该维度的大小需要被分割的段数整除
t1 = torch.randn(3,4)
t2 = torch.randn(3,4)
t3 = torch.randn(3,4)
t4 = torch.randn(3,2)
torch.stack([t1,t2,t3],-1).shape #沿着一个维度做堆叠，返回大小为3*4*3的张量
torch.Size([3, 4, 3])
torch.cat([t1,t2,t3],-1).shape #沿着一个维度做拼接，返回大小为3*14的张量
torch.Size([3, 12])
t = torch.randn(3,6)
t.split([1,2,3],-1) #把张量沿着最后一个维度分割为三个张量
(tensor([[-0.7143],
[-0.9957],
[-0.2261]]), tensor([[ 0.1810, 0.1221],
[-0.7660, -0.3330],
[ 0.3290, -0.7981]]), tensor([[ 0.7350, -0.7787, -0.4957],
[-0.6681, -1.0475, 0.1508],
[-0.5897, 0.7438, -3.7392]]))
t.split(3,-1) #把张量沿着最后一个维度，分割大小为3，输出的张量大小均为3*3
(tensor([[-0.7143, 0.1810, 0.1221],
[-0.9957, -0.7660, -0.3330],
[-0.2261, 0.3290, -0.7981]]), tensor([[ 0.7350, -0.7787, -0.4957],
[-0.6681, -1.0475, 0.1508],
[-0.5897, 0.7438, -3.7392]]))
t.chunk(3,-1) #把张量沿着最后一个维度分割为三个张量，大小均为3*2
(tensor([[-0.7143, 0.1810],
[-0.9957, -0.7660],
[-0.2261, 0.3290]]), tensor([[ 0.1221, 0.7350],
[-0.3330, -0.6681],
[-0.7981, -0.5897]]), tensor([[-0.7787, -0.4957],
[-1.0475, 0.1508],
[ 0.7438, -3.7392]]))
张量维度的扩增和压缩
t = torch.rand(3,4)
t.shape
torch.Size([3, 4])
t.unsqueeze(-1).shape #扩增最后一个维度
torch.Size([3, 4, 1])
t.unsqueeze(-1).unsqueeze(-1).shape #继续扩增最后一个维度
torch.Size([3, 4, 1, 1])
t = torch.rand(1,3,4,1)
t.shape
torch.Size([1, 3, 4, 1])
t.squeeze().shape #压缩所有大小为1的维度
torch.Size([3, 4])