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

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

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

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

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

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

1. 张量 (Tensor) 的定义

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

python 复制代码
import torch

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

print(tensor_2d)
python 复制代码
tensor([[1, 2],
        [3, 4]])

2. 张量的基本属性

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

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

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

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

python 复制代码
# 示例
tensor = torch.tensor([[1, 2], [3, 4]])

print("Shape:", tensor.shape)  # 输出张量的形状
print("dtype:", tensor.dtype)  # 输出张量的数据类型
print("device:", tensor.device)  # 输出张量所在设备
python 复制代码
Shape: torch.Size([2, 2])
dtype: torch.int64
device: cpu

3. 张量的初始化

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

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

python 复制代码
tensor_from_list = torch.tensor([1, 2, 3])  # 一维张量

常见初始化函数:

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

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

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

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

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

python 复制代码
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
python 复制代码
(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() 方法来转换张量的数据类型。

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

5.张量的设备

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

python 复制代码
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
tensor = tensor.to(device)

6. 张量的操作

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

加减
python 复制代码
tensor1 = torch.tensor([1, 2])
tensor2 = torch.tensor([3, 4])
sum_tensor = tensor1 + tensor2  # 张量加法
diff_tensor = tensor1 - tensor2  # 张量减法
元素级乘除
python 复制代码
product_tensor = tensor1 * tensor2  # 乘法
div_tensor = tensor1 / tensor2  # 除法
矩阵乘法

使用torch.matmul(mat1, mat2)

python 复制代码
mat1 = torch.randn(2, 3)
mat2 = torch.randn(3, 4)
result = torch.matmul(mat1, mat2)  # 矩阵乘法
转置和改变形状
python 复制代码
tensor = torch.randn(2, 3)
transposed_tensor = tensor.T  # 转置
reshaped_tensor = tensor.view(3, 2)  # 改变形状
聚合操作:

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

python 复制代码
sum_val = tensor.sum()  # 求和
mean_val = tensor.mean()  # 求均值
max_val = tensor.max()  # 最大值

7. 自动求导 (Autograd)

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

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

print(x.grad)  # 输出梯度值
python 复制代码
tensor([7.])

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

8. 与 NumPy 的关系

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

python 复制代码
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()
python 复制代码
array([4, 5, 6], dtype=int64)

pytorch中的主要函数

1. seed()

python 复制代码
import torch
torch.seed()
python 复制代码
614398074638100

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

参数:无

2. manual_seed()

python 复制代码
torch.manual_seed(10)
python 复制代码
<torch._C.Generator at 0x20c67010830>

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

举个例子
python 复制代码
# 设置随机数种子
torch.manual_seed(10)

# 生成一个随机张量
x = torch.rand(3, 3)
print(x)
python 复制代码
tensor([[0.4581, 0.4829, 0.3125],
        [0.6150, 0.2139, 0.4118],
        [0.6938, 0.9693, 0.6178]])

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

3.initial_seed()

python 复制代码
torch.initial_seed()
python 复制代码
10

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

4.get_rng_state()

python 复制代码
torch.get_rng_state()
python 复制代码
tensor([10,  0,  0,  ...,  0,  0,  0], dtype=torch.uint8)

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

5.get_rng_state()

python 复制代码
torch.get_rng_state()

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

python 复制代码
# 设置随机种子
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 应该是相同的
python 复制代码
原始随机张量:
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可以实现自动微分。

python 复制代码
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)
python 复制代码
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 关于 ab 的偏导数

    由于 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

  1. 计算 ab 关于 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
  2. 使用链式法则计算 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.0b = 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

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

相关推荐
Python图像识别4 小时前
71_基于深度学习的布料瑕疵检测识别系统(yolo11、yolov8、yolov5+UI界面+Python项目源码+模型+标注好的数据集)
python·深度学习·yolo
哥布林学者7 小时前
吴恩达深度学习课程一:神经网络和深度学习 第三周:浅层神经网络(二)
深度学习·ai
weixin_519535777 小时前
从ChatGPT到新质生产力:一份数据驱动的AI研究方向指南
人工智能·深度学习·机器学习·ai·chatgpt·数据分析·aigc
生命是有光的7 小时前
【深度学习】神经网络基础
人工智能·深度学习·神经网络
信田君95279 小时前
瑞莎星瑞(Radxa Orion O6) 基于 Android OS 使用 NPU的图片模糊查找APP 开发
android·人工智能·深度学习·神经网络
StarPrayers.9 小时前
卷积神经网络(CNN)入门实践及Sequential 容器封装
人工智能·pytorch·神经网络·cnn
数智顾问10 小时前
基于深度学习的卫星图像分类(Kaggle比赛实战)——从数据预处理到模型调优的全流程解析
深度学习
望获linux10 小时前
【实时Linux实战系列】Linux 内核的实时组调度(Real-Time Group Scheduling)
java·linux·服务器·前端·数据库·人工智能·深度学习
程序员大雄学编程10 小时前
「深度学习笔记4」深度学习优化算法完全指南:从梯度下降到Adam的实战详解
笔记·深度学习·算法·机器学习