pytorch张量 张量操作

最新推荐文章于 2024-05-17 11:10:58 发布
最新推荐文章于 2024-05-17 11:10:58 发布
阅读量2.2k 收藏 14
点赞数 1
分类专栏： pytorch 文章标签： python 深度学习 机器学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhhxxn/article/details/110092572
版权
一、改变张量的形状

改变张量的形状在深度学习的使用过程中会经常遇到，而且针对不同的情况对张量形状尺寸的改变有多种函数和方法可以使用
tensor.reshape()方法

import torch
A = torch.arange(12.0).reshape(3,4)
A
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  6.,  7.],
#         [ 8.,  9., 10., 11.]])

torch.reshape()方法

import torch
A = torch.arange(12.0).reshape(3,4)
print(A)
print(torch.reshape(input=A,shape=(2,-1)))
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  6.,  7.],
#         [ 8.,  9., 10., 11.]])
# tensor([[ 0.,  1.,  2.,  3.,  4.,  5.],
#         [ 6.,  7.,  8.,  9., 10., 11.]])

tensor.resize_()方法

import torch
A = torch.arange(12.0).reshape(3,4)
print(A)
print(A.resize_(2,6))

A.resize_as_(B)方法

import torch
A = torch.arange(12.0).reshape(3,4)
B = torch.arange(10.0,19.0).reshape(3,3)
A.resize_as_(B)
print(A)
print(B)
# tensor([[0., 1., 2.],
#         [3., 4., 5.],
#         [6., 7., 8.]])
# tensor([[10., 11., 12.],
#         [13., 14., 15.],
#         [16., 17., 18.]])

torch.unsqueeze()函数可以在张量的指定维度插入新的维度得到维度提升的张量
torch.squeeze()函数可以移除指定维度或者所有维度大小为1的维度，从而得到维度减小的新张量

import torch
A = torch.arange(12.0).reshape(2,6)
B = torch.unsqueeze(A,dim = 0)
print("B.shape:",B.shape)
# torch.Size([1, 2, 6])

C = B.unsqueeze(dim = 3)
print("C.shape:",C.shape)

D = torch.squeeze(C)
print("D.shape:",D.shape)

E = torch.squeeze(C,dim = 0)
print("E.shape:",E.shape)

# B.shape: torch.Size([1, 2, 6])
# C.shape: torch.Size([1, 2, 6, 1])
# D.shape: torch.Size([2, 6])
# E.shape: torch.Size([2, 6, 1])

.expand()方法对张量的维度进行拓展，从而对张量的大小形状进行修改。
A.expand_as©方法，则会将张量A根据张量C的形状进行拓展，得到新的张量。

import torch
A = torch.arange(3)
B = A.expand(3,-1)
print(B)

C = torch.arange(6).reshape(2,3)
D = A.expand_as(C)
print(D)

# tensor([[0, 1, 2],
#         [0, 1, 2],
#         [0, 1, 2]])
# tensor([[0, 1, 2],
#         [0, 1, 2]])

张量的.repeat()方法，可以将张量看作一个整体，然后根据指定的形状进行重复填充，得到新的张量

import torch
A = torch.arange(3)
C = torch.arange(6).reshape(2,3)
D = A.expand_as(C)
print(D)
E = D.repeat(2,2,6)
print(E)
print(E.shape)

# tensor([[0, 1, 2],
#         [0, 1, 2]])
# tensor([[[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
#          [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
#          [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
#          [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]],

#         [[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
#          [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
#          [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
#          [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]]])
# torch.Size([2, 4, 18])
二、获取张量中的元素

和numpy一致，利用索引和切片的方法提取元素

import torch
A = torch.arange(12).reshape(1,3,4)
print(A)
# tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]]])

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

print(A[0,0:2,:]) #获取第0维度下矩阵的前两行元素
# tensor([[0, 1, 2, 3],
#         [4, 5, 6, 7]])

print(A[0,-1,-4:-1]) #获取第0维度下的矩阵最后一行-4~-1列
# tensor([ 8,  9, 10])

也可按需将索引设置为相应的布尔值，然后提取为真条件下的内容

import torch
A = torch.arange(12).reshape(1,3,4)
print(A)
# tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]]])

B =  -A
print(B)
# tensor([[[  0,  -1,  -2,  -3],
#          [ -4,  -5,  -6,  -7],
#          [ -8,  -9, -10, -11]]])

print(torch.where(A>5,A,B)) #当A>5为true时返回x对应位置值,为false时返回y的值
# tensor([[[ 0, -1, -2, -3],
#          [-4, -5,  6,  7],
#          [ 8,  9, 10, 11]]])

print(A[A>5])
# tensor([ 6,  7,  8,  9, 10, 11])

torch.tril()函数可以获取张量下三角部分的内容，而将上三角部分的元素设置为0
torch.triu()函数可以获取张量上三角部分的内容，而将下三角部分的元素设置为0
torch.diag()函数可以获取矩阵张量的对角线元素，或者提供一个向量生成一个矩阵张量

import torch
A = torch.arange(12).reshape(1,3,4)
print(A)
# tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]]])

print(torch.tril(A,diagonal=0))
# tensor([[[ 0,  0,  0,  0],
#          [ 4,  5,  0,  0],
#          [ 8,  9, 10,  0]]])

print(torch.tril(A,diagonal = 1)) #diagonal参数控制要考虑的对角线
# tensor([[[0, 0, 0, 0],
#          [4, 0, 0, 0],
#          [8, 9, 0, 0]]])

print(torch.triu(A,diagonal=0))
# tensor([[[ 0,  1,  2,  3],
#          [ 0,  5,  6,  7],
#          [ 0,  0, 10, 11]]])

C = A.reshape(3,4)
print(C)
# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11]])

print(torch.diag(C,diagonal=0))
# tensor([ 0,  5, 10])

print(torch.diag(C,diagonal=1))
# tensor([ 1,  6, 11])

torch.diag(torch.tensor([1,2,3]))
# tensor([[1, 0, 0],
#         [0, 2, 0],
#         [0, 0, 3]])
三、拼接和拆分

troch.cat()函数

import torch
# 在给定的维度连接给定的张量序列
A = torch.arange(6.0).reshape(2,3)
print(A)
# tensor([[0., 1., 2.],
#         [3., 4., 5.]])

B = torch.linspace(0,10,6).reshape(2,3)
print(B)
# tensor([[ 0.,  2.,  4.],
#         [ 6.,  8., 10.]])

C = torch.cat((A,B),dim = 0) #在0维度连接张量
print(C)
# tensor([[ 0.,  1.,  2.],
#         [ 3.,  4.,  5.],
#         [ 0.,  2.,  4.],
#         [ 6.,  8., 10.]])

D = torch.cat((A,B),dim = 1) #在1维度上连接张量
print(D)
# tensor([[ 0.,  1.,  2.,  0.,  2.,  4.],
#         [ 3.,  4.,  5.,  6.,  8., 10.]])

E= torch.cat((A[:,0:2],A,B),dim = 1) #在1维度上连接3个张量
print(E)
# tensor([[ 0.,  1.,  0.,  1.,  2.,  0.,  2.,  4.],
#         [ 3.,  4.,  3.,  4.,  5.,  6.,  8., 10.]])

E = torch.cat((A[:,1:2],A,B),dim=1)
print(E)
# tensor([[ 1.,  0.,  1.,  2.,  0.,  2.,  4.],
#         [ 4.,  3.,  4.,  5.,  6.,  8., 10.]])

torch.stack()函数

import torch
# 在给定的维度连接给定的张量序列
A = torch.arange(6.0).reshape(2,3)
print(A)
# tensor([[0., 1., 2.],
#         [3., 4., 5.]])

B = torch.linspace(0,10,6).reshape(2,3)
print(B)
# tensor([[ 0.,  2.,  4.],
#         [ 6.,  8., 10.]])

F = torch.stack((A,B),dim=0) #沿新维度连接张量
print(F)
# tensor([[[ 0.,  1.,  2.],
#          [ 3.,  4.,  5.]],

#         [[ 0.,  2.,  4.],
#          [ 6.,  8., 10.]]])

print(F.shape)
# torch.Size([2, 2, 3])

G = torch.stack((A,B),dim = 2)
print(G)
# tensor([[[ 0.,  0.],
#          [ 1.,  2.],
#          [ 2.,  4.]],

#         [[ 3.,  6.],
#          [ 4.,  8.],
#          [ 5., 10.]]])
print(G.shape)
# torch.Size([2, 3, 2])

torch.chunk()函数可以将张量分割为特定数量的块
torch.split()函数在将张量分割为特定数量的块时，可以指定每个块的大小

import torch
# 在给定的维度连接给定的张量序列
A = torch.arange(6.0).reshape(2,3)
print(A)
# tensor([[0., 1., 2.],
#         [3., 4., 5.]])

B = torch.linspace(0,10,6).reshape(2,3)
print(B)
# tensor([[ 0.,  2.,  4.],
#         [ 6.,  8., 10.]])

E= torch.cat((A[:,0:2],A,B),dim = 1) #在1维度上连接3个张量
print(E)
# tensor([[ 0.,  1.,  0.,  1.,  2.,  0.,  2.,  4.],
#         [ 3.,  4.,  3.,  4.,  5.,  6.,  8., 10.]])

print(torch.chunk(E,2,dim = 0))
# (tensor([[0., 1., 0., 1., 2., 0., 2., 4.]]),
#  tensor([[ 3.,  4.,  3.,  4.,  5.,  6.,  8., 10.]]))

D = torch.cat((A,B),dim = 1) #在1维度上连接张量
print(D)
# tensor([[ 0.,  1.,  2.,  0.,  2.,  4.],
#         [ 3.,  4.,  5.,  6.,  8., 10.]])

D1,D2 = torch.chunk(D,2,dim = 1)
print(D1)
# tensor([[0., 1., 2.],
#         [3., 4., 5.]])
print(D2)
# tensor([[ 0.,  2.,  4.],
#         [ 6.,  8., 10.]])

E1,E2,E3 = torch.chunk(E,3,dim = 1) #如果沿给定维度dim的张量大小不能被块整除，则最后一个块最小
print(E1)
# tensor([[0., 1., 0.],
#         [3., 4., 3.]])
print(E2)
# tensor([[1., 2., 0.],
#         [4., 5., 6.]])
print(E3)
# tensor([[ 2.,  4.],
#         [ 8., 10.]])


D1,D2,D3 = torch.split(D,(1,2,3),dim = 1) #将张量切分为块，指定每个块的大小
print(D1)
# tensor([[0.],
#         [3.]])
print(D2)
# tensor([[1., 2.],
#         [4., 5.]])
print(D3)
# tensor([[ 0.,  2.,  4.],
#         [ 6.,  8., 10.]])
hhhhxxn
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Torch学习笔记—改变张量的形状
Blog Life
03-30 4201
1.改变张量的形状
tf建立tensor_【tensorflow 张量】创建张量1（1）
weixin_42364392的博客
01-17 912
TensorFlow2TensorFlow2将动态图机制作为默认模式，将tf.keras作为用于构建和训练模型的标准高阶APIimport tensorflow as tfprint("TensorFlow version:",tf.__version__)print("Eager execution is:",tf.executing_eagerly())创建Tensor对象¶张量由Tenso...
【Pytorch】一文向您介绍如何查找并获取张量中的非重复元素
最新发布
创作高质量博文，分享知识，共同进步！
05-17 1057
🚀 解锁PyTorch新技能，轻松查找张量非重复元素！🔍 在数据处理和深度学习旅程中，你是否曾为重复元素所困？别担心，`torch.unique()`来拯救你！从基础用法到实际场景应用，本文将带你轻松掌握这一利器。无论是数据预处理还是标签编码，它都能助你一臂之力。快来一起探索吧！#PyTorch #torch.unique() #非重复元素 #数据预处理 #深度学习
PyTorch入门4——张量变形
看流星划过天外的博客
02-12 599
介绍了 Pytorch 张量形状变换的函数方法，包括：reshape、transpose、permute、view、squeeze、unsqueeze、flatten等。
Pytorch：张量的形状操作
m0_63997099的博客
04-17 1586
该函数可以在张量的指定位置插入一个维度，它非常有用于调整张量的形状，以满足特定操作或模型的需求，例如在单样本张量上应用需要批处理的模型。方法用于重新排列张量的维度，这是处理多维数据时一个非常有用的功能，尤其在需要对维度进行特定的重排序操作时。方法用于交换张量中的两个维度，这是处理多维数组时一个常用的功能，尤其是在需要对特定的维度进行转置操作时。是 PyTorch 中的一个函数，用于减少张量的维度，特别是去除那些维度大小为1的维度。是一个方便的方法，用于将一个张量重新塑形为与另一个张量相同的形状。
pytorch使用view(*args)在不改变张量数据的情况下随意改变张量的大小和形状
genous110的博客
02-05 1179
torch.Tensor.view会返回具有相同数据但大小不同的新张量。 返回的张量必须有与原张量相同的数据和相同数量的元素，但可以有不同的大小。一个张量必须是连续contiguous()的才能被查看。类似于Numpy的np.reshape() pytorch中view的用法 torch.Tensor.view会将原有数据重新分配为一个新的张量，比如我们使用： x = torch.randn(2,...
pytorch张量创建与操作
01-20
张量创建 1. 直接创建 1.1 torch.tensor() 1.2 torch.from_numpy(ndarray) #从numpy创建tensor， 与原ndarray共享内存 2. 通过数值创建 2.1 torch.zeros() torch.zeros_like() torch.ones() torch.ones_like() ...
PyTorch张量与操作1
08-03
PyTorch提供了丰富的张量操作，包括加法。加法可以通过以下三种方式实现： 1. 使用`+`运算符： ```python x = torch.rand(5, 3) y = torch.rand(5, 3) print(x + y) ``` 2. 使用`torch.add()`函数： ```python ...
pytorch张量创建详细讲解
08-02
Jupyter文件，适用初学者，附带注释
创建pytorch张量
12-21
1、numpy->tensor 注： tensor()参数为具体的数据， Tensor() 和 FloatTensor()参数可以为数据也可以为维度信息，但是一般不用他来放数据 a = torch.Tensor(2, 3) print(a) a = torch.FloatTensor(2, 3) ...
pytorch张量数据类型
02-21
pytorch张量数据类型
TensorFlow常用函数：创建张量(tf.constant)，及一些特殊张量的创建。zeros，ones，fill，正态分布：random.normal和random.truncated_norm
01-21
1.创建常量(tf.constant) 函数原型： tf.constant( value, dtype=None, shape=None, name='Const', verify_shape=False ) 第一个参数是值，可以是单个的数，也可以是一个列表。 第二个参数是创建的变量的类型。默认是int t=tf.constant([1,2]) 如上创建出，显示如下： 第一个参数是形状，第二个是类型，第三个是值的大小。 打印一些信息： a = tf.constant([1, 5], dtype=tf.int64) print(a:, a) pri
Pytorch---Pytorch张量的变形与自动微分
qq_44961869的博客
04-20 787
一、张量的变形 1.张量的形状变换 代码 import torch import numpy as np if __name__ == '__main__': t = torch.randn(4, 6) print(t.shape) # 类型的转换 t1 = t.view(3, 8) print(t1.size()) # 转换为2维，最后一个维度为1，第一个维度-1代表自动计算 t2 = t.view(-1, 1) print(t2.shap
Pytorch-张量形状操作
小森的博客
04-16 1430
在 PyTorch 中，有些张量是由不同的数据块组成的，它们并没有存储在整块的内存中，view 函数无法对这样的张量进行变形处理，如果张量存储在不连续的内存中，使用view函数会导致错误。💎reshape 函数可以在保证张量数据不变的前提下改变数据的维度，将其转换成指定的形状，在后面的神经网络学习时，会经常使用该函数来调节数据的形状，以适配不同网络层之间的数据传递。当第二个参数为-1时，表示自动计算该维度的大小，以使得张量的元素总数不变，这样我们可以免去思考的时间。
[PyTroch系列-16]：PyTorch基础 - 张量的操作 - 变形
文火冰糖（王文兵）的博客
08-07 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 目录 第1章 Tensor运算与操作概述 1.1 概述 1.3 张量的操作与变换 1.4环境准备 1.5张量的操作 - 变形（reshape） 第2章 基本变形：reshape 1. 原理 2. 函数解读 3. 代码示例 第3章 2维矩阵的行列置换：t 1. 原理 2. 函数解读 3. 代码示例 第4章 任意维度方向上的置换：transpose 1. 原理..
Pytorch下张量的形状操作（详细）
weixin_47151388的博客
04-22 1180
这里将通过一个简单的Python例子来展示如何在PyTorch中使用上述的张量操作函数。我们将创建一个张量，然后对其进行维度改变、张量变形和维度重排的操作。在PyTorch中，对张量的形状进行操作是常见的需求，因为它允许我们重新组织、选择和操纵数据，以适应各种模型和函数的需求。它返回一个新的张量，其数据与原张量相同，但形状不同。维度重排涉及调整张量的维度顺序，这在处理不同数据格式时特别有用，比如从NCHW转换到NHWC。: 用于去除张量形状中所有的单维度条目，例如将形状为。: 返回张量的形状。
[TensorFlow系列-16]：TensorFlow基础 - 张量的操作 - 变形(降维、扩维、广播)
热门推荐
文火冰糖（王文兵）的博客
08-12 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 第1章 Tensor运算与操作概述 https://tensorflow.google.cn/api_docs/python/tf 1.1 概述 TensorFlow提供了大量的张量运算与操作，基本上可以对标Numpy多维数组的运算，以支持对张量的各种复杂的运算。 这些操作运算中大多是对数组中每个元素执行相同的函数运算，并获得每个元素函数运算的结果序列，这些序列生成一个新的..
TensorFlow2.x(二) ---- 常用函数讲解（创建张量）_ 适合入门学习的最全最细讲解
qq_55476112的博客
05-15 967
最常用的创建张量的函数，如tf.constant()、tf.conver_to_tensor()等的讲解还有一些特殊张量的计算，例如创建正态分布张量、均匀分布张量、以及全零全一张量，还陆续总结了很多常遇的问题；因此非常适合新手小白入门学习。也欢迎大家留下自己的讨论
Tensorflow深度学习实战之(二)--张量的属性和转换
tore007的博客
07-20 2176
对tensorflow的张量的属性和类型以及形状的转换进行说明
pytorch张量操作
05-03
PyTorch中的张量操作可以分为以下几类： 1. 创建张量： ```python import torch # 创建一个大小为(3, 2)的张量 tensor1 = torch.tensor([[1, 2], [3, 4], [5, 6]]) print(tensor1) # 创建一个大小为(2, 2)的全0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值