【PyTorch入门】 张量的介绍及常用函数和数据基础【一】

Hello 今天给大家分享torch的一些基础内容，让大家对pytorch有一些基本的了解。

在人工智能时代，机器学习技术在不断更新，深度学习更是机器学习领域中的一个全新的研究领域和热点方向，深度学习不仅推动了机器学习，更是促进了人工智能时代技术的更迭，已经被成功运用在了语音识别，图像分类识别等领域，有着巨大的发展价值。

近年来，pytorch更是备受喜爱，使用pytorch进行深度学习开发和研究已经成为主流。

PyTorch 中的底层框架：张量 (Tensor)

在 PyTorch 中，张量 (Tensor) 是其核心的数据结构之一，几乎所有操作都与张量密切相关。PyTorch 的张量提供了一个多维数组的基础，类似于 NumPy 数组，但具有更多的功能，特别是在深度学习中与 GPU 计算的高效配合。

1. 张量 (Tensor) 的定义

在 PyTorch 中，张量（Tensor）是一个多维矩阵的类，可以存储多维的数据，如标量、向量、矩阵或更高维度的数组。张量本质上是一个类（torch.Tensor），与 NumPy 中的 ndarray 相似，但是它支持 GPU 加速。

import torch

# 创建一个 2D 张量（矩阵）
tensor_2d = torch.tensor([[1, 2], [3, 4]])

print(tensor_2d)

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

2. 张量的基本属性

每个张量都有几个关键的属性：

形状 (Shape)：张量的维度（即每一维的大小）。可以通过 .shape 或 .size() 获取。

数据类型 (dtype)：张量中数据的类型，如浮点型（torch.float32）、整型（torch.int64）等。可以通过 .dtype 获取。

设备 (Device)：张量存储的位置，可以是 CPU 或 GPU。通过 .device 可以查看当前设备。

# 示例
tensor = torch.tensor([[1, 2], [3, 4]])

print("Shape:", tensor.shape)  # 输出张量的形状
print("dtype:", tensor.dtype)  # 输出张量的数据类型
print("device:", tensor.device)  # 输出张量所在设备

Shape: torch.Size([2, 2])
dtype: torch.int64
device: cpu

3. 张量的初始化

PyTorch 提供了多种方式来初始化张量，常用的有：

从数据创建张量：可以直接使用 torch.tensor() 来从 Python 列表或 NumPy 数组创建张量。

tensor_from_list = torch.tensor([1, 2, 3])  # 一维张量

常见初始化函数：

torch.zeros()：创建一个值为零的张量。

torch.ones()：创建一个值为一的张量。

torch.randn()：创建一个遵循标准正态分布的张量。

torch.arange()：创建一个有序的张量。

torch.linspace()：创建一个均匀分布的张量。

zeros_tensor = torch.zeros(3, 3)  # 3x3 张量，所有元素为0
ones_tensor = torch.ones(2, 2)  # 2x2 张量，所有元素为1
random_tensor = torch.randn(2, 3)  # 2x3 张量，符合标准正态分布
zeros_tensor, ones_tensor, random_tensor

(tensor([[0., 0., 0.],
         [0., 0., 0.],
         [0., 0., 0.]]),
 tensor([[1., 1.],
         [1., 1.]]),
 tensor([[ 0.3930,  0.4327, -1.3627],
         [ 1.3564,  0.6688, -0.7077]]))

4. 张量的类型转换：

PyTorch 允许通过 .to() 或 .type() 方法来转换张量的数据类型。

tensor = torch.tensor([1, 2, 3], dtype=torch.float32)
tensor = tensor.to(torch.int64)  # 转换为整数类型

5.张量的设备

PyTorch 张量可以在 CPU 或 GPU 上运行。使用 .to() 方法可以将张量转移到 GPU（前提是你的系统有支持的 GPU）。

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
tensor = tensor.to(device)

6. 张量的操作

PyTorch 提供了丰富的张量操作，包括数学运算、矩阵操作、线性代数操作等。这些操作通常是基于 NumPy 数组的操作，同时也支持 GPU 加速。

加减

tensor1 = torch.tensor([1, 2])
tensor2 = torch.tensor([3, 4])
sum_tensor = tensor1 + tensor2  # 张量加法
diff_tensor = tensor1 - tensor2  # 张量减法

元素级乘除

product_tensor = tensor1 * tensor2  # 乘法
div_tensor = tensor1 / tensor2  # 除法

矩阵乘法

使用torch.matmul(mat1, mat2)

mat1 = torch.randn(2, 3)
mat2 = torch.randn(3, 4)
result = torch.matmul(mat1, mat2)  # 矩阵乘法

转置和改变形状

tensor = torch.randn(2, 3)
transposed_tensor = tensor.T  # 转置
reshaped_tensor = tensor.view(3, 2)  # 改变形状

聚合操作：

PyTorch 提供了对张量的求和、求平均、最大值、最小值等操作。

sum_val = tensor.sum()  # 求和
mean_val = tensor.mean()  # 求均值
max_val = tensor.max()  # 最大值

7. 自动求导 (Autograd)

PyTorch 具有自动求导机制，能够计算张量的梯度。这是深度学习中反向传播的核心。通过 requires_grad=True 来启用张量的梯度计算。

x = torch.tensor([2.0], requires_grad=True)
y = x**2 + 3*x + 1
y.backward()  # 计算梯度

print(x.grad)  # 输出梯度值

tensor([7.])

在这个例子中，y.backward() 会自动计算 y 关于 x 的梯度，并保存在 x.grad 中。

8. 与 NumPy 的关系

PyTorch 的张量与 NumPy 的数组非常相似，它们之间可以无缝转换。通过 torch.tensor() 可以将 NumPy 数组转换为张量，通过 .numpy() 方法可以将张量转换为 NumPy 数组。

import numpy as np

# NumPy 数组转张量
np_array = np.array([1, 2, 3])
tensor_from_np = torch.tensor(np_array)

# 张量转 NumPy 数组
tensor = torch.tensor([4, 5, 6])
np_from_tensor = tensor.numpy()

array([4, 5, 6], dtype=int64)

pytorch中的主要函数

1. seed()

import torch
torch.seed()

614398074638100

用于生成不确定的随机数，返回64位数值。

参数：无

2. manual_seed()

torch.manual_seed(10)

<torch._C.Generator at 0x20c67010830>

设定生成的随机数种子，返回一个Generator 对象。初始化 PyTorch 所有随机数生成操作的种子，确保在不同的运行中能够生成相同的随机数序列，从而使得实验的结果可复现。

举个例子

# 设置随机数种子
torch.manual_seed(10)

# 生成一个随机张量
x = torch.rand(3, 3)
print(x)

tensor([[0.4581, 0.4829, 0.3125],
        [0.6150, 0.2139, 0.4118],
        [0.6938, 0.9693, 0.6178]])

每次运行结果得到的张量是一样的，因为设置了随机数种子。

3.initial_seed()

torch.initial_seed()

10

这个函数可以返回你刚刚设置的随机数种子。

4.get_rng_state()

torch.get_rng_state()

tensor([10,  0,  0,  ...,  0,  0,  0], dtype=torch.uint8)

用来获取当前随机数生成器（RNG，Random Number Generator）的状态的函数。它返回一个包含当前状态的张量，可以用来在将来恢复相同的随机数生成器状态，从而使得随机数生成的过程可复现。

5.get_rng_state()

torch.get_rng_state()

用来 获取当前随机数生成器（RNG）状态 的函数。它返回一个张量，代表当前随机数生成器的内部状态信息。通过获取这个状态，您可以在将来的某个时间点恢复这个状态，从而确保生成的随机数序列保持一致，确保实验的可复现性。

# 设置随机种子
torch.manual_seed(42)

# 生成一个随机张量
x1 = torch.rand(3, 3)
print("原始随机张量:")
print(x1)

# 获取当前随机数生成器的状态
rng_state = torch.get_rng_state()

# 更改种子，生成另一个随机张量
torch.manual_seed(123)
x2 = torch.rand(3, 3)
print("新的随机张量:")
print(x2)

# 恢复原始的随机数生成器状态
torch.set_rng_state(rng_state)

# 生成一个新的随机张量，它应该与x1相同
x3 = torch.rand(3, 3)
print("Tensor after restoring RNG state:")
print(x3)

# 观察结果，x1 和 x3 应该是相同的

原始随机张量:
tensor([[0.8823, 0.9150, 0.3829],
        [0.9593, 0.3904, 0.6009],
        [0.2566, 0.7936, 0.9408]])
新的随机张量:
tensor([[0.2961, 0.5166, 0.2517],
        [0.6886, 0.0740, 0.8665],
        [0.1366, 0.1025, 0.1841]])
Tensor after restoring RNG state:
tensor([[0.1332, 0.9346, 0.5936],
        [0.8694, 0.5677, 0.7411],
        [0.4294, 0.8854, 0.5739]])

微分基础

微分是数学中的概念，是对函数局部变化率的线性描述，pytorch可以实现自动微分。

import torch
# 定义张量w和x
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
#  定义 a 和 b
a = torch.add(x, w)
b = torch.add(w, 1)
y = torch.mul(a, b)

# 反向传播
y.backward()

print(w.grad)

tensor([5.])

1. w 和 x 都是张量（标量形式），它们的值分别是 1.0 和 2.0。requires_grad=True 表示这两个张量需要计算梯度。PyTorch 会追踪这些张量的操作，以便我们可以计算它们在某个计算图中的梯度。

2. a = x + w 计算了 a，即 a = 2.0 + 1.0 = 3.0。

   b = w + 1 计算了 b，即 b = 1.0 + 1.0 = 2.0。

   y = a * b 计算了 y，即 y = 3.0 * 2.0 = 6.0。

3. y.backward() 计算 y 关于所有要求梯度的张量（在这个例子中是 w 和 x）的梯度。这个操作会触发 PyTorch 自动微分引擎来根据计算图中的操作计算梯度。

   在这个例子中，我们需要计算的是 w 的梯度，因为 w.requires_grad=True。

梯度计算过程

如何计算 w 的梯度

我们可以通过链式法则来手动推导 w 的梯度：

1. 计算 y 关于 a 和 b 的偏导数：

   由于 y = a * b，所以根据乘法法则，有：

∂ y ∂ a = b 和 ∂ y ∂ b = a \frac{\partial y}{\partial a} = b \quad \text{和} \quad \frac{\partial y}{\partial b} = a ∂a∂y=b和∂b∂y=a

2. 计算 a 和 b 关于 w 的偏导数：

   • a = x + w，所以：
     ∂ a ∂ w = 1 \frac{\partial a}{\partial w} = 1 ∂w∂a=1
   • b = w + 1，所以：
     ∂ b ∂ w = 1 \frac{\partial b}{\partial w} = 1 ∂w∂b=1

3. 使用链式法则计算 y 关于 w 的梯度：

   通过链式法则，我们可以计算 y 相对于 w 的梯度：
   ∂ y ∂ w = ∂ y ∂ a ⋅ ∂ a ∂ w + ∂ y ∂ b ⋅ ∂ b ∂ w \frac{\partial y}{\partial w} = \frac{\partial y}{\partial a} \cdot \frac{\partial a}{\partial w} + \frac{\partial y}{\partial b} \cdot \frac{\partial b}{\partial w} ∂w∂y=∂a∂y⋅∂w∂a+∂b∂y⋅∂w∂b

   代入已知的值：
   ∂ y ∂ w = b ⋅ 1 + a ⋅ 1 \frac{\partial y}{\partial w} = b \cdot 1 + a \cdot 1 ∂w∂y=b⋅1+a⋅1

   由于 a = 3.0 和 b = 2.0，所以：
   ∂ y ∂ w = 2.0 ⋅ 1 + 3.0 ⋅ 1 = 2.0 + 3.0 = 5.0 \frac{\partial y}{\partial w} = 2.0 \cdot 1 + 3.0 \cdot 1 = 2.0 + 3.0 = 5.0 ∂w∂y=2.0⋅1+3.0⋅1=2.0+3.0=5.0

   因此，w.grad 将是 5.0。

== 今天的分享就结束了，希望小伙伴们可以初步的了解张量。==