PyTorch使用------张量的类型转换，拼接操作，索引操作，形状操作

已于 2024-09-03 09:39:38 修改
阅读量1.1k 收藏 33
点赞数 51
文章标签： 深度学习 pytorch 人工智能 python
于 2024-08-17 23:02:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76820214/article/details/141288270
版权

目录

1. 张量类型转换

1.1 张量转换为 numpy 数组

1.2 numpy 转换为张量

1.3 标量张量和数字的转换

1.4 小节

2. 张量拼接操作

2.1 torch.cat 函数的使用

2.2 torch.stack 函数的使用

2.3 小节

3. 张量索引操作

3.1 简单行、列索引

3.2 列表索引

3.3 范围索引

3.4 布尔索引

3.5 多维索引

4. 张量形状操作

4.1 reshape 函数的用法

4.2 transpose 和 permute 函数的使用

4.3 view 和 contigous 函数的用法

4.4 squeeze 和 unsqueeze 函数的用法

4.5 小节

 

前言

学习张量的拼接、索引和形状操作在深度学习和数据处理中至关重要。

拼接操作允许我们合并不同来源或不同维度的数据，以丰富模型输入或构建复杂网络结构。

索引操作则提供了精确访问和操作张量中特定元素或子张量的能力，这对于数据预处理、特征提取和错误调试尤为关键。

形状操作如重塑、转置等，能够灵活调整张量的维度，确保数据符合算法或网络层的输入要求，从而优化计算效率和性能。

在学习张量三大操作之前，我们先来简单熟悉一下张量的类型转换。

 

1. 张量类型转换

张量的类型转换也是经常使用的一种操作，是必须掌握的知识点。在本小节，我们主要学习如何将 numpy 数组和 PyTorch Tensor 的转化方法.

1.1 张量转换为 numpy 数组

使用 Tensor.numpy 函数可以将张量转换为 ndarray 数组，但是共享内存，可以使用 copy 函数避免共享。

# 1. 将张量转换为 numpy 数组
def test01():

    data_tensor = torch.tensor([2, 3, 4])
    # 使用张量对象中的 numpy 函数进行转换
    data_numpy = data_tensor.numpy()

    print(type(data_tensor))
    print(type(data_numpy))

    # 注意: data_tensor 和 data_numpy 共享内存
    # 修改其中的一个，另外一个也会发生改变
    # data_tensor[0] = 100
    data_numpy[0] = 100

    print(data_tensor)
    print(data_numpy)


# 2. 对象拷贝避免共享内存
def test02():

    data_tensor = torch.tensor([2, 3, 4])
    # 使用张量对象中的 numpy 函数进行转换
    data_numpy = data_tensor.numpy()

    print(type(data_tensor))
    print(type(data_numpy))

    # 注意: data_tensor 和 data_numpy 共享内存
    # 修改其中的一个，另外一个也会发生改变
    # data_tensor[0] = 100
    data_numpy[0] = 100

    print(data_tensor)
    print(data_numpy)

1.2 numpy 转换为张量

  1. 使用 from_numpy 可以将 ndarray 数组转换为 Tensor，默认共享内存，使用 copy 函数避免共享。
  2. 使用 torch.tensor 可以将 ndarray 数组转换为 Tensor，默认不共享内存。
# 1. 使用 from_numpy 函数
def test01():

    data_numpy = np.array([2, 3, 4])
    # 将 numpy 数组转换为张量类型
    # 1. from_numpy
    # 2. torch.tensor(ndarray)

    # 浅拷贝
    data_tensor = torch.from_numpy(data_numpy)

    # nunpy 和 tensor 共享内存
    # data_numpy[0] = 100
    data_tensor[0] = 100

    print(data_tensor)
    print(data_numpy)


# 2. 使用 torch.tensor 函数
def test02():

    data_numpy = np.array([2, 3, 4])

    data_tensor = torch.tensor(data_numpy)

    # nunpy 和 tensor 不共享内存
    # data_numpy[0] = 100
    data_tensor[0] = 100

    print(data_tensor)
    print(data_numpy)

1.3 标量张量和数字的转换

对于只有一个元素的张量，使用 item 方法将该值从张量中提取出来。

# 3. 标量张量和数字的转换
def test03():

    # 当张量只包含一个元素时, 可以通过 item 函数提取出该值
    data = torch.tensor([30,])
    print(data.item())

    data = torch.tensor(30)
    print(data.item())


if __name__ == '__main__':
    test03()

程序输出结果:

30
30

1.4 小节

在本小节中, 我们主要学习了 numpy 和 tensor 互相转换的规则, 以及标量张量与数值之间的转换规则。

 

2. 张量拼接操作

 

张量的拼接操作在神经网络搭建过程中是非常常用的方法，例如: 在后面将要学习到的残差网络、注意力机制中都使用到了张量拼接。

2.1 torch.cat 函数的使用

torch.cat 函数可以将两个张量根据指定的维度拼接起来.

import torch


def test():

    data1 = torch.randint(0, 10, [3, 5, 4])
    data2 = torch.randint(0, 10, [3, 5, 4])

    print(data1)
    print(data2)
    print('-' * 50)

    # 1. 按0维度拼接
    new_data = torch.cat([data1, data2], dim=0)
    print(new_data.shape)
    print('-' * 50)

    # 2. 按1维度拼接
    new_data = torch.cat([data1, data2], dim=1)
    print(new_data.shape)

    # 3. 按2维度拼接
    new_data = torch.cat([data1, data2], dim=2)
    print(new_data)


if __name__ == '__main__':
    test()

程序输出结果:

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

        [[0, 1, 4, 4],
         [4, 1, 8, 7],
         [5, 2, 6, 6],
         [2, 6, 1, 6],
         [0, 7, 8, 9]],

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

        [[7, 6, 3, 3],
         [4, 3, 3, 2],
         [2, 1, 1, 1],
         [3, 0, 8, 2],
         [8, 6, 6, 5]],

        [[0, 7, 2, 4],
         [4, 3, 8, 3],
         [4, 2, 1, 9],
         [4, 2, 8, 9],
         [3, 7, 0, 8]]])
--------------------------------------------------
torch.Size([6, 5, 4])
--------------------------------------------------
torch.Size([3, 10, 4])
tensor([[[6, 8, 3, 5, 4, 6, 8, 1],
         [1, 1, 3, 8, 0, 1, 8, 2],
         [9, 0, 4, 4, 4, 9, 9, 8],
         [1, 4, 7, 0, 5, 1, 5, 9],
         [5, 1, 4, 8, 9, 4, 3, 0]],

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

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

2.2 torch.stack 函数的使用

torch.stack 函数可以将两个张量根据指定的维度叠加起来.

import torch


def test():

    data1= torch.randint(0, 10, [2, 3])
    data2= torch.randint(0, 10, [2, 3])
    print(data1)
    print(data2)

    new_data = torch.stack([data1, data2], dim=0)
    print(new_data.shape)

    new_data = torch.stack([data1, data2], dim=1)
    print(new_data.shape)

    new_data = torch.stack([data1, data2], dim=2)
    print(new_data)


if __name__ == '__main__':
    test()

程序输出结果:

tensor([[5, 8, 7],
        [6, 0, 6]])
tensor([[5, 8, 0],
        [9, 0, 1]])
torch.Size([2, 2, 3])
torch.Size([2, 2, 3])
tensor([[[5, 5],
         [8, 8],
         [7, 0]],

        [[6, 9],
         [0, 0],
         [6, 1]]])

2.3 小节

张量的拼接操作也是在后面我们经常使用一种操作。cat 函数可以将张量按照指定的维度拼接起来，stack 函数可以将张量按照指定的维度叠加起来。

 

3. 张量索引操作

我们在操作张量时，经常需要去进行获取或者修改操作，掌握张量的花式索引操作是必须的一项能力。

3.1 简单行、列索引

准备数据

import torch

data = torch.randint(0, 10, [4, 5])
print(data)
print('-' * 50)

程序输出结果:

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

# 1. 简单行、列索引
def test01():

    print(data[0])
    print(data[:, 0])
    print('-' * 50)

if __name__ == '__main__':
    test01()

程序输出结果:

tensor([0, 7, 6, 5, 9])
tensor([0, 6, 6, 4])
--------------------------------------------------

3.2 列表索引

# 2. 列表索引
def test02():

    # 返回 (0, 1)、(1, 2) 两个位置的元素
    print(data[[0, 1], [1, 2]])
    print('-' * 50)

    # 返回 0、1 行的 1、2 列共4个元素
    print(data[[[0], [1]], [1, 2]])
if __name__ == '__main__':
    test02()

程序输出结果:

tensor([7, 3])
--------------------------------------------------
tensor([[7, 6],
        [8, 3]])

3.3 范围索引

# 3. 范围索引
def test03():
    # 前3行的前2列数据
    print(data[:3, :2])
    # 第2行到最后的前2列数据
    print(data[2:, :2])
if __name__ == '__main__':
    test03()

程序输出结果:

tensor([[0, 7],
        [6, 8],
        [6, 3]])
tensor([[6, 3],
        [4, 9]])

3.4 布尔索引

# 布尔索引
def test():

    # 第三列大于5的行数据
    print(data[data[:, 2] > 5])
    # 第二行大于5的列数据
    print(data[:, data[1] > 5])
if __name__ == '__main__':
    test04()

程序输出结果:

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

3.5 多维索引

# 多维索引
def test05():

    data = torch.randint(0, 10, [3, 4, 5])
    print(data)
    print('-' * 50)

    print(data[0, :, :])
    print(data[:, 0, :])
    print(data[:, :, 0])


if __name__ == '__main__':
    test05()

程序输出结果:

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

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

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

 

4. 张量形状操作

 

在我们后面搭建网络模型时，数据都是基于张量形式的表示，网络层与层之间很多都是以不同的 shape 的方式进行表现和运算，我们需要掌握对张量形状的操作，以便能够更好处理网络各层之间的数据连接。

4.1 reshape 函数的用法

reshape 函数可以在保证张量数据不变的前提下改变数据的维度，将其转换成指定的形状，在后面的神经网络学习时，会经常使用该函数来调节数据的形状，以适配不同网络层之间的数据传递。

import torch
import numpy as np


def test():

    data = torch.tensor([[10, 20, 30], [40, 50, 60]])

    # 1. 使用 shape 属性或者 size 方法都可以获得张量的形状
    print(data.shape, data.shape[0], data.shape[1])
    print(data.size(), data.size(0), data.size(1))

    # 2. 使用 reshape 函数修改张量形状
    new_data = data.reshape(1, 6)
    print(new_data.shape)


if __name__ == '__main__':
    test()

程序运行结果:

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

4.2 transpose 和 permute 函数的使用

transpose 函数可以实现交换张量形状的指定维度, 例如: 一个张量的形状为 (2, 3, 4) 可以通过 transpose 函数把 3 和 4 进行交换, 将张量的形状变为 (2, 4, 3)

permute 函数可以一次交换更多的维度。

import torch
import numpy as np


def test():

    data = torch.tensor(np.random.randint(0, 10, [3, 4, 5]))
    print('data shape:', data.size())

    # 1. 交换1和2维度
    new_data = torch.transpose(data, 1, 2)
    print('data shape:', new_data.size())

    # 2. 将 data 的形状修改为 (4, 5, 3)
    new_data = torch.transpose(data, 0, 1)
    new_data = torch.transpose(new_data, 1, 2)
    print('new_data shape:', new_data.size())

    # 3. 使用 permute 函数将形状修改为 (4, 5, 3)
    new_data = torch.permute(data, [1, 2, 0])
    print('new_data shape:', new_data.size())


if __name__ == '__main__':
    test()

程序运行结果:

data shape: torch.Size([3, 4, 5])
data shape: torch.Size([3, 5, 4])
new_data shape: torch.Size([4, 5, 3])
new_data shape: torch.Size([4, 5, 3])

4.3 view 和 contigous 函数的用法

view 函数也可以用于修改张量的形状，但是其用法比较局限，只能用于存储在整块内存中的张量。在 PyTorch 中，有些张量是由不同的数据块组成的，它们并没有存储在整块的内存中，view 函数无法对这样的张量进行变形处理，例如: 一个张量经过了 transpose 或者 permute 函数的处理之后，就无法使用 view 函数进行形状操作。

import torch
import numpy as np


def test():

    data = torch.tensor([[10, 20, 30], [40, 50, 60]])
    print('data shape:', data.size())

    # 1. 使用 view 函数修改形状
    new_data = data.view(3, 2)
    print('new_data shape:', new_data.shape)

    # 2. 判断张量是否使用整块内存
    print('data:', data.is_contiguous())  # True

    # 3. 使用 transpose 函数修改形状
    new_data = torch.transpose(data, 0, 1)
    print('new_data:', new_data.is_contiguous())  # False
    # new_data = new_data.view(2, 3)  # RuntimeError

    # 需要先使用 contiguous 函数转换为整块内存的张量，再使用 view 函数
    print(new_data.contiguous().is_contiguous())
    new_data = new_data.contiguous().view(2, 3)
    print('new_data shape:', new_data.shape)


if __name__ == '__main__':
    test()

程序运行结果:

data shape: torch.Size([2, 3])
new_data shape: torch.Size([3, 2])
data: True
new_data: False
True
new_data shape: torch.Size([2, 3])

4.4 squeeze 和 unsqueeze 函数的用法

squeeze 函数用删除 shape 为 1 的维度，unsqueeze 在每个维度添加 1, 以增加数据的形状。

import torch
import numpy as np


def test():

    data = torch.tensor(np.random.randint(0, 10, [1, 3, 1, 5]))
    print('data shape:', data.size())

    # 1. 去掉值为1的维度
    new_data = data.squeeze()
    print('new_data shape:', new_data.size())  # torch.Size([3, 5])

    # 2. 去掉指定位置为1的维度，注意: 如果指定位置不是1则不删除
    new_data = data.squeeze(2)
    print('new_data shape:', new_data.size())  # torch.Size([3, 5])

    # 3. 在2维度增加一个维度
    new_data = data.unsqueeze(-1)
    print('new_data shape:', new_data.size())  # torch.Size([3, 1, 5, 1])


if __name__ == '__main__':
    test()

程序运行结果:

data shape: torch.Size([1, 3, 1, 5])
new_data shape: torch.Size([3, 5])
new_data shape: torch.Size([1, 3, 5])
new_data shape: torch.Size([1, 3, 1, 5, 1])

4.5 小节

本小节带着同学们学习了经常使用的关于张量形状的操作，我们用到的主要函数有:

  1. reshape 函数可以在保证张量数据不变的前提下改变数据的维度.
  2. transpose 函数可以实现交换张量形状的指定维度, permute 可以一次交换更多的维度.
  3. view 函数也可以用于修改张量的形状, 但是它要求被转换的张量内存必须连续，所以一般配合 contiguous 函数使用.
  4. squeeze 和 unsqueeze 函数可以用来增加或者减少维度.

 

小言从不摸鱼
关注
pytorch张量的拆分与合并
qq_40107571的博客
10-28 1735
pytorch张量的拆分与合并
Pytorch-张量基础操作
小森的博客
03-23 1520
😆😆😆我们先来看一下张量的介绍😆😆😆。
Pytorch-张量操作：拼接，切分，索引和变换
qq_44817900的博客
08-11 769
将张量按维度dim进行拼接在上进行拼接将张脸按维度dim进行平均切分返回值：张量列表注：若不能整除，最后一个张量小于其他张量，向上取整将张量按维度dim进行切分。
PyTorch张量拼接方式【附维度拼接/叠加的数学推导】
最新发布
逐梦苍穹的博客
07-17 537
PyToorch张量拼接，带你推导维度拼接和叠加的数学原理！
pytorch张量拼接与切分
OldDriver1995的博客
08-01 1488
拼接 第一种方法 cat 在指定维度上拼接 t = torch.ones((3,2)) res = torch.cat([t, t], dim=0) res 按行拼接，会生成一个（6，2）的张量 如果dim=1就是按列拼接，生成（3，4）的张量 如果是三维张量: t = torch.ones((2,3,2)) res = torch.cat([t, t], dim=0) res 这个时候dim=0是针对第三维的个数， dim=1，2才分别是行，列 第二种方法stack 在新创建的维度上拼接 t
PyTorch: 张量的拼接、切分、索引
timerring的博客
10-29 1762
文章目录 一、张量拼接与切分 1.1 torch.cat 1.2 torch.stack 1.3 torch.chunk 1.4 torch.split 二、张量索引 2.1 torch.index_select 2.2 torch.masked_select 一、张量拼接与切分 1.1 torch.cat 功能：将张量按维度dim 进行拼接 tensors : 张量序列 dim： 要拼接的维度 t = torch.ones((2, 3)) t_0 = torch.cat([t, t],
PyTorch - 10 - CNN扁平化操作 (Flatten Operation) 可视化 - 用于深度学习的张量批处理
weixin_48367136的博客
01-11 5611
欢迎回到有关神经网络编程的系列文章。 在本文中，我们将可视化单个灰度图像的张量展平操作，并且将展示如何展平特定的张量轴，这是CNN经常需要的，因为我们处理的是与单个输入相对的成批输入。 事不宜迟，让我们开始吧。
pytorch--数据预处理基础操作(2)
超越永无止境的博客
03-06 2052
数据预处理篇 import os os.makedirs(os.path.join('..', 'data'), exist_ok=True) data_file = os.path.join('..', 'data', 'house_tiny.csv') with open(data_file, 'w') as f: f.write('NumRooms,Alley,Price\n') # 列名 f.write('NA,Pave,127500\n') # 每行表示一个数据样本
Pytorch数据拼接与拆分操作实现图解
09-16
例如，如果你有两个形状为`(3, 4)`的张量`tensor1`和`tensor2`，你可以将它们沿着第二个维度（索引为1）拼接，得到一个新的形状为`(3, 8)`的张量。代码示例如下： ```python import torch tensor1 = torch.rand(3, ...
Pytorch快速入门系列---（一）张量及运算
qq_42681787的博客
03-06 3409
在上面的例子中，我们演示了如何调用pytorch中的函数查看、修改默认数据类型，但是这种修改是全局的，如何我们想要把一个张量a（32位浮点型）转换为16位有符号整型但是又不影响其他张量的数据类型怎么办呢？我们接着看下面一个例子。torch.sort()函数：对一维张量进行排序，或者对高维张量在指定的维度进行排序，在输出排序结果的同时，还会输出对应的值在原始位置的索引。张量计算主要包括张量之间的大小比较、张量的基本运算（元素之间的运算和矩阵之间的运算）、张量与统计相关的运算（排序、最大值、最小值）
Pytorch深度学习实战3-3：张量Tensor的分块、变形、排序、极值与in-place操作
FRIGIDWINTER的博客
02-17 3985
总结Pytorch中的张量Tensor分块、组合、变形(维度变换、维度交换、序列化与反序列化、扩展)、排序、极值、in-place操作的基本API方法
【Pytorch基础（3）】张量的拼接，拆分与统计
lingchen1906的博客
01-19 1860
张量的拼接主要通过cat()和stack()函数实现。其中torch.cat([a, b], dim=n)是在n维度上进行两个张量的拼接，其参数n的含义代表要进行拼接操作的维度，a和b则代表要拼接的张量。在使用cat()方法时需要注意的是两个张量除了拼接的维度可以不同，其他的维度必须相同，否则会报错。示例如下：torch.stack([a, b], dim=n)是拼接两个张量a，b时，在维度n之前生成一个新的维度。
Pytorch张量的拆分与拼接
日拱一卒，功不唐捐
07-08 1万+
Pytorch的拆分与拼接 预览 在 PyTorch 中，对张量 (Tensor) 进行拆分通常会用到两个函数： torch.split [按块大小拆分张量] torch.chunk [按块数拆分张量] 而对张量 (Tensor) 进行拼接通常会用到另外两个函数： torch.cat [按已有维度拼接张量] torch.stack [按新维度拼接张量] 1.张量的拆分 torch.split函数 torch.split(tensor, split_size_or_sections, d
[PyTroch系列-14]：PyTorch基础 - 张量的操作 - 拼接与堆叠
文火冰糖（王文兵）的博客
08-07 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 第1章 Tensor运算概述 1.1 概述 PyTorch提供了大量的张量运算，基本上可以对标Numpy多维数组的运算，以支持对张量的各种复杂的运算。 这些操作运算中大多是对数组中每个元素执行相同的函数运算，并获得每个元素函数运算的结果序列，这些序列生成一个新的同维度的数组。 https://www.runoob.com/numpy/numpy-linear-algebra.h
[Pytorch]张量的合并：cat和stack操作
weixin_45863060的博客
04-22 1188
这里简单的理解是，两个shape为[2,2,3]的张量在dim=0上合并后，由原来两个2x[2,3]的张量合并为了一个4x[2,3]的张量，即shape为[4,2,3]的张量；而两个shape为[2,2,3]的张量在dim=1上合并后第一个维度的数量不变，而将第二个维度进行合并，可以看作将原来2x[2,3]的张量合并为了2x[4，3]的张量，原来每个[2x3]的张量的行数扩展至了4行。将多个向量在同一维度上进行合并，并且要求在指定维度dim外，其他维度的形状应保持相同。关于在不同维度上合并的结果。
Pytorch数据类型Tensor张量操作(操作比较全)
weixin_45863060的博客
06-22 4015
本文只简单介绍pytorch中的对于张量的各种操作，主要列举介绍其大致用法和简单demo。后续更为详细的介绍会进行补充...
torch中的数据类型和相互转换
热门推荐
程西西
12-12 1万+
文章目录1 torch.Tensor2 Data types3 Initializing and basic operations1）使用torch.tensor() 创建2）使用python list创建3）使用zeros ones函数创建4）通过torch.dtype指定类型， torch.device指定构造器5）零维张量6）torch.Tensor.item()从包含单个值的张量中获取Python数字4 type changes1）tensor间类型转换2）数据存储位置转换3）与Python数据类型
pytorch中张量的合并操作.cat()、.stack()方法
qq_43061415的博客
03-01 9108
### 张量的合并操作 张量的合并操作类似与列表的追加元素，可以拼接、也可以堆叠。 #### 1.拼接方法：.cat() PyTorch中，可以使用.cat()方法实现张量的拼接,==不改变张量形状，并且返回结果是原张量的视图==。 **（1）.cat()方法的使用，第一个参数和第二个参数：为目标张量，第三个参数：0表示行数增加，1表示列数增加，注意观察张量形状**
PyTorch中文文档精华：张量操作与核心功能速览
`torch.is_tensor()`和`torch.is_storage()`两个函数分别用于检测给定的对象是否为PyTorch张量或存储对象，这对于在代码中进行类型检查非常有用。 `torch.set_default_tensor_type(t)`允许用户设置默认的张量类型。...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值