PyTorch框架学习 — Tensor（张量）详解

Posted 2021-12-15 Roar冷颜

PyTorch框架学习 — Tensor（张量）详解

• 1 Tensor 的概念
• 2 Tensor 与 Variable
• 3 创建Tensor的方法
• • 3.1 直接创建Tensor
  • 3.2 根据数值创建 Tensor
  • 3.3 根据概率创建 Tensor
• 4 完整代码

1 Tensor 的概念

  Tensor 中文翻译为张量。张量的意思是一个多维数组，它是标量、向量、矩阵的高维扩展。标量可以称为 0 维张量，向量可以称为 1 维张量，矩阵可以称为 2 维张量，RGB 图像可以用 3 维张量表示。因此，我们可以把张量看作多维数组。

  在深度学习中，我们需要处理大量的数据，包括对数据的各种运算以及存储等。在PyTorch中，torch.Tensor是存储和变换数据的主要工具。如果大家了解Python的NumPy库的话，你会发现Tensor和NumPy的多维数组非常类似。然而，在PyTorch深度学习框架中，Tensor提供GPU计算和自动求梯度等更多功能，这些使Tensor更加适合深度学习。

2 Tensor 与 Variable

  在 PyTorch 0.4.0 之前，torch.autograd 包中存在 Variable 这种数据类型，主要是用于封装 Tensor，进行自动求导。Variable 主要包含下面几种属性。

  $\bullet$ data: 被包装的 Tensor。
  $\bullet$ grad: data 的梯度。
  $\bullet$ grad_fn: 创建 Tensor 所使用的 Function，是自动求导的关键，因为根据所记录的函数才能计算出导数。
  $\bullet$ requires_grad: 指示是否需要梯度，并不是所有的张量都需要计算梯度。
  $\bullet$ is_leaf: 指示是否为叶子节点（张量），叶子节点的概念在计算图中会用到，后面详细介绍。

  在 PyTorch 0.4.0 之后，Variable 并入了 Tensor。在之后版本的 Tensor 中，除了具有上面 Variable 的 5 个属性，还有另外 3 个属性。

  $\bullet$ dtype: 张量的数据类型，如 torch.FloatTensor，torch.cuda.FloatTensor
  $\bullet$ shape: 张量的形状。如 (64, 3, 224, 224)
  $\bullet$ device: 张量所在设备 (CPU/GPU)，GPU 是加速计算的关键

  Torch定义了10种CPU tensor类型和10种GPU tensor类型：

3 创建Tensor的方法

3.1 直接创建Tensor

torch.tensor()
torch.tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) → Tensor

  $\bullet$ data: 数据，可以是 list，NumPy ndarray，tuple，scalar 以及其他类型。
  $\bullet$ dtype: 返回张量的数据类型，默认与 data 的一致。
  $\bullet$ device: 所在设备，cuda/cpu。
  $\bullet$ requires_grad: 是否需要梯度。
  $\bullet$ pin_memory: 如果设置，返回的张量将分配到固定内存中。仅适用于CPU张量。

【代码】：

import torch
torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])

【结果】：

tensor([[0.1000, 1.2000],
        [2.2000, 3.1000],
        [4.9000, 5.2000]])

【代码】：

import torch
torch.tensor([0, 1])  # Type inference on data

【结果】：

tensor([0, 1])

【代码】：

# creates a torch.cuda.DoubleTensor
t = torch.tensor([[0.11111, 0.222222, 0.3333333]], dtype=torch.float64, device=torch.device('cuda:0'))
print(t)

【结果】：

tensor([[0.1111, 0.2222, 0.3333]], device='cuda:0', dtype=torch.float64)

【代码】：

# Create a scalar (zero-dimensional tensor)
t = torch.tensor(3.14159)
print(t)

【结果】：

tensor(3.1416)

【代码】：

# Create an empty tensor (of size (0,))
t = torch.tensor([])
print(t)

【结果】：

tensor([])

【代码】：

import torch
import numpy as np

arr = np.ones((3, 3))
print("arr的数据类型：", arr.dtype)

# 创建存放在 GPU 的数据
t = torch.tensor(arr, device='cuda')
# t = torch.tensor(arr)
print(t)

【结果】：

arr的数据类型： float64
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], device='cuda:0', dtype=torch.float64)

---

torch.from_numpy(ndarray)
torch.from_numpy(ndarray) → Tensor

【功能】：从 numpy 创建 tensor。利用这个方法创建的 tensor 和原来的 ndarray 共享内存，当修改其中一个数据，另外一个也会被改动。

【代码】：

import torch
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
t = torch.from_numpy(arr)

# 修改 array，tensor 也会被修改
print("修改arr: ")
arr[0, 0] = 0
print("numpy array: ", arr)
print("tensor: ", t)

# 修改 tensor，array 也会被修改
print("\\n修改tensor: ")
t[0, 0] = -1
print("numpy array: ", arr)
print("tensor: ", t)

【结果】：

修改arr: 
numpy array:  [[0 2 3]
 [4 5 6]]
tensor:  tensor([[0, 2, 3],
        [4, 5, 6]])

修改tensor: 
numpy array:  [[-1  2  3]
 [ 4  5  6]]
tensor:  tensor([[-1,  2,  3],
        [ 4,  5,  6]])

---

3.2 根据数值创建 Tensor

torch.zeros()
torch.zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

【功能】：根据 size 创建全 0 张量

  $\bullet$ size: 定义输出张量形状的整数序列。可以是数量可变的参数或集合，如列表或元组。
  $\bullet$ out: 输出的张量，如果指定了 out，那么torch.zeros()返回的张量和 out 指向的是同一个地址。
  $\bullet$ dtype: 返回张量的数据类型。
  $\bullet$ layout: 内存中布局形式，有 strided，sparse_coo 等。当是稀疏矩阵时，设置为 sparse_coo 可以减少内存占用。
  $\bullet$ device: 所在设备，cuda/cpu。
  $\bullet$ requires_grad: 是否需要梯度。

【代码】：

import torch

out_t = torch.tensor([1])   # 这里制定了out
t = torch.zeros((3, 3), out=out_t)
print("t = ", t)
print("out_t = ", out_t)
print("t的内存地址: ", id(t))
print("out_t的内存地址: ", id(out_t))
print(id(t) == id(out_t))

【结果】：

t =  tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
out_t =  tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
t的内存地址:  140530588876928
out_t的内存地址:  140530588876928
True

---

torch.zeros_like()
torch.zeros_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

【功能】：根据 input 形状创建全 0 张量

  $\bullet$ input: input的大小决定了输出张量的大小。
  $\bullet$ dtype: 返回张量的数据类型。
  $\bullet$ layout: 内存中布局形式，有 strided，sparse_coo 等。当是稀疏矩阵时，设置为 sparse_coo 可以减少内存占用。
  $\bullet$ device: 所在设备，cuda/cpu。
  $\bullet$ requires_grad: 是否需要梯度。
  $\bullet$ memory_format: 返回张量的所需内存格式。

【代码】：

import torch

input = torch.empty(2, 3)
t = torch.zeros_like(input)
print("t = ", t)

【结果】：

t =  tensor([[0., 0., 0.],
        [0., 0., 0.]])

  同理还有全 1 张量的创建方法：torch.ones()，torch.ones_like()。

---

torch.full()
torch.full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

【功能】：创建自定义数值的张量

  $\bullet$ size: 张量的形状，可以是list或tuple，如 (3,3)或[3,3]。
  $\bullet$ fill_value: 张量中每一个元素的值。

【代码】：

import torch

t = torch.full((3, 3), 2)
print("t = ", t)

【结果】：

t =  tensor([[2, 2, 2],
        [2, 2, 2],
        [2, 2, 2]])

  同理还有根据 input 形状创建自定义数值的张量：torch.full_like()。

---

torch.arange()
torch.arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

【功能】：创建等差的 1 维张量。注意区间为[start, end)。

  $\bullet$ start: 数列起始值，默认从0开始。
  $\bullet$ end: 数列结束值，开区间，取不到结束值。
  $\bullet$ step: 数列公差，默认为 1。

【代码】：

import torch

t1 = torch.arange(5)
print("t1 = ", t1)
t2 = torch.arange(1, 4)
print("t2 = ", t2)
t3 = torch.arange(1, 2.5, 0.5)
print("t3 = ", t3)

【结果】：

t1 =  tensor([0, 1, 2, 3, 4])
t2 =  tensor([1, 2, 3])
t3 =  tensor([1.0000, 1.5000, 2.0000])

---

torch.linspace()
torch.linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

【功能】：创建均分的 1 维张量。数值区间为 [start, end]

  $\bullet$ start(float): 数列起始值，注意不能缺省。
  $\bullet$ end(float): 数列结束值，闭区间，取得到结束值。
  $\bullet$ step(int): 数列长度 (元素个数)。

【代码】：

import torch

t1 = torch.linspace(3, 10, steps=5)
print("t1 = ", t1)
t2 = torch.linspace(-10, 10, steps=5)
print("t2 = ", t2)
t3 = torch.linspace(start=-10, end=10, steps=5)
print("t3 = ", t3)
t4 = torch.linspace(start=-10, end=10, steps=1)
print("t4 = ", t4)

【结果】：

t1 =  tensor([ 3.0000,  4.7500,  6.5000,  8.2500, 10.0000])
t2 =  tensor([-10.,  -5.,   0.,   5.,  10.])
t3 =  tensor([-10.,  -5.,   0.,   5.,  10.])
t4 =  tensor([-10.])

---

torch.logspace()
torch.logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

【功能】：创建对数均分的 1 维张量。数值区间为 [start, end]，底为 base。

  $\bullet$ start(float): 数列起始值。
  $\bullet$ end(float): 数列结束值。
  $\bullet$ steps(int): 数列长度 (元素个数)。
  $\bullet$ base(float, optional): 对数函数的底，默认为 10。

【代码】：

import torch

t1 = torch.logspace(-10, 10, steps=5)
print("t1 = ", t1)
t2 = torch.logspace(0.1, 1, steps=5)
print("t2 = ", t2)
t3 = torch.logspace(0.1, 1, steps=1)
print("t3 = ", t3)
t4 = torch.logspace(2, 2, steps=1, base=2)
print("t4 = ", t4)

【结果】：

t1 =  tensor([1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])
t2 =  tensor([ 1.2589,  2.1135,  3.5481,  5.9566, 10.0000])
t3 =  tensor([1.2589])
t4 =  tensor([4.])

---

torch.eye()
torch.eye(n, m=None, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

【功能】：创建单位对角矩阵( 2 维张量)，默认为方阵

  $\bullet$ n(int): 矩阵行数。通常只设置 n，为方阵。
  $\bullet$ m(int): 矩阵列数。

【代码】：

import torch

t1 = torch.eye(3)
print("t1 = ", t1)
t2 = torch.eye(2, 3)
print("t2 = ", t2)
t3 = torch.eye(3, 2)
print("t3 = ", t3)

【结果】：

t1 =  tensor([[1., 0., 0.],
        [0., 1., Pytorch深度学习基础之Tensor

 Pytorch深度学习实战3-2：什么是张量？Tensor的创建与索引
 pytorch学习笔记1-创建tensor（张量，多维数组）
 Pytorch 理解张量Tensor
 深度学习-Pytorch张量tensor详解（线性回归实战）
 Pytorch深度学习实战3-3：张量Tensor的分块变形排序极值与in-place操作