Pytorch数据类型Tensor张量操作(操作比较全)

这篇具有很好参考价值的文章主要介绍了Pytorch数据类型Tensor张量操作(操作比较全)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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)

Pytorch数据类型Tensor张量操作(操作比较全)

三.索引

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)

Pytorch数据类型Tensor张量操作(操作比较全)
根据掩码获得打平后的指定索引张量:

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)

Pytorch数据类型Tensor张量操作(操作比较全)

四.维度变换

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}")

运行结果:
Pytorch数据类型Tensor张量操作(操作比较全)

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}")

运行结果:
Pytorch数据类型Tensor张量操作(操作比较全)

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}")

运行结果:
Pytorch数据类型Tensor张量操作(操作比较全)

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}")

Pytorch数据类型Tensor张量操作(操作比较全)

五.维度交换

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{x}")
print(f"transposed tensor in shape(3,4,2):\n{y}")

Pytorch数据类型Tensor张量操作(操作比较全)

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}")

Pytorch数据类型Tensor张量操作(操作比较全)

六.张量合并

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。

a = torch.tensor([
    [
        [1, 0, 1],
        [9, 1, 2],
        [3, 3, 1]
    ],
    [
        [0, 0, 1],
        [2, 5, 1],
        [3, 3, 2]
    ],
    [
        [4, 1, 10],
        [0, 2, 1],
        [1, 1, 1]
    ]
], dtype=int)

b = torch.tensor([
    [
        [0, 0, 2],
        [1, 10, 2],
        [2, 3, 0]
    ],
    [
        [0, 4, 1],
        [2, 0, 1],
        [1, 3, 6]
    ],
    [
        [0, 1, 4],
        [1, 2, 1],
        [1, 4, 1]
    ]
], dtype=int)

c = torch.cat([a, b], dim=0)
print(f"shape of A: {a.shape}")
print(f"shape of B: {b.shape}")
print(f"shape of A concat B: {c.shape}")
print(c)

运行结果:
Pytorch数据类型Tensor张量操作(操作比较全)

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)

运行结果:
Pytorch数据类型Tensor张量操作(操作比较全)

七.张量的分割

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}")

Pytorch数据类型Tensor张量操作(操作比较全)

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张量操作(操作比较全)文章来源地址https://www.toymoban.com/news/detail-496649.html

到了这里,关于Pytorch数据类型Tensor张量操作(操作比较全)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • PyTorch核心--tensor 张量 !!

    文章目录 前言 张量的概念 1. 张量的定义 2. 张量的属性 3. 张量的形状 张量的原理 1. 存储(storage) 2. 形状(shape) 3. 步幅(stride) 张量的操作 1. 数学运算 2. 逻辑运算 3. 索引和切片 4. 形状操作 5. 广播 总结 在PyTorch中,张量是核心数据结构,它是一个多维数组,类似Numpy中

    2024年01月23日
    浏览(41)
  • 【深度学习】pytorch——Tensor(张量)详解

    笔记为自我总结整理的学习笔记,若有错误欢迎指出哟~ Tensor,又名张量。它可以是一个数(标量)、一维数组(向量)、二维数组(矩阵)和更高维的数组(高阶数据)。Tensor和Numpy的ndarrays类似,但PyTorch的tensor支持GPU加速。 官方文档 : https://pytorch.org/docs/stable/tensors.html

    2024年02月06日
    浏览(46)
  • 【带着学Pytorch】2、张量(Tensor)的介绍与创建

           最开始在出现CPU和GPU, GPU出现主要解决的问题时并行计算,在此基础上的软件层面的工作基本上围绕着并行计算进行的,张量也不例外。 首先,我们先来聊聊 编程语言,python,java ,C,C++等,他们都有的共同特点是什么?在大学中计算机类专业耳熟能详, 算法、数

    2024年02月11日
    浏览(42)
  • Pytorch:将列表数据转不同数据类型的Tensor矩阵

            本文主要介绍pytorch中不同数据类型的Tensor矩阵,例如:float32、float64、int32、int64。并将创建好的列表数据转成不同数据类型的Tensor矩阵,最后进行:行复制的操作。 一、列表转Tensor,复制行和列向量 二、转Tensor矩阵中元素的数据类型 三、求个赞就行    

    2024年02月11日
    浏览(48)
  • 【1】深度学习之Pytorch——张量(tensor)的尺寸、储存偏移及步长等基本概念

    深度学习的基本概念 深度学习是一种人工神经网络的学习方法。它通过模仿人脑的学习方式来处理信息。深度学习的网络有很多层,每层都能学习到更抽象的概念。这种方法在语音识别、计算机视觉、自然语言处理等领域有很好的应用。 深度学习也有许多应用,这些应用往

    2024年02月02日
    浏览(41)
  • Pytorch数据类型转换(torch.tensor,torch.FloatTensor)

    之前遇到转为tensor转化为浮点型的问题,今天整理下,我只讲几个我常用的,如果有更好的方法,欢迎补充 1.首先讲下torch.tensor,默认整型数据类型为torch.int64,浮点型为torch.float32 2.这是我认为平常最爱用的转数据类型的方法,可以用dtype去定义数据类型 1.这个函数不要乱用

    2024年02月11日
    浏览(48)
  • 【Pytorch】学习记录分享2——Tensor基础,数据类型,及其多种创建方式

    pytorch 官方文档 1. 创建 Creating Tensor: 标量、向量、矩阵、tensor 2. 三种方法可以创建张量,一是通过列表(list),二是通过元组(tuple),三是通过Numpy的数组(array),基本创建代码如下: 张量相关属性查看的基本操作,后期遇到的张量结构都比较复杂,难以用肉眼直接看出,因此

    2024年02月04日
    浏览(50)
  • 1.PyTorch数据结构Tensor常用操作

    从接口的角度来讲,对tensor的操作可分为两类: torch.function ,如 torch.save 等。 另一类是 tensor.function ,如 tensor.view 等。 为方便使用,对tensor的大部分操作同时支持这两类接口,如 torch.sum (torch.sum(a, b)) 与 tensor.sum (a.sum(b)) 功能等价。 而从存储的角度来讲,对tensor的操作又可

    2024年02月04日
    浏览(39)
  • 【youcans的深度学习 10】PyTorch入门教程:张量的统计运算与比较运算

    欢迎关注『youcans的深度学习』系列,持续更新中… 【youcans的深度学习 01】安装环境之 miniconda 【youcans的深度学习 02】PyTorch CPU版本安装与环境配置 【youcans的深度学习 03】PyTorch CPU版本安装与环境配置 【youcans的深度学习 04】PyTorch入门教程:基础知识 【youcans的深度学习 05】

    2024年02月08日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包