Pytorch张量视图（Tensor Views）

已于 2024-05-27 19:38:03 修改
阅读量1k 收藏 22
点赞数 23
分类专栏： PyTorch框架 文章标签： pytorch 人工智能 python
于 2024-05-27 17:03:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44815135/article/details/139236225
版权

文章目录

前言

张量视图（Tensor Views）是 PyTorch 中的一个重要概念。视图是指与原始张量共享相同底层数据的新张量，但具有不同的形状或步幅。

通过创建张量视图，我们可以在不复制数据的情况下对张量进行形状变换、切片和其他操作，从而实现快速且内存高效的操作。

1.torch.as_strided()

  使用 torch.as_strided 函数创建新的张量,这个新视图与原张量共享内存，但可以以不同的步幅访问这些数据。

import torch

# 创建一个输入张量
input = torch.tensor([1, 2, 3, 4, 5, 6])
output = torch.as_strided(input, size=(3, 2), stride=(2, 1))

# 打印输入张量和输出张量
print("Input tensor:")
print(input)

print("Output tensor:")
print(output)

Input tensor:
tensor([1, 2, 3, 4, 5, 6])
Output tensor:
tensor([[1, 2],
        [3, 4],
        [5, 6]])

2.torch.detach()

 当使用 torch.detach() 函数时，它会创建一个新的张量，该张量与原始张量共享相同的数据，但不共享计算图的梯度。这使得新张量可以被用作不需要梯度的中间结果或者被用于与原始张量相互独立的计算。

import torch

# 创建一个需要梯度的张量
x = torch.tensor([2.0, 3.0], requires_grad=True)

# 进行一些操作，并分离计算图
y = x + 1
z = y * 2
z_detached = z.detach()

# 查看张量的梯度信息
print(x.requires_grad)  # 输出: True
print(y.requires_grad)  # 输出: True
print(z.requires_grad)  # 输出: True
print(z_detached.requires_grad)  # 输出: False

3.torch.diagonal()

  用于提取张量的对角线元素。

torch.diagonal(input, offset=0, dim1=0, dim2=1)
"""
参数说明：

input：输入张量。
offset：对角线的偏移量，表示从主对角线的偏移量，默认为0（主对角线）。
dim1：起始维度。
dim2：结束维度。
"""

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

# 提取主对角线的元素
diagonal = torch.diagonal(x)

print(diagonal)  # 输出: tensor([1, 5, 9])

# 提取副对角线的元素
diagonal_offset = torch.diagonal(x, offset=1)

print(diagonal_offset)  # 输出: tensor([2, 6])

# 提取指定维度的对角线元素
diagonal_dim = torch.diagonal(x, dim1=1, dim2=0)

print(diagonal_dim)  # 输出: tensor([1, 5, 9])

4.torch.expand()

  torch.expand() 是 PyTorch 中的一个函数，用于扩展张量的形状。

torch.expand(input, size)
"""
参数说明：

input：输入张量。
size：扩展后的目标形状，可以是一个元组或列表。
"""

import torch

# 创建一个一维张量
x = torch.tensor([1, 2, 3])

# 扩展张量的形状
expanded = torch.expand(x, (2, 3))

print(expanded)
# 输出:
# tensor([[1, 2, 3, 1, 2, 3, 1, 2, 3],
#         [1, 2, 3, 1, 2, 3, 1, 2, 3]])

# 创建一个二维张量
y = torch.tensor([[1],
                  [2]])

# 扩展张量的形状
expanded_2 = torch.expand(y, (2, 3))

print(expanded_2)
# 输出:
# tensor([[1, 1, 1],
#         [2, 2, 2],
#         [1, 1, 1],
#         [2, 2, 2]])

5.torch.movedim()

  torch.movedim() 是 PyTorch 中的一个函数，用于移动张量的维度顺序。

torch.movedim(input, source, destination)
"""
参数说明：

input：输入张量。
source：原始维度或维度的序列。
destination：目标维度或维度的序列。
"""

import torch

# 创建一个三维张量
x = torch.tensor([[[1, 2],
                   [3, 4]],
                  
                  [[5, 6],
                   [7, 8]]])

# 移动张量的维度顺序
moved = torch.movedim(x, source=[0, 1, 2], destination=[2, 1, 0])

print(moved.shape)  # 输出: torch.Size([2, 2, 2])
print(moved)
# tensor([[[1, 5],
#          [3, 7]],

#         [[2, 6],
#          [4, 8]]])

6.torch.narrow()

  torch.narrow() 是 PyTorch 中的一个函数，用于沿指定维度缩小张量，通过选择一定范围的索引来实现。

torch.narrow(input, dim, start, length)
"""
参数说明：

input：输入张量。
dim：要缩小的维度。
start：缩小范围的起始索引。
length：缩小范围的长度。
"""

import torch

# 创建一个张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

# 沿着维度0进行缩小
narrowed = torch.narrow(x, 0, 1, 2)

print(narrowed)
# 输出:
# tensor([[4, 5, 6],
#         [7, 8, 9]])

7.torch.permute()

torch.permute() 是 PyTorch 中的一个函数，用于对张量进行维度重排。

torch.permute(*dims)
"""
参数说明：

*dims：要重排的维度顺序，可以是一个整数序列或多个整数参数。
"""

import torch

# 创建一个三维张量
x = torch.tensor([[[1, 2, 3],
                   [4, 5, 6]],
                  
                  [[7, 8, 9],
                   [10, 11, 12]]])

# 对张量进行维度重排
permuted = torch.permute(x, [0, 2, 1])
#permuted = x.permute(0,2,1)
print(permuted.shape)  # 输出: torch.Size([2, 3, 2])
print(permuted)
# 输出:
# tensor([[[ 1,  4],
#          [ 2,  5],
#          [ 3,  6]],
# 
#         [[ 7, 10],
#          [ 8, 11],
#          [ 9, 12]]])

8.torch.select()

torch.select() 是 PyTorch 中的一个函数，用于按照指定的条件选择张量中的元素。

torch.select(input, dim, index)
"""
参数说明：

input：输入张量。
dim：要选择的维度。
index：要选择的索引。
"""

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

# 在维度0上选择索引为1的元素
selected = torch.select(x, 0, 1)

print(selected)
# 输出:
# tensor([4, 5, 6])

9.torch.squeeze()

  torch.squeeze() 是 PyTorch 中的一个函数，用于去除张量中尺寸为 1 的维度。

torch.squeeze(input, dim=None)
"""
参数说明：

input：输入张量。
dim（可选）：指定要挤压的维度。
					如果指定了 dim，则只会挤压该维度上的尺寸为 1 的维度；
					如果未指定 dim，则会挤压所有尺寸为 1 的维度
"""

import torch

# 创建一个具有尺寸为 1 的维度的张量
x = torch.tensor([[[1, 2, 3]]])

# 去除尺寸为 1 的维度
squeezed = torch.squeeze(x)
x = x.squeeze()
print(x.shape)  # 输出: torch.Size([3])
print(x)
# 输出:
# tensor([1, 2, 3])

10.torch.transpose()

  torch.transpose() 是 PyTorch 中的一个函数，用于对张量进行转置操作，即交换维度的顺序。

torch.transpose() 和 torch.permute() 都是用于改变张量的维度顺序，但它们之间有一些区别。

  • 参数形式：torch.transpose() 函数接受两个参数 dim0 和 dim1，用于指定要交换的维度索引。而torch.permute() 函数接受一个可变数量的参数 *dims，用于指定新的维度顺序。
  • 功能范围：torch.transpose() 只能实现维度之间的交换，即将指定的两个维度进行交换。而 torch.permute()可以实现更灵活的维度重新排列，可以同时对多个维度进行重排，不仅仅是交换。
  • 维度顺序：torch.transpose() 只能交换两个维度的顺序，无法改变其他维度的顺序。而 torch.permute()可以在任意维度上进行重排，允许灵活地改变维度的顺序。
import torch

# 创建一个三维张量
x = torch.tensor([[[1, 2, 3],
                   [4, 5, 6]],

                  [[7, 8, 9],
                   [10, 11, 12]]])

# 使用 torch.transpose() 进行维度交换
transposed = torch.transpose(x, 0, 2)

# 使用 torch.permute() 进行维度重排
permuted = x.permute(2, 1, 0)

print(transposed.shape)  # 输出: torch.Size([3, 2, 2])
print(transposed)
# 输出:
# tensor([[[ 1,  4],
#          [ 7, 10]],
#
#         [[ 2,  5],
#          [ 8, 11]],
#
#         [[ 3,  6],
#          [ 9, 12]]])

print(permuted.shape)  # 输出: torch.Size([3, 2, 2])
print(permuted)
# 输出:
# tensor([[[ 1,  4],
#          [ 7, 10]],
#
#         [[ 2,  5],
#          [ 8, 11]],
#
#         [[ 3,  6],
#          [ 9, 12]]])

11.torch.t()

  该函数期望输入为 2 维或更低维的张量，并将维度 0 和维度 1 进行转置。0 维和 1 维张量将按原样返回。当输入为 2 维张量时，这等价于 transpose(input, 0, 1)。

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])

# 对张量进行转置操作
transposed = torch.t(x)

print(transposed.shape)  # 输出: torch.Size([3, 2])
print(transposed)
# 输出:
# tensor([[1, 4],
#         [2, 5],
#         [3, 6]])

import torch

# 创建一个一维张量
x = torch.tensor([1, 2, 3, 4, 5])

# 对张量进行转置操作
transposed = torch.t(x)

print(transposed.shape)  # 输出: torch.Size([5])
print(transposed)
# 输出:
# tensor([1, 2, 3, 4, 5])

12.torch.real和torch.imag

  torch.real() 函数用于提取复数张量中的实部部分。

import torch

# 创建一个复数张量
x = torch.tensor([1+2j, 3+4j, 5+6j])

# 提取复数张量的实部
real_part = torch.real(x)

print(real_part.shape)  # 输出: torch.Size([3])
print(real_part)
# 输出:
# tensor([1., 3., 5.])

import torch

# 创建一个复数张量
x = torch.tensor([1+2j, 3+4j, 5+6j])

# 分别提取复数张量的实部和虚部
real_part = x.real
imag_part = x.imag

print(real_part.shape)  # 输出: torch.Size([3])
print(real_part)
# 输出:
# tensor([1., 3., 5.], dtype=torch.float32)

print(imag_part.shape)  # 输出: torch.Size([3])
print(imag_part)
# 输出:
# tensor([2., 4., 6.], dtype=torch.float32)

13.torch.unflatten()

  torch.unflatten() 函数用于将给定的维度展平的张量恢复成原始的形状。

torch.unflatten(dim, input_sizes)
"""
参数说明：
dim：指定要展平的维度。
input_sizes：一个元组或列表，指定原始张量在指定维度上的各个子张量的大小。
"""

import torch

# 创建一个展平的张量
x = torch.tensor([1, 2, 3, 4, 5, 6])

# 恢复成原始形状
unflattened = torch.unflatten(x,0, (2, 3))

print(unflattened.shape)  # 输出: torch.Size([2, 3])
print(unflattened)
# 输出:
# tensor([[1, 2, 3],
#         [4, 5, 6]])

14.torch.unsqueeze()

  torch.unsqueeze() 函数用于在指定的维度上增加一个维度，从而扩展张量的形状。

torch.unsqueeze(input, dim)
"""
参数说明：
input：输入张量。
dim：指定要扩展的维度索引。
"""

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])

# 在维度 1 上增加一个维度
expanded = torch.unsqueeze(x, dim=1)

print(expanded.shape)  # 输出: torch.Size([2, 1, 3])
print(expanded)
# 输出:
# tensor([[[1, 2, 3]],
#         [[4, 5, 6]]])

15.torch.view()

  torch.view() 是 PyTorch 中用于调整张量形状的函数，它允许你重新定义张量的维度和大小，而不改变原始数据。

torch.view(*shape)
"""
参数说明：
shape：一个整数元组或多个整数参数，用于指定新张量的形状。
"""

import torch

# 创建一个张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])

# 改变张量的形状
reshaped = x.view(3, 2)

print(reshaped.shape)  # 输出: torch.Size([3, 2])
print(reshaped)
# 输出:
# tensor([[1, 2],
#         [3, 4],
#         [5, 6]])

16.torch.unbind()

  torch.unbind() 函数用于按维度将张量拆分为多个张量序列。

torch.unbind(input, dim=0)
"""
参数说明：
input：输入张量。
dim：指定的维度，沿该维度进行拆分。默认值为 0。
"""

import torch

# 创建一个张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])

# 按维度 1 拆分张量
unpacked = torch.unbind(x, dim=1)

print(len(unpacked))  # 输出: 3
print(unpacked[0])  # 输出: tensor([1, 4])
print(unpacked[1])  # 输出: tensor([2, 5])
print(unpacked[2])  # 输出: tensor([3, 6])

import torch

# 创建一个张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])

# 按维度 0 拆分张量
unpacked = torch.unbind(x, dim=0)

print(len(unpacked))  # 输出: 2
print(unpacked[0])  # 输出: tensor([1, 2, 3])
print(unpacked[1])  # 输出: tensor([4, 5, 6])

17.torch.split()

  torch.split() 函数用于按指定维度将张量分割为多个子张量。

torch.split(tensor, split_size_or_sections, dim=0)
"""
tensor：输入张量。
split_size_or_sections：指定分割的大小（整数）或分割的位置（整数列表）。
dim：指定的维度，沿该维度进行分割。默认值为 0。
"""

import torch

# 创建一个张量
x = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8])

# 按维度 0 使用整数列表分割张量
splits = torch.split(x, split_size_or_sections=[2, 3, 1, 2], dim=0)

print(len(splits))  # 输出: 4
print(splits[0])  # 输出: tensor([1, 2])
print(splits[1])  # 输出: tensor([3, 4, 5])
print(splits[2])  # 输出: tensor([6])
print(splits[3])  # 输出: tensor([7, 8])

import torch

# 创建一个张量
x = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8])

# 按维度 0 分割张量
splits = torch.split(x, split_size_or_sections=3, dim=0)

print(len(splits))  # 输出: 3
print(splits[0])  # 输出: tensor([1, 2, 3])
print(splits[1])  # 输出: tensor([4, 5, 6])
print(splits[2])  # 输出: tensor([7, 8])

18.torch.chunk()

  torch.chunk() 函数用于按指定维度将张量分割为多个块（chunks）。

torch.chunk(tensor, chunks, dim=0)
"""
参数说明：
tensor：输入张量。
chunks：要分割的块数。
dim：指定的维度，沿该维度进行分割。默认值为 0。
"""

import torch

# 创建一个张量
x = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8])

# 按维度 0 分割张量为两个块
chunks = torch.chunk(x, chunks=2, dim=0)

print(len(chunks))  # 输出: 2
print(chunks[0])  # 输出: tensor([1, 2, 3, 4])
print(chunks[1])  # 输出: tensor([5, 6, 7, 8])

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])

# 按维度 1 分割张量为三个块
chunks = torch.chunk(x, chunks=3, dim=1)

print(len(chunks))  # 输出: 3
print(chunks[0])  # 输出: tensor([[1],
                 #         [4]])
print(chunks[1])  # 输出: tensor([[2],
                 #         [5]])
print(chunks[2])  # 输出: tensor([[3],
                 #         [6]])
胡乱儿起个名
关注
  • 23
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch 实现张量tensor,图片,CPU,GPU,数组等的转换
09-18
在PyTorch中，张量（Tensor）是核心数据结构，用于存储和处理数值计算。以下将详细讲解如何创建和转换不同类型的张量，以及如何与CPU、GPU、数组及图片进行交互。 1. **创建张量**： 使用`torch.rand()`可以创建一...
一文读懂 Pytorch 中的 Tensor View 机制
m0_61899108的博客
03-01 1839
前言 用户在使用 Pytorch 的过程中，必然会接触到 view 这个概念，可能会有用户对它背后的实现原理感兴趣。Pytorch 通过 view 机制可以实现 tensor 之间的内存共享。而 view 机制可以避免显式的数据拷贝，因此能实现快速且内存高效的比如切片和 element-wise 等操作。全文约 ~4000字&多图预警。 什么是 View 搬运官网的例子 https://pytorch.org/docs/stable/tensor_view.html#tensor-vie.
tensor.view()
vivi_cin的博客
06-21 712
view用法
Tensor.view()的用法
m0_56896669的博客
04-07 704
Tensor.view()的用法
tensor中的view()、sequeeze()、resize()操作
fly_Xiaoma的博客
03-01 2万+
1. view() tensor.view()方法可以调整tensor的形状，但必须保证调整前后元素总数一致。view不会修改自身的数据，返回的新tensor与原tensor共享内存，即更改一个，另一个也随之改变。 在实际应用中，可能经常需要添加或者减少某一维度，这是sequeeze()和unsequeeze()这两个方法就派上了用场。 2. unsequeeze()和seque...
tensor.view()和torch.transpose()
weixin_47041940的博客
10-16 353
其中，c=a.view(-1,1)中的参数-1表示自适应维度，就是把a转换成1列的张量，至于有多少行，要根据a的形状自行计算。3.需要说明的是，有时，view方法和transpose方法能获得相同维度的张量，但它们是不相等的。1.view()函数用于对张量重塑形状。2.transpose()函数是转置操作。
pytorch中tensor张量数据类型的转化方式
09-18
在PyTorch中，张量（Tensor）是处理和计算数据的基本单元，它支持各种数学操作，而且可以方便地与其他数据结构如NumPy数组或Python列表进行交互。本篇文章将详细探讨PyTorch中张量数据类型的转化方法，这对于理解和...
PyTorch 基础：Tensor（张量）-谢TS的博客.pdf
07-17
在PyTorch中，Tensor（张量）是其核心数据结构，它被广泛用于构建和训练深度学习模型。PyTorch是由Facebook开发的开源深度学习框架，它支持CPU和GPU加速计算，使得处理大规模数据变得更加高效。Tensor可以视为一个...
pytorch 实现删除tensor中的指定行列
09-18
在PyTorch中，操作张量（Tensor）是深度学习模型构建的基础，而有时我们需要根据需求删除张量中的特定行或列。标题和描述中提到的问题是如何在PyTorch中实现这一功能。虽然PyTorch并没有提供直接删除指定行列的函数...
【Pytorch】torch.Tensor.view()使用
让算法融入生活，改变生活！
04-27 1589
官方文档：https://pytorch.org/docs/stable/generated/torch.Tensor.view.html?highlight=torch%20view#torch.Tensor.view 形式：Tensor.view(*shape) → Tensor 作用：返回一个新的张量，其数据与自张量相同，但形状不同。 说明：返回的张量共享相同的数据，并且必须具有相同数量的元素，但可能具有不同的大小。 当不清楚是否可以执行 view() 时，建议使用 reshape()，如果形状兼容则
【PyTorch】PyTroch中.view()函数的详细使用方法
开水的博客
08-08 8173
PyTorch中的.view()函数是一个用于改变张量形状的方法。它类似于NumPy中的.reshape()函数，可以通过重新排列张量的维度来改变其形状，而不改变张量的数据。在深度学习中，.view()函数常用于调整输入数据的形状以适应模型的输入要求，或者在网络层之间传递数据时进行形状的转换。.view()函数的语法如下，shape是一个整数元组，用于指定新的张量形状，新形状的元素个数必须与原形状的元素个数相同。函数返回一个具有指定形状的新张量，但与原始张量共享数据存储，因此它们指向相同的内存区域。
PyTorch：Tensor的常用基础函数
baidu_38797690的博客
12-24 3380
PyTorch中一些常见函数的用法和示例
详解Pytorch中的view函数
信小海
11-28 1万+
详解Pytorch中的view函数，通俗易懂！
【Pytorch】torch.Tensor.view()
海到无边天作岸 山登绝顶我为峰
09-02 1441
Hello！ଘ(੭ˊᵕˋ)੭昵称：海轰标签：程序猿｜C++选手｜学生简介：因C语言结识编程，随后转入计算机专业，获得过国家奖学金，有幸在竞赛中拿过一些国奖、省奖…已保研学习经验：扎实基础 + 多做笔记 + 多敲代码 + 多思考 + 学好英语！唯有努力💪本文仅记录自己感兴趣的内容文章仅作为个人学习笔记记录，记录从0到1的一个过程希望对您有一点点帮助，如有错误欢迎小伙伴指正。
PyTorch学习之 torch.Tensor.view 函数
最新发布
qq_46396470的博客
07-01 246
函数，用于高效地调整张量（tensor）的形状。可以重新组织张量的数据而不改变其内容，使我们能够更灵活地处理和操作数据。
PyTorch中view的用法
热门推荐
york1996的博客
08-22 26万+
相当于numpy中resize（）的功能，但是用法可能不太一样。 我的理解是： 把原先tensor中的数据按照行优先的顺序排成一个一维的数据（这里应该是因为要求地址是连续存储的），然后按照参数组合成其他维度的tensor。比如说是不管你原先的数据是[[[1,2,3],[4,5,6]]]还是[1,2,3,4,5,6]，因为它们排成一维向量都是6个元素，所以只要view后面的参数一致，得到的结果都...
torch.view() 详解
you 是 mine
01-05 4865
功能同reshape相似，但是 view() 只能操作 tensor，reshape() 可以操作 tensor 和 ndarray。view() 只能用在 contiguous（连续） 的变量上。如果在 view 之前用了 transpose, permute 等切片处理，需要用 contiguous() 来返回一个 contiguous copy。pytorch 中的 torch.reshape() 大致相当于 tensor.contiguous().view()
怎么将输入的数据转换为PyTorch张量（Tensor）格式
04-22
您可以通过使用PyTorch的torch.tensor()函数将输入数据转换为PyTorch张量格式。例如，如果您有一个名为input_data的numpy数组，则可以使用以下代码进行转换： import torch input_tensor = torch.tensor(input_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值