在 Pytorch 中创建张量

所有的深度学习都是对张量的计算，张量是一个矩阵的推广，可以在超过 2 个维度上建立索引。可以使用 torch.tensor()函数从Python列表创建张量。

tensor() 方法：

要使用 Pytorch 创建张量，我们可以简单地使用 tensor() 方法：

句法：

torch.tensor(Data)

例子：

Python3

import torch
  
V_data = [1, 2, 3, 4]
V = torch.tensor(V_data)
print(V)

输出：

tensor([1, 2, 3, 4])

要创建矩阵，我们可以使用：

蟒蛇3

import torch
  
M_data = [[1., 2., 3.], [4, 5, 6]]
M = torch.tensor(M_data)
print(M)

输出：

tensor([[1., 2., 3.],
        [4., 5., 6.]])

要创建 3D 张量，您可以使用以下代码模板：

蟒蛇3

import torch
  
T_data = [[[1., 2.], [3., 4.]],
          [[5., 6.], [7., 8.]]]
T = torch.tensor(T_data)
print(T)

输出：

tensor([[[1., 2.],
         [3., 4.]],

        [[5., 6.],
         [7., 8.]]])

但是，如果我们运行以下代码：

蟒蛇3

import torch
  
x = torch.tensor([[1, 2], [3, 4, 5]])
print(x)

输出：

ValueError: expected sequence of length 2 at dim 1 (got 3)

发生这种情况是因为张量基本上是矩阵，并且它们不能在每个维度上具有不相等数量的元素。

randint() 方法：

randint()方法返回一个张量，其中填充了随机整数，这些整数在给定形状的低（含）和高（不包括）之间均匀生成。形状由用户给出，可以是元组或具有非负成员的列表。 low 的默认值为 0。当只传递一个 int 参数时，默认情况下，low 获取值 0，high 获取传递的值。像 zeros() 一样，形状的空元组或列表会创建一个零维张量。

Syntax: torch.randint(,,)

例子：

蟒蛇3

import torch
  
randint_tensor = torch.randint(5, (3,3))
print(randint_tensor)

输出：

tensor([[3, 2, 3],
        [4, 4, 0],
        [3, 3, 4]])

complex() 方法：

complex()方法接受两个参数（ real和imag ）并返回一个复张量，其实部等于 real 且其虚部等于imag ，其中 real 和imag都是具有相同数据类型和相同形状的张量。

Syntax: torch.complex(,)

例子：

蟒蛇3

import torch
  
real = torch.rand(2, 2)
print(real)
imag = torch.rand(2, 2)
print(imag)
complex_tensor = torch.complex(real, imag)
print(complex_tensor)

输出：

tensor([[0.7655, 0.7181],
        [0.8479, 0.0369]])
tensor([[0.5604, 0.0012],
        [0.6316, 0.6574]])
tensor([[0.7655+0.5604j, 0.7181+0.0012j],
        [0.8479+0.6316j, 0.0369+0.6574j]])

眼睛（）方法：

对于给定的形状 (n,m)， eye()方法返回一个二维张量，对角线上为 1，其他地方为 0（恒等矩阵），其中 n 和 m 为非负。行数由 n 给出，列数由 m 给出。 m 的默认值是 n 的值，当只传递 n 时，它会以单位矩阵的形式创建张量。

Syntax: torch.eye()

例子：

蟒蛇3

import torch
  
n = m = 3
eye_tensor = torch.eye(n, m)
print(eye_tensor)

输出：

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

zeros() 方法：

当您需要一个所有元素都为零、具有指定形状的张量时，可以使用此方法。形状可以作为元组或列表或两者都不是。如果您传递一个空元组或一个空列表，则 zeros() 方法返回一个形状（维度）为 0 的张量，其唯一元素为 0，其数据类型为浮点数。负数或浮点数不能作为形状传递。

句法：

torch.zero(D1,D2)

Here,
D1: It represents the horizontal dimension of the tensor.
D2: It represents the vertical dimension of the tensor.

例子：

蟒蛇3

import torch
  
zeros_tensor = torch.zeros(3,2)
print(zeros_tensor)

输出：

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

rand() 方法：

rand()方法返回一个张量，该张量填充随机数，这些随机数来自给定形状的区间 0（含）到 1（不含）的均匀分布。形状由用户给出，可以作为元组或列表或两者都不是。类似于 zeros() 和 ones() 传递空元组或列表创建零维的标量张量。像 zeros() 一样，shape 参数只接受一个元组或一个包含非负成员的列表。空元组或列表创建一个零维张量。

rand() 方法可用于在神经网络中设置随机权重和偏差。

Syntax: torch.rand()

蟒蛇3

import torch
  
rand_tensor = torch.rand(3, 3)
print(rand_tensor)

输出：

tensor([[0.6307, 0.7281, 0.0130],
        [0.7359, 0.0241, 0.2845],
        [0.2154, 0.3773, 0.6545]])

ones() 方法：

与 zeros() 类似，ones() 返回一个张量，其中所有元素都为 1，具有指定大小（形状）。

Syntax: torch.tensor()

例子：

蟒蛇3

import torch
  
ones_tensor = torch.ones((4,4,4))
print(ones_tensor)

输出：

tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

arange() 方法：

arange()方法用于获取一维张量（行矩阵），元素从开始（包含）到结束（不包含），具有公共差异步长（start 的默认值为 0，step 的默认值为 1 ）。张量的元素可以说是算术级数，给定的步长为公分。所有三个参数 start、end 和 step 都可以是正数、负数或浮点数。

Syntax: torch.arange(,,)

例子：

蟒蛇3

import torch
  
arange_tensor = torch.arange(2, 20, 2)
print(arange_tensor)

输出：

tensor([ 2,  4,  6,  8, 10, 12, 14, 16, 18])

full() 方法：

当我们需要一个由 shape 参数给出的形状的张量时使用full()方法，它的所有元素都等于用户给定的填充值。同样，传递一个空元组或列表会创建一个零维的标量张量。使用 full 时，必须将形状作为元组或列表（可以为空），否则会引发错误。此外，形状列表的成员不能为负数或浮动。

Syntax: torch.full(,)

例子：

蟒蛇3

import torch
  
full_tensor = torch.full((3,2), 3)
print(full_tensor)

输出：

tensor([[3, 3],
        [3, 3],
        [3, 3]])

linspace() 方法：

linspace()方法也返回一维张量（行矩阵），元素从开始（包括）到结束（包括）。然而，与arange()不同，我们在一维张量中传递我们需要的元素数量，而不是传递步长（如上所示）。 Pytorch 自动计算给定开始和结束值的步骤。元素个数只能是非负整数是可以理解的。

Syntax: torch.linspace( , , )

例子：

蟒蛇3

import torch
  
linspace_tensor = torch.linspace(1, 7.75, 4)
print(linspace_tensor)

输出：

tensor([ 1.0000,  3.2500,  5.5000,  7.7500])

与arange()不同，在linspace() 中，我们可以有一个大于 end 的开始，因为公差是自动计算的。

Tensor([[0.6307, 0.7281, 0.0130],
        [0.7359, 0.0241, 0.2845],
        [0.2154, 0.3773, 0.6545]])

这就是我们如何在 PyTorch 中创建张量。