pytorch之张量

最新推荐文章于 2023-04-14 01:38:56 发布

Strawberry.

最新推荐文章于 2023-04-14 01:38:56 发布

阅读量216

点赞数

分类专栏： Pytorch 文章标签： pytorch 深度学习 python

本文链接：https://blog.csdn.net/qq_43754288/article/details/125235365

版权

Pytorch 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

张量 torch.Tensor

张量 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])