PyTorch--Tensor拼接、切分、置换

已于 2024-09-07 17:42:41 修改
阅读量959 收藏 4
点赞数 26
文章标签： pytorch 人工智能 python 深度学习
于 2024-09-07 17:41:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74895132/article/details/141994592
版权

目录

1、拼接

torch.cat()

torch.stacks()

2、切分

torch.chunk()

torch.split()

 3、置换

1、拼接
torch.cat()

torch.cat(tensors,dim=0,out=None):将张量按照dim维度进行拼接

torch.stacks()

torch.stacks(tensors,dim=0,out=None):将张量在新创建的dim维度上进行拼接

(tensors:待拼接的张量序列，dim:要拼接的维度，out:输出的张量，如果指定，则返回的张量与out指向同一个地址)

import torch

# tensor拼接和拆分
a = torch.tensor([[1, 2, 3], [4, 5, 6]])
b = torch.tensor([[10, 10, 10], [10, 10, 10]])
print("a：", a.shape)
print("b：", b.shape)
# -------------------拼接--------------------
# 在指定的维度dim上，连接给定的一组张量，除了要拼接的维度外，其他维度数值必须保持一致
print("dim=0:\n", torch.cat((a, b), dim=0))
print(torch.cat((a, b), dim=0).shape)
# dim=0:
#  tensor([[ 1,  2,  3],
#         [ 4,  5,  6],
#         [ 7,  8,  9],
#         [10, 10, 10],
#         [10, 10, 10],
#         [10, 10, 10]])
# torch.Size([6, 3])

print("dim=1:\n", torch.cat((a, b), dim=1))
print(torch.cat((a, b), dim=1).shape)
# dim=1:
#  tensor([[ 1,  2,  3, 10, 10, 10],
#         [ 4,  5,  6, 10, 10, 10],
#         [ 7,  8,  9, 10, 10, 10]])
# torch.Size([3, 6])

print(torch.stack((a, b), dim=0))
print(torch.stack((a, b), dim=0).shape)
# tensor([[[ 1,  2,  3],
#          [ 4,  5,  6]],
#
#         [[10, 10, 10],
#          [10, 10, 10]]])
# torch.Size([2, 2, 3])

print(torch.stack((a, b), dim=1))
print(torch.stack((a, b), dim=1).shape)
# tensor([[[ 1,  2,  3],
#          [10, 10, 10]],
#
#         [[ 4,  5,  6],
#          [10, 10, 10]]])
# torch.Size([2, 2, 3])

print(torch.stack((a, b), dim=2))
print(torch.stack((a, b), dim=2).shape)
# tensor([[[ 1, 10],
#          [ 2, 10],
#          [ 3, 10]],
#
#         [[ 4, 10],
#          [ 5, 10],
#          [ 6, 10]]])
# torch.Size([2, 3, 2])
2、切分
torch.chunk()

torch.chunk(input,chunks,dim=0)：将张量按照dim维度进行切分，若不能整除，则最后一份张量小于其他张量

(input：待切分的张量,chunks：切分的数量,dim：切分的维度)

t = torch.tensor([[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3], [4, 4, 4, 4, 4, 4]])
print(torch.chunk(t, 2, 0))
print(type(torch.chunk(t, 2, 0)))  # 切分之后的结果是一个元组，元组中有两个张量
# (tensor([[1, 1, 1, 1, 1, 1],
#         [2, 2, 2, 2, 2, 2]]), tensor([[3, 3, 3, 3, 3, 3],
#         [4, 4, 4, 4, 4, 4]]))
# <class 'tuple'>
print(torch.chunk(t, 2, 0)[0])
print(torch.chunk(t, 2, 0)[1])
# tensor([[1, 1, 1, 1, 1, 1],
#         [2, 2, 2, 2, 2, 2]])
# tensor([[3, 3, 3, 3, 3, 3],
#         [4, 4, 4, 4, 4, 4]])

print(torch.chunk(t, 3, 1))
print(torch.chunk(t, 3, 1)[0])
print(torch.chunk(t, 3, 1)[1])
# (tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]]), tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]]), tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]]))
# tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]])
# tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]])

t = torch.tensor([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3], [4, 4, 4, 4, 4, 4]],
                  [[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3], [4, 4, 4, 4, 4, 4]],
                  [[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3], [4, 4, 4, 4, 4, 4]]])
print(t.shape)
# torch.Size([3, 4, 6])
print(torch.chunk(t, 3, 0))
print(torch.chunk(t, 3, 0)[0].shape)
# (tensor([[[1, 1, 1, 1, 1, 1],
#          [2, 2, 2, 2, 2, 2],
#          [3, 3, 3, 3, 3, 3],
#          [4, 4, 4, 4, 4, 4]]]), tensor([[[1, 1, 1, 1, 1, 1],
#          [2, 2, 2, 2, 2, 2],
#          [3, 3, 3, 3, 3, 3],
#          [4, 4, 4, 4, 4, 4]]]), tensor([[[1, 1, 1, 1, 1, 1],
#          [2, 2, 2, 2, 2, 2],
#          [3, 3, 3, 3, 3, 3],
#          [4, 4, 4, 4, 4, 4]]]))
# torch.Size([1, 4, 6])

print(torch.chunk(t, 2, 1))
print(torch.chunk(t, 2, 1)[0].shape)
# (tensor([[[1, 1, 1, 1, 1, 1],
#          [2, 2, 2, 2, 2, 2],
#          [3, 3, 3, 3, 3, 3],
#          [4, 4, 4, 4, 4, 4]]]), tensor([[[1, 1, 1, 1, 1, 1],
#          [2, 2, 2, 2, 2, 2],
#          [3, 3, 3, 3, 3, 3],
#          [4, 4, 4, 4, 4, 4]]]), tensor([[[1, 1, 1, 1, 1, 1],
#          [2, 2, 2, 2, 2, 2],
#          [3, 3, 3, 3, 3, 3],
#          [4, 4, 4, 4, 4, 4]]]))
# torch.Size([1, 4, 6])

print(torch.chunk(t, 3, 2))
print(torch.chunk(t, 3, 2)[0].shape)
# (tensor([[[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]],
# 
#         [[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]],
# 
#         [[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]]]), tensor([[[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]],
# 
#         [[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]],
# 
#         [[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]]]), tensor([[[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]],
# 
#         [[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]],
# 
#         [[1, 1],
#          [2, 2],
#          [3, 3],
#          [4, 4]]]))
# torch.Size([3, 4, 2])
torch.split()

torch.split():将张量按照dim维度进行平均切分，可指定每一个分量的长度

torch.split(input,split_size_or_sections,dim=0)

(input:待切分的张量，split_size_or_sections:若为int，表示每一个分量的长度；若为list，按照list元素给分量分配长度；dim:切分的维度)

t = torch.tensor([[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3], [4, 4, 4, 4, 4, 4]])
print(torch.split(t, 2, dim=0))
# (tensor([[1, 1, 1, 1, 1, 1],
#         [2, 2, 2, 2, 2, 2]]), tensor([[3, 3, 3, 3, 3, 3],
#         [4, 4, 4, 4, 4, 4]]))

t1 = torch.split(t, [1, 2, 3], dim=1)
print(t1)
for i in t1:
    print(i)
# (tensor([[1],
#         [2],
#         [3],
#         [4]]), tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]]), tensor([[1, 1, 1],
#         [2, 2, 2],
#         [3, 3, 3],
#         [4, 4, 4]]))
# 
# tensor([[1],
#         [2],
#         [3],
#         [4]])
# tensor([[1, 1],
#         [2, 2],
#         [3, 3],
#         [4, 4]])
# tensor([[1, 1, 1],
#         [2, 2, 2],
#         [3, 3, 3],
#         [4, 4, 4]])
 3、置换
a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
# tensor([[1, 2, 3],
#         [4, 5, 6],
#         [7, 8, 9]])
# 转置，只接受二维的
print(a.T)
print(torch.t(a))
print(torch.transpose(a, 1, 0))  # transpose(a, 1, 0)和transpose(a, 0, 1)效果一致，都是dim[0]和dim[1]互换
# tensor([[1, 4, 7],
#         [2, 5, 8],
#         [3, 6, 9]])
print(a.permute(1, 0))  # 可接受多维的
# tensor([[1, 4, 7],
#         [2, 5, 8],
#         [3, 6, 9]])

c = torch.unsqueeze(a, 0)  # 三维张量
print(c)
print(c.shape)
# tensor([[[1, 2, 3],
#          [4, 5, 6],
#          [7, 8, 9]]])
# torch.Size([1, 3, 3])

print(c.permute(1, 0, 2))  # 0和1维度互换
print(c.permute(1, 0, 2).shape)
# tensor([[[1, 2, 3]],
#
#         [[4, 5, 6]],
#
#         [[7, 8, 9]]])
# torch.Size([3, 1, 3])

print(c.permute(2, 1, 0))
print(c.permute(2, 1, 0).shape)
# tensor([[[1],
#          [4],
#          [7]],
#
#         [[2],
#          [5],
#          [8]],
#
#         [[3],
#          [6],
#          [9]]])
# torch.Size([3, 3, 1])
ww'
关注
使用pytorch-superpoint与pytorch-superglue项目实现训练自己的数据集
a486259的博客
01-07 4830
superpoint与superglue的组合可以实现基于深度学习的图像配准，官方发布的superpoint与superglue模型均基于coco数据训练，与业务中的实际数据或许存在差距，为此实现基于开源的pytorch-superpoint与pytorch-superglue项目实现训练自己的数据集。然而，在训练pytorch-superpoint有诸多细节需要优化，特此整理成技术文档。本文档描述了实验pytorch-superpoint与pytorch-superglue项目训练自己的图像配准模型。
Tensor——拼接与拆分
surymy
06-16 4518
文章目录1. 拼接(1). cat(2). stack2. 拆分(1). split(2). chunk 1. 拼接 (1). cat 注意要指出在哪个维度上进行拼接： >>> import torch >>> a = torch.rand(4,32,8) >>> b = torch.rand(5,32,8) >>> torch.cat([a,b],dim=0).shape torch.Size([9, 32, 8]) 且除了要拼接的
详解pytorch之tensor的拼接
06-12 2万+
tensor经常需要进行拼接、拆分与调换维度，比如通道拼接，比如通道调至最后一个维度等，本文的目的是详细讨论一下具体是怎么拼接的。如果本来就理解这其中的原理的童鞋就不用往下看了，肯定觉得啰嗦了...
Pytorch：Tensor之间的拼接与拆分【拼接：cat、stack；拆分：split、chunk】
u013250861的博客
03-11 4791
一、cat函数 二、stack函数 三、split函数 四、chunk函数 参考资料： Pytorch:Tensor的合并与分割
PyTorch|Tensor基础操作：拼接、切分、索引和变换
木千之
01-11 2765
在学习了Tensor的创建方法之后，接下来你可能会问：那么我们可以对Tensor进行哪些操作呢？不急，今天我们就来聊聊Tensor的操作方法。这部分主要包含两类：Tensor的基础操作：如拼接、切分、索引和变换Tensor的数学运算。
Pytorch学习笔记【5】---tensor的拼接和拆分
python_LC_nohtyp的博客
05-11 1188
Pytorch学习笔记【5】—tensor的拼接和拆分 # cat a = torch.rand(4,32,8) b = torch.rand(5,32,8) torch.cat([a,b],dim=0).shape torch.Size([9, 32, 8]) a1 =torch.rand(4,3,32,32) a2 = torch.rand(5,3,32,32) print(torch.cat([a1,a2],dim=0).shape) a2 = torch.rand(4,1,32,32) prin
PyTorch深度学习基础---Tensor的变换、拼接和拆分
Ting_28的博客
03-11 799
PyTorch提供了大量的对Tensor进行操作的函数或方法这些函数内部使用指针实现对矩阵的形状变化、拼接和拆分等操作。
pytorch-direct_dgl:基于PyTorch-1.8.0nightly（e152ca5）的PyTorch-Direct代码，用于使用面向GPU的数据通信体系结构进行大图卷积网络训练（正在审查PVLDB提交）
04-12
PyTorch-Direct的当前实现基于PyTorch-1.8.0的夜间版本。 安装 由于我们修改了PyTorch的源代码，因此无法通过诸如pip类的众所周知的工具来安装我们的实现。 要编译并安装我们代码的修改后的版本，请按照。 用例 在...
pytorch-tensor-decompositions:卷积层的[1412.6553]和[1511.06530]张量分解方法的PyTorch实现
04-28
PyTorch张量分解 这是卷积层的Tucker和CP分解的实现。 关于此的博客文章可以在找到。 它取决于来执行张量分解。 用法 根据微调VGG16训练模型： python main.py --train 。 应该有一个包含两个类别的数据集。 每个...
Pytorch基础 - 0. Tensor数据类型与存储结构
Aaron_neil的博客
04-13 2227
pytorch中最常见的tensor张量，包括数据类型，创建类型，类型转换，以及存储方式和数据结构。
TensorFlow tensor的拼接实例
12-23
TensorFlow提供两种类型的拼接： tf.concat(values, axis, name='concat')：按照指定的已经存在的轴进行拼接 tf.stack(values, axis=0, name='stack')：按照指定的新建的轴进行拼接 t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] tf.concat([t1, t2], 0) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] tf.concat([t1, t2], 1) ==> [[1, 2,
Pytorch 之修改Tensor部分值方式
12-23
一：背景引入 对于一张图片，怎样修改局部像素值? 二：利用Tensor方法 比如输入全零tensor，可认为为黑色图片 >>> n=torch.FloatTensor(3,3,4).fill_(0) >>> n tensor([[[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]], [[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]], [[0., 0., 0.,
PyTorch中Tensor的拼接与拆分
热门推荐
Steven的博客
04-26 10万+
拼接张量： 在给定维度上对输入的张量序列 seq 进行连接操作 拆分张量： 将输入张量分割成相等形状的 chunks（如果可分）。 如果沿指定维的张量形状大小不能被 split_size 整分， 则最后一个分块会小于其它分块。 ...
tensorflow对图像进行拼接
Understand-image
09-05 3196
tensorflow对图像进行多个块的行列拼接 在深度学习过程中，通过卷积得到的图像块大小是8×8×1024的图像块，对得到的图像块进行reshape得到[8×8]×[32×32]，其中[8×8]是图像块的个数，[32×32]是小图像的大小。通过tf.concat对小块的图像进行拼接。 -在做图像卷积的过程中，做了这样一个比较麻烦的拼接，现在还没想到更好的拼接方法，因为是块拼接，开始的时候使用...
【用图说话】PyTorch中Tensor的拼接
kevin的博客
07-25 1万+
PyTorch中Tensor的拼接 PyTorch中Tensor的拼接方法：torch.cat() 、torch.stack() 【小提示：代码得到下面的图】 torch.cat() 我们用图+代码来举例 import torch x1 = torch.randn(1, 3) x2 = torch.randn(1, 3) # 在 0 维(纵向)进行拼接 torch.cat((x1, x2), 0) # size [2, 3] # 在 1 维(横向)进行拼接 torch.cat((x1, x2)
PyTorch深度学习基础之Tensor的变换、拼接、拆分讲解及实战（附源码 超详细必看）
showswoller的博客
11-23 1014
PyTorch深度学习基础之Tensor的变换、拼接、拆分讲解及实战（附源码 超详细必看）
【Pytorch实用教程】PyTorch中的Tensor拼接与组合以及其意义
最新发布
惊鸿若梦一书生
08-01 115
各位，今天我们要一起探索一个在深度学习中非常重要的概念 —— Tensor的拼接与组合。你可以把这些操作想象成是在搭积木，通过这些操作，我们可以构建复杂的神经网络模型，处理大规模数据集。
pytorch-lightning镜像
08-25
PyTorch-Lightning镜像是一个预先配置好的虚拟环境，其中包含了使用PyTorch-Lightning的必要依赖项和库。PyTorch-Lightning是一个轻量级的PyTorch扩展库，简化了PyTorch模型训练和部署过程中的许多重复性任务，提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ww'

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值