Lesson 2.张量的索引、分片、合并以及维度调整

已于 2022-04-04 09:32:17 修改
阅读量1.1k 收藏 9
点赞数
文章标签： pytorch python 深度学习
于 2021-12-16 17:25:19 首次发布
原文链接：https://www.bilibili.com/video/BV14X4y1A7KT?p=3
版权

Lesson 2.张量的索引、分片、合并以及维度调整

转载自：https://www.bilibili.com/video/BV14X4y1A7KT?p=3

  张量作为有序的序列，也是具备数值索引的功能，并且基本索引方法和Python原生的列表、NumPy中的数组基本一致，当然，所有不同的是，PyTorch中还定义了一种采用函数来进行索引的方式。
  而作为PyTorch中基本数据类型，张量即具备了列表、数组的基本功能，同时还充当着向量、矩阵、甚至是数据框等重要数据结构，因此PyTorch中也设置了非常完备的张量合并与变换的操作。

import torch
import numpy as np

一、张量的符号索引

  张量也是有序序列，我们可以根据每个元素在系统内的顺序“编号”，来找出特定的元素，也就是索引。

1.一维张量索引

  一维张量的索引过程和Python原生对象类型的索引一致，基本格式遵循[start: end: step]，索引的基本要点回顾如下。

t1 = torch.arange(1, 11)
t1

tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
  • 从左到右，从零开始
t1[0]

tensor(1)

注：张量索引出来的结果还是零维张量， 而不是单独的数。要转化成单独的数，需要使用item()方法。

  • 冒号分隔，表示对某个区域进行索引，也就是所谓的切片
t1[1: 8]             # 索引其中2-9号元素，并且左包含右不包含

tensor([2, 3, 4, 5, 6, 7, 8])
  • 第二个冒号，表示索引的间隔
t1[1: 8: 2]          # 索引其中2-9号元素，左包含右不包含，且隔两个数取一个

tensor([2, 4, 6, 8])
  • 冒号前后没有值，表示索引这个区域
t1[1: : 2]           # 从第二个元素开始索引，一直到结尾，并且每隔两个数取一个

tensor([ 2,  4,  6,  8, 10])

t1[: 8: 2]           # 从第一个元素开始索引到第9个元素（不包含），并且每隔两个数取一个

tensor([1, 3, 5, 7])

在张量的索引中，step位必须大于0

t1[9: 1: -1]

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-312-b82bb967c8e2> in <module>
----> 1 t1[9: 1: -1]


ValueError: step must be greater than zero

2.二维张量索引

  二维张量的索引逻辑和一维张量的索引逻辑基本相同，二维张量可以视为两个一维张量组合而成，而在实际的索引过程中，需要用逗号进行分隔，分别表示对哪个一维张量进行索引、以及具体的一维张量的索引。

t2 = torch.arange(1, 10).reshape(3, 3)
t2

tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])

t2[0, 1]                  # 表示索引第一行、第二个（第二列的）元素

tensor(2)

t2[0, ::2]                # 表示索引第一行、每隔两个元素取一个

tensor([1, 3])

t2[0, [0, 2]]             # 索引结果同上

tensor([1, 3])

t2[::2, ::2]              # 表示每隔两行取一行、并且每一行中每隔两个元素取一个

tensor([[1, 3],
        [7, 9]])

t2[[0, 2], 1]              # 索引第一行、第三行、第二列的元素

tensor([2, 8])

理解：对二维张量来说，基本可以视为是对矩阵的索引，并且行、列的索引遵照相同的索引规范，并用逗号进行分隔。

3.三维张量的索引

  在二维张量索引的基础上，三维张量拥有三个索引的维度。我们将三维张量视作矩阵组成的序列，则在实际索引过程中拥有三个维度，分别是索引矩阵、索引矩阵的行、索引矩阵的列。

t3 = torch.arange(1, 28).reshape(3, 3, 3)
t3

tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9]],

        [[10, 11, 12],
         [13, 14, 15],
         [16, 17, 18]],

        [[19, 20, 21],
         [22, 23, 24],
         [25, 26, 27]]])

t3[1, 1, 1]          # 索引第二个矩阵中，第二行、第二个元素

tensor(14)

t3[1, ::2, ::2]      # 索引第二个矩阵，行和列都是每隔两个取一个

tensor([[10, 12],
        [16, 18]])

t3[:: 2, :: 2, :: 2]      # 每隔两个取一个矩阵，对于每个矩阵来说，行和列都是每隔两个取一个

tensor([[[ 1,  3],
         [ 7,  9]],

        [[19, 21],
         [25, 27]]])

理解：更为本质的角度去理解高维张量的索引，其实就是围绕张量的“形状”进行索引

t3.shape

torch.Size([3, 3, 3])

t3[1, 1, 1]             # 与shape一一对应

tensor(14)

二、张量的函数索引

  在PyTorch中，我们还可以使用index_select函数，通过指定index来对张量进行索引。

t1

tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

t1.ndim

1

indices = torch.tensor([1, 2])
indices

tensor([1, 2])

torch.index_select(t1, 0, indices)

tensor([2, 3])

在index_select函数中，第二个参数实际上代表的是索引的维度。对于t1这个一维向量来说，由于只有一个维度，因此第二个参数取值为0，就代表在第一个维度上进行索引

t2 = torch.arange(12).reshape(4, 3)
t2

tensor([[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

t2.shape

torch.Size([4, 3])

indices

tensor([1, 2])

torch.index_select(t2, 0, indices)     

tensor([[3, 4, 5],
        [6, 7, 8]])

dim参数取值为0，代表在shape的第一个维度上索引

torch.index_select(t2, 1, indices)

tensor([[ 1,  2],
        [ 4,  5],
        [ 7,  8],
        [10, 11]])

dim参数取值为1，代表在shape的第二个维度上索引

三、tensor.view()方法

  在正式介绍张量的切分方法之前，需要首先介绍PyTorch中的.view()方法。该方法会返回一个类似视图的结果，该结果和原张量对象共享一块数据存储空间，并且通过.view()方法，还可以改变对象结构，生成一个不同结构，但共享一个存储空间的张量。当然，共享一个存储空间，也就代表二者是“浅拷贝”的关系，修改其中一个，另一个也会同步进行更改。

t = torch.arange(6).reshape(2, 3)
t

tensor([[0, 1, 2],
        [3, 4, 5]])

te = t.view(3, 2)              # 构建一个数据相同，但形状不同的“视图”
te

tensor([[0, 1],
        [2, 3],
        [4, 5]])

t

tensor([[0, 1, 2],
        [3, 4, 5]])

t[0] = 1                       # 对t进行修改

t

tensor([[1, 1, 1],
        [3, 4, 5]])

te                             # te同步变化

tensor([[1, 1],
        [1, 3],
        [4, 5]])

tr = t.view(1, 2, 3)           # 维度也可以修改
tr

tensor([[[1, 1, 1],
         [3, 4, 5]]])

“视图”的作用就是节省空间，而值得注意的是，在接下来介绍的很多切分张量的方法中，返回结果都是“视图”，而不是新生成一个对象。

三、张量的分片函数

1.分块：chunk函数

  chunk函数能够按照某维度，对张量进行均匀切分，并且返回结果是原张量的视图。

t2 = torch.arange(12).reshape(4, 3)
t2

tensor([[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

tc = torch.chunk(t2, 4, dim=0)           # 在第零个维度上（按行），进行四等分
tc

(tensor([[0, 1, 2]]),
 tensor([[3, 4, 5]]),
 tensor([[6, 7, 8]]),
 tensor([[ 9, 10, 11]]))

注意：chunk返回结果是一个视图，不是新生成了一个对象

tc[0][0]

tensor([0, 1, 2])

tc[0][0][0] = 1            # 修改tc中的值

tc

(tensor([[1, 1, 2]]),
 tensor([[3, 4, 5]]),
 tensor([[6, 7, 8]]),
 tensor([[ 9, 10, 11]]))

t2                         # 原张量也会对应发生变化

tensor([[ 1,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

当原张量不能均分时，chunk不会报错，但会返回其他均分的结果

torch.chunk(t2, 3, dim=0)            # 次一级均分结果

(tensor([[1, 1, 2],
         [3, 4, 5]]),
 tensor([[ 6,  7,  8],
         [ 9, 10, 11]]))

len(torch.chunk(t2, 3, dim=0))

2

torch.chunk(t2, 5, dim=0)            # 次一级均分结果

(tensor([[1, 1, 2]]),
 tensor([[3, 4, 5]]),
 tensor([[6, 7, 8]]),
 tensor([[ 9, 10, 11]]))

2.拆分：split函数

  split既能进行均分，也能进行自定义切分。当然，需要注意的是，和chunk函数一样，split返回结果也是view。

t2 = torch.arange(12).reshape(4, 3)
t2

tensor([[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

均分情况

torch.split(t2, 2, 0)           # 第二个参数只输入一个数值时表示均分，第三个参数表示切分的维度

(tensor([[0, 1, 2],
         [3, 4, 5]]),
 tensor([[ 6,  7,  8],
         [ 9, 10, 11]]))

按照索引切分

torch.split(t2, [1, 3], 0)           # 第二个参数输入一个序列时，表示按照序列数值进行切分，也就是1/3分

(tensor([[0, 1, 2]]),
 tensor([[ 3,  4,  5],
         [ 6,  7,  8],
         [ 9, 10, 11]]))

注意，当第二个参数位输入一个序列时，序列的各数值的和必须等于对应维度下形状分量的取值。例如，上述代码中，是按照第一个维度进行切分，而t2总共有4行，因此序列的求和必须等于4，也就是1+3=4，而序列中每个分量的取值，则代表切块大小。

torch.split(t2, [1, 1, 1, 1], 0)  

(tensor([[0, 1, 2]]),
 tensor([[3, 4, 5]]),
 tensor([[6, 7, 8]]),
 tensor([[ 9, 10, 11]]))

torch.split(t2, [1, 1, 2], 0) 

(tensor([[0, 1, 2]]),
 tensor([[3, 4, 5]]),
 tensor([[ 6,  7,  8],
         [ 9, 10, 11]]))

ts = torch.split(t2, [1, 2], 1) 
ts

(tensor([[0],
         [3],
         [6],
         [9]]),
 tensor([[ 1,  2],
         [ 4,  5],
         [ 7,  8],
         [10, 11]]))

ts[0][0] = 1                 # view进行修改

t2                           # 原对象同步改变

tensor([[ 1,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

tensor的split方法和array的split方法有很大的区别，array的split方法是根据索引进行切分。

四、张量的合并操作

  张量的合并操作类似与列表的追加元素，可以拼接、也可以堆叠。

  • 拼接函数：cat

PyTorch中，可以使用cat函数实现张量的拼接。

a = torch.zeros(2, 3)
a

tensor([[0., 0., 0.],
        [0., 0., 0.]])

b = torch.ones(2, 3)
b

tensor([[1., 1., 1.],
        [1., 1., 1.]])

c = torch.zeros(3, 3)
c

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

torch.cat([a, b])                  # 按照行进行拼接，dim默认取值为0

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [1., 1., 1.],
        [1., 1., 1.]])

torch.cat([a, b], 1)               # 按照列进行拼接

tensor([[0., 0., 0., 1., 1., 1.],
        [0., 0., 0., 1., 1., 1.]])

torch.cat([a, c], 1)               # 形状不匹配时将报错

---------------------------------------------------------------------------

RuntimeError                              Traceback (most recent call last)

<ipython-input-153-8bdd1a857266> in <module>
----> 1 torch.cat([a, c], 1)               # 形状不匹配时将报错


RuntimeError: Sizes of tensors must match except in dimension 1. Got 2 and 3 in dimension 0 (The offending index is 1)

注意理解，拼接的本质是实现元素的堆积，也就是构成a、b两个二维张量的各一维张量的堆积，最终还是构成二维向量。

  • 堆叠函数：stack

  和拼接不同，堆叠不是将元素拆分重装，而是简单的将各参与堆叠的对象分装到一个更高维度的张量里。

a

tensor([[0., 0., 0.],
        [0., 0., 0.]])

b

tensor([[1., 1., 1.],
        [1., 1., 1.]])

torch.stack([a, b])                 # 堆叠之后，生成一个三维张量

tensor([[[0., 0., 0.],
         [0., 0., 0.]],

        [[1., 1., 1.],
         [1., 1., 1.]]])

torch.stack([a, b]).shape

torch.Size([2, 2, 3])

torch.cat([a, b])

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [1., 1., 1.],
        [1., 1., 1.]])

注意对比二者区别，拼接之后维度不变，堆叠之后维度升高。拼接是把一个个元素单独提取出来之后再放到二维张量中，而堆叠则是直接将两个二维张量封装到一个三维张量中，因此，堆叠的要求更高，参与堆叠的张量必须形状完全相同。

a

tensor([[0., 0., 0.],
        [0., 0., 0.]])

c

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

torch.cat([a, c])                # 横向拼接时，对行数没有一致性要求

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

torch.stack([a, c])               # 维度不匹配时也会报错

---------------------------------------------------------------------------

RuntimeError                              Traceback (most recent call last)

<ipython-input-167-0311d15e051e> in <module>
----> 1 torch.stack([a, c])               # 维度不匹配时也会报错


RuntimeError: stack expects each tensor to be equal size, but got [2, 3] at entry 0 and [3, 3] at entry 1

五、张量维度变换

  此前我们介绍过，通过reshape方法，能够灵活调整张量的形状。而在实际操作张量进行计算时，往往需要另外进行降维和升维的操作，当我们需要除去不必要的维度时，可以使用squeeze函数，而需要手动升维时，则可采用unsqueeze函数。

  • squeeze函数：删除不必要的维度
t = torch.zeros(1, 1, 3, 1)
t

tensor([[[[0.],
          [0.],
          [0.]]]])

t.shape

torch.Size([1, 1, 3, 1])

t张量解释：一个包含一个三维的四维张量，三维张量只包含一个三行一列的二维张量。

torch.squeeze(t)

tensor([0., 0., 0.])

torch.squeeze(t).shape

torch.Size([3])

转化后生成了一个一维张量

t1 = torch.zeros(1, 1, 3, 2, 1, 2)
t1.shape

torch.Size([1, 1, 3, 2, 1, 2])

torch.squeeze(t1)

tensor([[[0., 0.],
         [0., 0.]],

        [[0., 0.],
         [0., 0.]],

        [[0., 0.],
         [0., 0.]]])

torch.squeeze(t1).shape

torch.Size([3, 2, 2])

简单理解，squeeze就相当于提出了shape返回结果中的1

  • unsqeeze函数：手动升维
t = torch.zeros(1, 2, 1, 2)
t.shape

torch.Size([1, 2, 1, 2])

torch.unsqueeze(t, dim = 0)              # 在第1个维度索引上升高1个维度

tensor([[[[[0., 0.]],

          [[0., 0.]]]]])

torch.unsqueeze(t, dim = 0).shape

torch.Size([1, 1, 2, 1, 2])

torch.unsqueeze(t, dim = 2).shape         # 在第3个维度索引上升高1个维度

torch.Size([1, 2, 1, 1, 2])

torch.unsqueeze(t, dim = 4).shape          # 在第5个维度索引上升高1个维度

torch.Size([1, 2, 1, 2, 1])

注意理解维度和shape返回结果一一对应的关系，shape返回的序列有几个元素，张量就有多少维度。

QT-Smile
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Lesson 4.张量的线性代数运算.ipynb
11-26
张量的线性代数运算
pytorch张量索引以及sum函数mean函数unsqueeze函数
02-20
张量学习笔记
Lesson 2.张量的索引、分片、合并以及维度调整.ipynb
11-26
Lesson 2.张量的索引、分片、合并以及维度调整.ipynb
在keras 中获取张量 tensor 的维度大小实例
01-20
在进行keras 网络计算时，有时候需要获取输入张量的维度来定义自己的层。但是由于keras是一个封闭的接口。因此在调用由于是张量不能直接用numpy 里的A.shape()。这样的形式来获取。这里需要调用一下keras 作为后端的方式来获取。当我们想要操作时第一时间就想到直接用 shape ()函数。其实keras 中真的有shape()这个函数。 shape（x）返回一个张量的符号shape，符号shape的意思是返回值本身也是一个tensor， 示例： >>> from keras import backend as K >>> tf_session = K.get_session()
Lesson 1.张量（Tensor）的创建和索引.ipynb
11-26
Lesson 1.张量（Tensor）的创建和索引.ipynb
pytorch张量索引切片等学习笔记
09-09
结合网上的相关教程整理的关于pytorch的有关张量，索引，切片以及与numpy相互转换使用的学习笔记，比较完整，有兴趣的可以下载！
张量索引张量与张量切片
twelve13的博客
11-24 1399
张量索引张量与张量切片 提示：这里简述项目相关背景： 张量的索引与一般的列表和元组索引类似，在不同维度的使用索引值索引，与一般列表相似的数字操作可以参考https://blog.csdn.net/Zzz_zhongqing/article/details/107279857 这里讲述使用将一个张量作为一个索引参数用来索引张量， 问题描述： 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override publ
【Pytorch基础(2)】张量的索引，切片与维度变换
lingchen1906的博客
01-19 2854
举例如下：[2, 3, 32, 32] + [3,1,1] 是不能直接相加的。Broadcast机制会先将 [3,1,1] 增加新维度变为 [1, 3, 1, 1] (等价于unsqueeze()方法)，然后再将 [1, 3, 1, 1]扩展维度为 [2, 3, 32, 32] (等价于expand()方法)从某种程度上说，
张量的索引切片
weixin_44039183的博客
01-18 1178
张量的索引切片 张量的索引切片方式和numpy几乎是一样的。切片时支持缺省参数和省略号。可以通过索引和切片对部分元素进行修改。类似于数组的切片，但是又稍微有些不同： 例如：a=torch.rand(4,3,28,28):dim=4的张量数据a (1)a[:2]:取第一个维度的前2个维度数据(不包括2)； (2)a[:2,:1,:,:]：取第一个维度的前两个数据，取第二个维度的第一个数据，后两个维度全都取到； (3)a[:2,1:,:,:]：取第一个维度的前两个数据，取第二个维度的索引1到最后索引的数据(包含
pytorch张量数据索引切片与维度变换操作大全
Lily的博客
04-25 1756
(1-1)pytorch张量数据的索引与切片操作1、对于张量数据的索引操作主要有以下几种方式：a=torch.rand(4,3,28,28):DIM=4的张量数据a(1)a[:2]:...
TensorFlow深度学习：4.1.张量的结构操作
ssshyeong的博客
10-03 90
张量的结构操作1.创建张量2.索引切片2.2.tf.slice.2.3.tf.gather2.3.tf.gather_nd2.4.tf.boolean_mask3.修改张量的某些元素3.1.tf.where3.2.tf.scatter_nd4.维度变换4.1.tf.reshape ——改变张量的形状。4.2.tf.squeeze ——减少维度。4.3.tf.expand_dims ——增加维度。4.4.tf.transpose ——交换维度。5.合并分割5.1.tf.concat5.2.tf.stack5.
tensor 增加一维度_Pytorch学习笔记------tensor
weixin_39870132的博客
01-10 7344
文章结构一、什么是张量？张量的基本介绍。二、pytorch中几种创建张量的方式。 1.直接创建、 2.依据数值创建、 3.依据概率创建。三、张量的基本操作。 1.张量的拼接、 2.张量的切分、 3.张量的索引、 4.张量的变换、 5.张量的数学运算。一、什么是tensor？ tensor（张...
Numpy(高维数组) |Pytorch(张量) 索引读操作笔记
weixin_44815943的博客
04-13 2485
张量是一种多维单一数据类型数组，pytorch 索引张量继承 numpy 索引多维数组。两者均遵守 x[obj] 索引语法，obj 称为索引对象。根据 obj 的不同情形，有“基础索引”， “高级索引”， “字段访问（field access）”三种形式， 本文主要记录前两者。   基础索引 当索引对象是元组时，遵守基础索引规则， 注意x1, x2, x3 是元组 (x1, x2, x3)的等价形式。 当只需索引单一元素时，类似于标准 python 序列对象索引操作，索引号从0开始， 支持负数。当
Lesson 1.张量（Tensor）的创建和索引
QT-Smile
12-16 715
转载自：https://www.bilibili.com/video/BV14X4y1A7KT?p=3 Lesson 1. 张量（Tensor）的创建和常用方法   在实际使用PyTorch的过程中，张量（Tensor）对象是我们操作的基本数据类型。   很多时候，在我们没有特别明确什么是深度学习计算框架的时候，我们可以把PyTorch简单看成是Python的深度学习第三方库，在PyTorch中定义了适用于深度学习的基本数据结构————张量，以及张量的各类计算。其实也就相当于NumPy中定义的Array和对
1.张量（pytorch）
qq_26974921的博客
03-21 325
浮点数是网络处理信息的方式，因此我们需要一种方法，将我们希望处理的真实世界的 数据编码为网络可理解的数据，然后将输出解码为我们可以理解和使用的数据。一般来说，这些中间表征是浮点数的集合，它们描述输入的特征，并以一种有助于描述输入映射到神经网络输出的方式捕获数据的结构。张量是一个数组，也就是一种数据结构，它存储了一组数字，这些数字可以用一个索引单独访问，也可以用多个索引访问。（这些中间表征是将输入与前一层神经元的权重结合的结果，如图 3.1 所示的第 2 步。每个中间表征对之前的输入都是唯一的。
pytorch张量维度操作（拼接、维度扩展、压缩、转置、重复……）
热门推荐
Ma Sizhou
06-28 2万+
张量的操作确实有技巧，pytorch中提供了一些相关的操作，在编程的时候很有用。 涉及的方法见下面的目录： 目录一、拼接张量1、torch.cat()2、torch.stack()二、扩大张量1、torch.Tensor.expand()三、压缩张量1、torch.squeeze()四、重复张量1、torch.Tensor.repeat()2、torch.Tensor.unfold()五、缩小张量1、torch.Tensor.narrow()六、张量变形 z1、torch.Tensor.view()七、.
机器学习笔记 - PyTorch 分布式训练概览
最新发布
学以致用 知行合一
06-01 42
对训练集图像进行数据增强])])加载预训练模型首先，检查我们的硬件是否符合 PyTorch Data Parallel。如果符合我们就将模型传递给模块从而并行化我们的模型。我们使用训练数据加载器循环训练集。进入训练集循环后，我们首先启用混合精度并将输入（数据和标签）加载到 CUDA 设备。最后，让模型执行前向传递并使用损失函数计算损失。在评估过程中，我们将PyTorch切换到评估模式。然后，在训练步骤中，我们循环验证数据加载器并在将数据加载到 CUDA 设备之前启用混合精度。
Pytorch创建张量
qq_44815135的博客
05-27 1033
torch.normal() 是 PyTorch 中用于创建具有指定均值和标准差的正态分布随机值的张量的函数。torch.randn() 是 PyTorch 中用于创建具有正态分布（高斯分布）随机值的张量的函数。torch.zeros() 函数是 PyTorch 中用于创建元素全为零的张量的函数。torch.ones() 函数是 PyTorch 中用于创建元素全为一的张量的函数。torch.rand() 是 PyTorch 中用于创建具有随机值的张量的函数。
Pytorch实用教程：pytorch中nn.Linear()用法详解 | 构建多层感知机 | nn.Module的作用 | nn.Sequential的作用
惊鸿若梦一书生
05-30 204
Pytorch实用教程：pytorch中nn.Linear()用法详解 | 构建多层感知机 | nn.Module的作用 | nn.Sequential的作用
torch.tensor张量维度
08-17
在PyTorch中，torch.Tensor是一个多维数组的数据类型。它可以表示不同维度的张量。维度是一个抽象的概念，可以用来描述张量的形状和大小。每个维度都对应着张量的一个轴，可以通过索引来访问张量中的元素。 例如，一个二维张量可以表示为一个矩阵，其中第一个维度表示行，第二个维度表示列。一个三维张量可以表示为一个立方体，其中第一个维度表示深度，第二个维度表示行，第三个维度表示列。更高维度的张量可以类似地解释。 torch.Tensor.expand()函数可以用来改变张量的形状，可以通过指定新的维度来扩展原有的维度。这个函数的官方文档可以在中找到。 torch.Tensor.expand_as()函数则是用来将一个张量扩展为与另一个张量具有相同形状的函数。这个函数的官方文档可以在中找到。 所以，torch.tensor张量的维度是指张量的形状和大小，可以通过expand()和expand_as()函数来改变或扩展。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [图像解析 torch.Tensor 的维度概念 && 用 torch.randn 举例](https://blog.csdn.net/qq_54185421/article/details/124896084)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [【Pytorch】torch.Tensor.expand_as()与torch.Tensor.expand()使用与比较](https://blog.csdn.net/meiqi0538/article/details/124394608)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值