Pytorch中的一维张量

作者： Muhammad Asad Iqbal Khan 发布于 2023年4月8日分类： PyTorch 深度学习 4

PyTorch 是一个基于 Python 语言的开源深度学习框架。它允许您构建、训练和部署深度学习模型，提供了极大的灵活性和效率。

PyTorch 主要关注张量运算，而张量可以是数字、矩阵或多维数组。

在本教程中，我们将执行一些一维张量的基本运算，因为它们是复杂的数学对象，也是 PyTorch 库的重要组成部分。因此，在深入研究细节和更高级的概念之前，应该先掌握基础知识。

完成本教程后，您将

了解 PyTorch 中一维张量运算的基础知识。
了解张量类型和形状，并执行张量切片和索引操作。
能够对张量对象应用一些方法，例如均值、标准差、加法、乘法等。

通过我的《用PyTorch进行深度学习》一书来启动你的项目。它提供了包含可用代码的自学教程。

让我们开始吧。

Pytorch中的一维张量
图片来自 Jo Szczepanska。保留部分权利。

一维张量的类型和形状

首先，让我们导入本教程中将使用的一些库。

import torch

import numpy as np

import pandas as pd

如果您有其他编程语言的经验，理解张量最简单的方法是将其视为多维数组。因此，一维张量就是一个一维数组，或称为向量。要将整数列表转换为张量，请使用 torch.tensor() 构造函数。例如，我们将采用一个整数列表并将其转换为各种张量对象。

int_to_tensor = torch.tensor([10, 11, 12, 13])

print("转换后的张量对象类型： ", int_to_tensor.dtype)

print("转换后的张量对象类型： ", int_to_tensor.type())

1 2	转换后的张量对象类型： torch.int64 转换后的张量对象类型： torch.LongTensor

您也可以使用相同的 torch.tensor() 方法将浮点列表转换为浮点张量。

float_to_tensor = torch.tensor([10.0, 11.0, 12.0, 13.0])

print("转换后的张量对象类型： ", float_to_tensor.dtype)

print("转换后的张量对象类型： ", float_to_tensor.type())

1 2	转换后的张量对象类型： torch.float32 转换后的张量对象类型： torch.FloatTensor

请注意，需要转换为张量的列表元素必须具有相同的类型。此外，如果您想将列表转换为特定的张量类型，PyTorch 也允许您这样做。例如，以下代码行会将整数列表转换为浮点张量。

int_list_to_float_tensor = torch.FloatTensor([10, 11, 12, 13])

int_list_to_float_tensor.type()

print("转换后的张量类型： ", int_list_to_float_tensor.type())

1	转换后的张量类型： torch.FloatTensor

同样，size() 和 ndimension() 方法允许您查找张量对象的尺寸和维度。

1 2	print("int_list_to_float_tensor 的大小： ", int_list_to_float_tensor.size()) print("int_list_to_float_tensor 的维度： ",int_list_to_float_tensor.ndimension())

1 2	int_list_to_float_tensor 的大小： torch.Size([4]) int_list_to_float_tensor 的维度： 1

要重塑张量对象，可以使用 view() 方法。它接受 行 和 列 作为参数。例如，让我们使用此方法重塑 int_list_to_float_tensor。

reshaped_tensor = int_list_to_float_tensor.view(4, 1)

print("张量的原始大小： ", reshaped_tensor)

print("张量的新大小： ", reshaped_tensor)

张量的原始大小： tensor([[10.],

[11.],

[12.],

[13.]])

张量的新大小： tensor([[10.],

[11.],

[12.],

[13.]])

如您所见，view() 方法已将张量的大小更改为 torch.Size([4, 1])，具有 4 行和 1 列。

虽然在应用 view() 方法后张量对象中的元素数量应保持不变，但您可以使用 -1（例如 reshaped_tensor.view(-1, 1)）来重塑动态大小的张量。

将 NumPy 数组转换为张量

PyTorch 也允许您将 NumPy 数组转换为张量。您可以使用 torch.from_numpy 执行此操作。让我们采用一个 NumPy 数组并应用此操作。

numpy_arr = np.array([10.0, 11.0, 12.0, 13.0])

from_numpy_to_tensor = torch.from_numpy(numpy_arr)

print("张量的 dtype： ", from_numpy_to_tensor.dtype)

print("张量的 type： ", from_numpy_to_tensor.type())

1 2	张量的 dtype： torch.float64 张量的 type： torch.DoubleTensor

同样，您可以将张量对象转换回 NumPy 数组。让我们使用前面的示例来展示如何完成。

tensor_to_numpy = from_numpy_to_tensor.numpy()

print("从张量转换回 numpy： ", tensor_to_numpy)

print("转换后的 numpy 数组的 dtype： ", tensor_to_numpy.dtype)

1 2	从张量转换回 numpy： [10. 11. 12. 13.] 转换后的 numpy 数组的 dtype： float64

将 Pandas Series 转换为张量

您也可以将 pandas Series 转换为张量。为此，首先需要使用 NumPy 数组和 values() 函数存储 pandas Series。

pandas_series=pd.Series([1, 0.2, 3, 13.1])

store_with_numpy=torch.from_numpy(pandas_series.values)

print("存储在 numpy 数组中的张量： ", store_with_numpy)

print("存储张量的 dtype： ", store_with_numpy.dtype)

print("存储张量的 type： ", store_with_numpy.type())

存储在 numpy 数组中的张量： tensor([ 1.0000, 0.2000, 3.0000, 13.1000], dtype=torch.float64)

存储张量的 dtype： torch.float64

存储张量的 type： torch.DoubleTensor

此外，PyTorch 框架允许我们对张量进行许多操作，例如它的 item() 方法可以从张量中返回一个 Python 数字，而 tolist() 方法返回一个列表。

new_tensor=torch.tensor([10, 11, 12, 13])

print("第二个元素是",new_tensor[1].item())

tensor_to_list=new_tensor.tolist()

print('张量:', new_tensor,"\n列表:",tensor_to_list)

第二个元素是 11

张量: tensor([10, 11, 12, 13])

列表: [10, 11, 12, 13]

一维张量的索引和切片

PyTorch 中的索引和切片操作与 Python 中的几乎相同。因此，第一个索引始终从 0 开始，最后一个索引小于张量的总长度。使用方括号访问张量中的任何数字。

tensor_index = torch.tensor([0, 1, 2, 3])

print("检查索引 0 的值：",tensor_index[0])

print("检查索引 3 的值：",tensor_index[3])

1 2	检查索引 0 的值： tensor(0) 检查索引 3 的值： tensor(3)

就像 Python 中的列表一样，您也可以对张量中的值执行切片操作。此外，PyTorch 库还允许您更改张量中的某些值。

让我们举个例子来看看如何应用这些操作。

example_tensor = torch.tensor([50, 11, 22, 33, 44])

sclicing_tensor = example_tensor[1:4]

print("示例张量： ", example_tensor)

print("示例张量的子集：", sclicing_tensor)

1 2	示例张量： tensor([50, 11, 22, 33, 44]) 示例张量的子集： tensor([11, 22, 33])

现在，让我们更改 example_tensor 索引 3 处的值。

print("example_tensor 索引 3 的值：", example_tensor[3])

example_tensor[3] = 0

print("新张量：", example_tensor)

1 2	example_tensor 索引 3 的值： tensor(0) 新张量： tensor([50, 11, 22, 0, 44])

想开始使用PyTorch进行深度学习吗？

立即参加我的免费电子邮件速成课程（附示例代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

可应用于一维张量的一些函数

在本节中，我们将回顾一些可以应用于张量对象的统计方法。

最小和最大函数

这两个有用的方法用于查找张量中的最小值和最大值。它们的工作方式如下。

我们将使用 sample_tensor 作为示例来应用这些方法。

sample_tensor = torch.tensor([5, 4, 3, 2, 1])

min_value = sample_tensor.min()

max_value = sample_tensor.max()

print("检查张量中的最小值： ", min_value)

print("检查张量中的最大值： ", max_value)

1 2	检查张量中的最小值： tensor(1) 检查张量中的最大值： tensor(5)

均值和标准差

均值和标准差常用于对张量进行统计运算。您可以使用 PyTorch 中的 .mean() 和 .std() 函数来应用这两个指标。

让我们用一个例子来看看这两个指标是如何计算的。

mean_std_tensor = torch.tensor([-1.0, 2.0, 1, -2])

Mean = mean_std_tensor.mean()

print("mean_std_tensor 的均值： ", Mean)

std_dev = mean_std_tensor.std()

print("mean_std_tensor 的标准差： ", std_dev)

1 2	mean_std_tensor 的均值： tensor(0.) mean_std_tensor 的标准差： tensor(1.8257)

一维张量的简单加法和乘法运算

在 PyTorch 中，可以轻松地对张量应用加法和乘法运算。在本节中，我们将创建两个一维张量来演示如何使用这些运算。

a = torch.tensor([1, 1])

b = torch.tensor([2, 2])

add = a + b

multiply = a * b

print("两个张量的加法： ", add)

print("两个张量的乘法： ", multiply)

1 2	两个张量的加法： tensor([3, 3]) 两个张量的乘法： tensor([2, 2])

为了方便起见，上面所有的例子都已汇总，您可以一次性尝试。

import torch
import numpy as np
import pandas as pd

int_to_tensor = torch.tensor([10, 11, 12, 13])
print("Tensor object type after conversion: ", int_to_tensor.dtype)
print("Tensor object type after conversion: ", int_to_tensor.type())

float_to_tensor = torch.tensor([10.0, 11.0, 12.0, 13.0])
print("Tensor object type after conversion: ", float_to_tensor.dtype)
print("Tensor object type after conversion: ", float_to_tensor.type())

int_list_to_float_tensor = torch.FloatTensor([10, 11, 12, 13])
int_list_to_float_tensor.type()
print("Tensor  type after conversion: ", int_list_to_float_tensor.type())

print("Size of the int_list_to_float_tensor: ", int_list_to_float_tensor.size())
print("Dimensions of the int_list_to_float_tensor: ",int_list_to_float_tensor.ndimension())

reshaped_tensor = int_list_to_float_tensor.view(4, 1)
print("Original Size of the tensor: ", reshaped_tensor)
print("New size of the tensor: ", reshaped_tensor)

numpy_arr = np.array([10.0, 11.0, 12.0, 13.0])
from_numpy_to_tensor = torch.from_numpy(numpy_arr)
print("dtype of the tensor: ", from_numpy_to_tensor.dtype)
print("type of the tensor: ", from_numpy_to_tensor.type())

tensor_to_numpy = from_numpy_to_tensor.numpy()
print("back to numpy from tensor: ", tensor_to_numpy)
print("dtype of converted numpy array: ", tensor_to_numpy.dtype)

pandas_series=pd.Series([1, 0.2, 3, 13.1])
store_with_numpy=torch.from_numpy(pandas_series.values)
print("Stored tensor in numpy array: ", store_with_numpy)
print("dtype of stored tensor: ", store_with_numpy.dtype)
print("type of stored tensor: ", store_with_numpy.type())

new_tensor=torch.tensor([10, 11, 12, 13]) 
print("the second item is",new_tensor[1].item())
tensor_to_list=new_tensor.tolist()
print('tensor:', new_tensor,"\nlist:",tensor_to_list)

tensor_index = torch.tensor([0, 1, 2, 3])
print("Check value at index 0:",tensor_index[0])
print("Check value at index 3:",tensor_index[3])

example_tensor = torch.tensor([50, 11, 22, 33, 44])
sclicing_tensor = example_tensor[1:4]
print("example tensor : ", example_tensor)
print("subset of example tensor:", sclicing_tensor)

print("value at index 3 of example tensor:", example_tensor[3])
example_tensor[3] = 0
print("new tensor:", example_tensor)

sample_tensor = torch.tensor([5, 4, 3, 2, 1])
min_value = sample_tensor.min()
max_value = sample_tensor.max()
print("check minimum value in the tensor: ", min_value)
print("check maximum value in the tensor: ", max_value)

mean_std_tensor = torch.tensor([-1.0, 2.0, 1, -2])
Mean = mean_std_tensor.mean()
print("mean of mean_std_tensor: ", Mean)
std_dev = mean_std_tensor.std()
print("standard deviation of mean_std_tensor: ", std_dev)

a = torch.tensor([1, 1])
b = torch.tensor([2, 2])
add = a + b
multiply = a * b
print("addition of two tensors: ", add)
print("multiplication of two tensors: ", multiply)