当前位置：首页 > news >正文

一小时速通Pytorch之Tensor张量（一）

news 2025/11/11 11:33:56

Tensor 张量笔记

通过官网学习总结而得，加上一些个人的理解。
Tensot是原文名称，中文常用张量一词进行描述，在本文中两者等同。

张量概述

张量类似与数组和矩阵是一种多维的数据结果，类比于Python的Numpy里面的数组这种数据结构，与Numpy数组不同的是，Tensor可以用GPU等进行加速运输。
Pytorch使用张量输入数据、输出数据和模型的参数

初始化`张量`

法一：从数据构造张量

例子：

import torch
data = [[1,2],[3,4]]
x_data = torch.tensor(data)

法二：从`Numpy`进行转换

import torch
data = [[1,2],[3,4]]
np_array = np.array(data)
x_np = torch.from_numpy(np_array)

法三：从其他的张量赋值

默认情况下赋值操作会保留原有张量的形状和数据类型

import torch
data = [[1,2],[3,4]]
x_data = torch.tensor(data)
x_ones = torch.ones_like(x_data) # 创建一个和x_data形状一样的全为1的张量
print(f"Ones Tensor: \n {x_ones} \n")x_rand = torch.rand_like(x_data, dtype=torch.float) # 创建一个形状和x_data一样并且数据内容随机，数据的类型为“torch.float"的张量
print(f"Random Tensor: \n {x_rand} \n")

输出的结果如下（Random Tensor具有随机性，数值会不一样）

Ones Tensor:tensor([[1, 1],[1, 1]])Random Tensor:tensor([[0.0374, 0.4275],[0.5612, 0.9651]])

法四：采用随机值或者固定值创建张量

**shape**这个值是张量维度的一个元组，这个元组本身也是多维的。在下面的示例函数中它用来决定输出张量的维度（形状）

import torch
shape = (2, 3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")

示例输出如下：

Random Tensor:tensor([[0.4494, 0.7683, 0.4767],[0.3432, 0.8501, 0.6761]])Ones Tensor:tensor([[1., 1., 1.],[1., 1., 1.]])Zeros Tensor:tensor([[0., 0., 0.],[0., 0., 0.]])

张量的属性

shape描述张量的形状
dtype描述张量的数据类型
device描述张量的存储位置，一般理解是用CPU还是GPU来进行处理

对应的访问函数示例如下：

import torch
tensor = torch.rand(3, 4)print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

示例输出如下：

Shape of tensor: torch.Size([3, 4])
Datatype of tensor: torch.float32
Device tensor is stored on: cpu

张量的基础操作

张量的基础操作有很多，包括常规的操作和一些基本的数学运算，pytorch都进行了一些基本的优化，这里给出[官方的API接口](torch — PyTorch 2.9 documentation)

数据搬运

对于可以使用CUDA的设备（一般是NVIDA的显卡才支持），可以使用以下步骤把张量搬运到CUDA上

import torch
tensor = torch.rand(3, 4)
if torch.cuda.is_available():tensor = tensor.to('cuda')print(f"Device tensor is stored on: {tensor.device}")

示例输出：

Device tensor is stored on: cuda:0

索引和切片

类比与Numpy和python原生的索引和切片的操作

import torch
tensor = torch.ones(3, 4)
tensor[:,1] = 0 #把tensor的第二维，即长度为4的这个维度的第二个元素全部置为0
print(tensor)

示例输出如下：

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

拼接

法一：使用cat函数 `torch.cat(tensors,dim=0,*,out=None)->Tensor`

函数作用

按照tesnors中给定的多个张量按照dim中指定的维度进行拼接。注意给定的张量形状除了要连接的那个维度以外，其他维度必须一样大小（除非是大小是(0,)的一维空张量
此外，cat函数可以看作是torch.split()和torch.chunk()这个函数的逆操作

参数说明

tensors一组以张量为元素的序列化组合，可以是列表，集合等。除了空张量以外，其他的张量必须具有一样的形状（除了待拼接的那个维度）
dim维度（整形）。默认是0维，指定拼接操作的维度
out输出值（可选参数）数据类型是张量。可以把输出的张量放在此处

简单使用示例：

import torchx = torch.randn(2, 3)
print(x)
print('-' * 30)
a = torch.cat((x, x, x), 0)
print(a)
print('-' * 30)
a = torch.cat((x, x, x), 1)
print(a)
print('-' * 30)

示例输出：

tensor([[ 0.4675,  0.5847, -0.3645],[-0.2279, -0.1246, -0.7916]])
------------------------------
tensor([[ 0.4675,  0.5847, -0.3645],[-0.2279, -0.1246, -0.7916],[ 0.4675,  0.5847, -0.3645],[-0.2279, -0.1246, -0.7916],[ 0.4675,  0.5847, -0.3645],[-0.2279, -0.1246, -0.7916]])
------------------------------
tensor([[ 0.4675,  0.5847, -0.3645,  0.4675,  0.5847, -0.3645,  0.4675,  0.5847,-0.3645],[-0.2279, -0.1246, -0.7916, -0.2279, -0.1246, -0.7916, -0.2279, -0.1246,-0.7916]])
------------------------------

法二：使用stack函数 `torch.stack(tensors,dim=0,*,out=None)->Tensor`

函数作用

沿指定维度拼接张量
与cat函数不同的是，stack函数要求输入的全部张量形状完全一致

参数说明

tensors一组以张量为元素的序列化组合，可以是列表，集合等。
dim维度（整形，可选）。要拼接的维度。必须介于0和连接张量的维数之间（包括0和维数）。默认值：0
out 类型：张量。在内存紧张时可用作输出张量。

简单使用示例：

import torchx = torch.randn(2, 3)
print(x)
print('-' * 30)
a = torch.stack((x, x, x), 0)
print(a)
print('-' * 30)
a = torch.stack((x, x, x), 1)
print(a)
print('-' * 30)

示例输出：

tensor([[-0.5955,  2.1726,  1.1533],[-0.5504,  2.5954, -0.1234]])
------------------------------
tensor([[[-0.5955,  2.1726,  1.1533],[-0.5504,  2.5954, -0.1234]],[[-0.5955,  2.1726,  1.1533],[-0.5504,  2.5954, -0.1234]],[[-0.5955,  2.1726,  1.1533],[-0.5504,  2.5954, -0.1234]]])
------------------------------
tensor([[[-0.5955,  2.1726,  1.1533],[-0.5955,  2.1726,  1.1533],[-0.5955,  2.1726,  1.1533]],[[-0.5504,  2.5954, -0.1234],[-0.5504,  2.5954, -0.1234],[-0.5504,  2.5954, -0.1234]]])
------------------------------

`cat`和`stack`函数的异同

相同之处：两者都是把张量进行拼接
不同之处：cat的拼接不会改变原有张量的维数，stack会增加多一维。因此两者要求的张量输入也有区别。

逐元素相乘运算

乘法运算有两种方法完全等价

法一采用mul方法
法二直接使用乘法运算符*

简单使用示例：

import torchx = torch.randn(2, 3)
print(x)
print("使用mul方法", x.mul(x), sep='\n')
print("使用乘法运算符", x * x, sep='\n')

示例输出：

tensor([[-2.3343, -1.2076, -0.1143],[ 0.3928,  0.0286,  0.5086]])
使用mul方法
tensor([[5.4489e+00, 1.4582e+00, 1.3056e-02],[1.5428e-01, 8.1787e-04, 2.5872e-01]])
使用乘法运算符
tensor([[5.4489e+00, 1.4582e+00, 1.3056e-02],[1.5428e-01, 8.1787e-04, 2.5872e-01]])

矩阵相乘运算

法一，调用matmul方法
法二，采用@运算符

简单使用示例，下面代码的x.T是张量x对应的转置矩阵

import torchx = torch.randn(2, 3)
print(x)
print("使用matmul方法", x.matmul(x.T), sep='\n')
print("使用矩阵乘法运算符", x @ x.T, sep='\n')

示例输出：

ensor([[-1.1979,  1.0094,  0.4069],[-0.1973,  2.4104, -0.8201]])
使用matmul方法
tensor([[2.6194, 2.3357],[2.3357, 6.5216]])
使用矩阵乘法运算符
tensor([[2.6194, 2.3357],[2.3357, 6.5216]])

注意事项

任何带有**“_”**后缀的运算符都是在原有张量基础上直接修改。例如：x.copy_(y),x.t_()都会改变x的值
虽然理论上可以节省内存但是会丢失梯度数据，在训练阶段不建议使用

简单使用示例：

import torchx = torch.randn(2, 3)
print(x)
print("原地修改x", x.add_(5), sep='\n')

示例输出：

tensor([[ 2.8642,  0.6144,  0.2932],[-1.5987,  0.2407, -1.2078]])
原地修改x
tensor([[7.8642, 5.6144, 5.2932],[3.4013, 5.2407, 3.7922]])

张量与`Numpy`的联系

运行在**CPU**上的张量与Numpy底层上共用同一块内存区域，修改其中一个另外一个也会被同步修改

简单使用示例：

import torch
import numpy as npprint("从Tensor构造Numpy：")
x = torch.ones(2, 3)
print("Tensor形式：", x, sep="\n")
n = x.numpy()
print("Numpy形式：", n, sep='\n')
print("修改Tensor后的Tensor:{}\nNumpy:{}".format(x.add_(10), n), sep='\n')
print('-' * 30)print("从Numpy构造Tensor：")
n1 = np.ones((3, 2))
print("Numpy形式：", n1, sep='\n')
x1 = torch.from_numpy(n1)
print("Tensor形式：", x1, sep='\n')
print("修改Numpy后的Numpy:{}\nTensor:{}".format(np.add(n1, 5, out=n1), x1), sep='\n')

示例输出：

从Tensor构造Numpy：
Tensor形式：
tensor([[1., 1., 1.],[1., 1., 1.]])
Numpy形式：
[[1. 1. 1.][1. 1. 1.]]
修改Tensor后的Tensor:tensor([[11., 11., 11.],[11., 11., 11.]])
Numpy:[[11. 11. 11.][11. 11. 11.]]
------------------------------
从Numpy构造Tensor：
Numpy形式：
[[1. 1.][1. 1.][1. 1.]]
Tensor形式：
tensor([[1., 1.],[1., 1.],[1., 1.]], dtype=torch.float64)
修改Numpy后的Numpy:[[6. 6.][6. 6.][6. 6.]]
Tensor:tensor([[6., 6.],[6., 6.],[6., 6.]], dtype=torch.float64)

查看全文

http://www.dtcms.com/a/593998.html