Pytorch 中的张量

Pytorch 张量与 NumPy 数组基本相同。这意味着它对深度学习或计算图或梯度一无所知，只是一个用于任意数值计算的通用 n 维数组。然而，NumPy 数组和 PyTorch Tensor 之间的最大区别在于 PyTorch Tensor 可以在 CPU 或 GPU 上运行。要在 GPU 上运行操作，只需使用以下命令将 Tensor 转换为 cuda 数据类型：

device = torch.device(“cpu”)

# to create random input and output data ,

# and H is hidden dimension; D_out is output dimension.

N, D_in, H, D_out = 32, 100, 10, 2 

x = torch.randn(N, D_in, device=device, dtype=torch.float)    #where x is a tensor 

在上面的例子中，x 可以被认为是一个随机特征张量作为模型的输入。我们将在本文中看到如何在张量上创建张量、不同的属性和操作。

如何创建张量？

您可以使用一些简单的代码行创建张量，如下所示。

Python3

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

输出：

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

您还可以创建具有给定维度的随机数据张量，例如：

蟒蛇3

import torch
  
x = torch.randn((3, 4, 5))
print(x)

输出 ：

tensor([[[ 0.8332, -0.2102,  0.0213,  0.4375, -0.9506],
         [ 0.0877, -1.5845, -0.1520,  0.3944, -0.7282],
         [-0.6923,  0.0332, -0.4628, -0.9127, -1.4349],
         [-0.3641, -0.5880, -0.5963, -1.4126,  0.5308]],

        [[ 0.4492, -1.2030,  2.5985,  0.8966,  0.4876],
         [ 0.5083,  1.4515,  0.6496,  0.3407,  0.0093],
         [ 0.1237,  0.3783, -0.7969,  1.4019,  0.0633],
         [ 0.4399,  0.3827,  1.2231, -0.0674, -1.0158]],

        [[-0.2490, -0.5475,  0.6201, -2.2092,  0.8405],
         [ 0.1684, -1.0118,  0.7414, -3.3518, -0.3209],
         [ 0.6543,  0.1956, -0.2954,  0.1055,  1.6523],
         [-0.9872, -2.0118, -1.6609,  1.4072,  0.0632]]])

您还可以使用以下函数创建张量：

• torch.zeros()：创建一个包含所有元素的新张量，初始化为零。

蟒蛇3

import torch
  
z= torch.zeros([3,3], dtype=torch.int32)
print(z)

输出：

tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]], dtype=torch.int32)

• torch.ones() ：创建一个包含所有元素的新张量，初始化为一个。

蟒蛇3

import torch
  
z = torch.ones([3,3])
print(z)

输出：

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

• torch.full() 和 torch.full_like()：这些函数返回所需大小的张量，并填充了所需的 fill_value。 torch.full() 的完整原型是：

Syntax: torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

而torch.full_like()是：

Syntax: torch.full_like(input, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format)

蟒蛇3

import torch
  
# example of torch.full()
newTensor= torch.full((4, 3), 3.14,dtype= torch.float32)
print(newTensor)

输出：

tensor([[3.1400, 3.1400, 3.1400],
        [3.1400, 3.1400, 3.1400],
        [3.1400, 3.1400, 3.1400],
        [3.1400, 3.1400, 3.1400]])

蟒蛇3

import torch
  
# Example for torch.full_like()
x = torch.full_like(newTensor,3.24, dtype=None )
print(x)

输出：

tensor([[3.2400, 3.2400, 3.2400],
        [3.2400, 3.2400, 3.2400],
        [3.2400, 3.2400, 3.2400],
        [3.2400, 3.2400, 3.2400]])

这里一个新的张量返回，以相同的尺寸和D型细胞作为newTensor其前面从上面所示的例子中torch.full方法返回。

张量属性：

每个张量（ torch.Tensor ）都有一个torch.dtype、torch.device和torch.layout属性。

• torch.dtype ： torch.dtype是表示 torch.Tensor数据类型的对象。 PyTorch 有十二种不同的数据类型。
• torch.device ： torch.device是一个对象，表示在其上分配或将分配torch.Tensor 的设备。 torch.device包含设备类型（“cpu”或“cuda”）和设备类型的可选设备序号。

例子：

蟒蛇3

torch.device('cuda:0')

输出 ：

device(type='cuda', index=0)

如果设备序号不存在，则该对象将始终表示设备类型的当前设备，即使在调用 torch.cuda.set_device() 之后也是如此。

• torch.layout： torch.layout是一个对象，表示 torch.Tensor 的内存布局。目前，torch 支持两种类型的内存布局。

1.torch.strided：代表密集Tensors，是最常用的内存布局。每个跨步张量都有一个关联的torch.Storage，它保存着它的数据。这些张量提供了一个多维、跨步的存储视图。数组的步长（也称为增量、间距或步长）是内存中连续数组元素开头之间的位置数，以字节或数组元素大小的单位度量。步幅不能小于元素大小，但可以更大，表示元素之间有额外的空间。所以基本上这里的 Strides 是一个整数列表：第 k 步表示从 Tensor 的第 k 维中的一个元素到下一个元素所需的内存中的跳跃。这个概念使得高效地执行许多张量操作成为可能。

让我们运行一些示例代码段：

蟒蛇3

x = torch.Tensor([[1, 2, 3, 4], [5, 7, 8, 9]])
x.stride()

输出：

(4,1)

2.torch.sparse_coo_tensor：用于在稀疏坐标列表中存储数组。在 COO 格式中，指定的元素存储为元素索引和相应值的元组。

蟒蛇3

i = [[0, 1, 1],
     [2, 0, 2]]
  
v =  [3, 4, 5]
s = torch.sparse_coo_tensor(i, v, (2, 3))
Print(s)

输出：

tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3, 4, 5]),
       size=(2, 3), nnz=3, layout=torch.sparse_coo)

张量操作：

您可以添加两个张量，如矩阵加法。

蟒蛇3

x = torch.tensor([1., 2., 3.])
y = torch.tensor([4., 5., 6.])
z = x + y
print(z)

输出：

tensor([5., 7., 9.])

• torch.cat() ：连接张量列表

蟒蛇3

x_1 = torch.randn(2, 5)
y_1 = torch.randn(3, 5)
z_1 = torch.cat([x_1, y_1])
print(z_1)

输出：

tensor([[ 0.5761,  0.6781,  0.1621,  0.4986,  0.3410],
        [-0.8428,  0.2510, -0.2668, -1.1475,  0.5675],
        [-0.2797, -0.0699,  2.8936,  1.8260,  2.1227],
        [ 1.3765, -0.0939, -0.3774, -0.3834,  0.0682],
        [ 2.3666,  0.0904,  0.7956,  1.2281,  0.5561]])

要连接列，您可以执行以下操作。

蟒蛇3

x_2 = torch.randn(2, 3)
y_2 = torch.randn(2, 5)
  
# second argument specifies which axis to concat along
z_2 = torch.cat([x_2, y_2], 1)
print(z_2)

输出：

tensor([[ 0.5818,  0.7047,  0.1581,  1.8658,  0.5953, -0.9453, -0.6395, -0.7106],
        [ 1.2197,  0.8110, -1.6072,  0.1463,  0.4895, -0.8226, -0.1889,  0.2668]])

• view()：您可以使用 .view() 方法重塑张量，如下所示。

蟒蛇3

x = torch.randn(2, 3, 4)
print(x)
  
# reshape to 2 rows, 12 columns
print(x.view(2, 12))

输出：

tensor([[[ 0.4321,  0.2414, -0.4776,  1.6408],
         [ 0.9085,  0.9195,  0.1321,  1.1891],
         [-0.9267, -0.1384,  0.0115, -0.4731]],

        [[ 0.7256,  0.6990, -1.7374,  0.6053],
         [ 0.0224, -1.2108,  0.1974,  0.0655],
         [-0.6182, -0.0797,  0.2603, -1.3280]]])
tensor([[ 0.4321,  0.2414, -0.4776,  1.6408,  0.9085,  0.9195,  0.1321,  1.1891,
         -0.9267, -0.1384,  0.0115, -0.4731],
        [ 0.7256,  0.6990, -1.7374,  0.6053,  0.0224, -1.2108,  0.1974,  0.0655,
         -0.6182, -0.0797,  0.2603, -1.3280]])

• torch.argmax()：返回输入张量中所有元素的最大值的索引。

蟒蛇3

x = torch.randn(3,3)
print((x, torch.argmax(x)))

输出：

(tensor([[ 1.9610, -0.7683, -2.6080],
        [-0.3659, -0.1731,  0.1061],
        [ 0.8582,  0.6420, -0.2380]]), tensor(0))

• torch.argmin()：与 argmax() 类似，它返回输入张量中所有元素的最小值。

蟒蛇3

x = torch.randn(3,3)
print((x, torch.argmin(x)))

输出：

(tensor([[ 0.9838, -1.2761,  0.2257],
        [-0.4754,  1.2677,  1.1973],
        [-1.2298, -0.5710, -1.3635]]), tensor(8))