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)
每个张量都有几个关键的属性：
形状 (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
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]]))
PyTorch 答应通过 .to() 或 .type() 方法来转换张量的数据类型。
- tensor = torch.tensor([1, 2, 3], dtype=torch.float32)
- tensor = tensor.to(torch.int64) # 转换为整数类型
PyTorch 张量可以在 CPU 或 GPU 上运行。使用 .to() 方法可以将张量转移到 GPU（条件是你的体系有支持的 GPU）。
- device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- tensor = tensor.to(device)
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() # 最大值
PyTorch 具有自动求导机制，可以大概盘算张量的梯度。这是深度学习中反向传播的核心。通过 requires_grad=True 来启用张量的梯度盘算。
- x = torch.tensor([2.0], requires_grad=True)
- y = x**2 + 3*x + 1
- y.backward() # 计算梯度
- print(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)
1. seed()
用于生成不确定的随机数，返回64位数值。
参数：无
2. manual_seed()
- <torch._C.Generator at 0x20c67010
- 830>
举个例子
- # 设置随机数种子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()
这个函数可以返回你刚刚设置的随机数种子。
4.get_rng_state()
- tensor([10
- , 0, 0, ..., 0, 0, 0], dtype=torch.uint8)
5.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.10
- 25, 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)
- w 和 x 都是张量（标量形式），它们的值分别是 1.0 和 2.0。requires_grad=True 表示这两个张量需要盘算梯度。PyTorch 会追踪这些张量的操纵，以便我们可以盘算它们在某个盘算图中的梯度。
- 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。
- y.backward() 盘算 y 关于所有要求梯度的张量（在这个例子中是 w 和 x）的梯度。这个操纵会触发 PyTorch 自动微分引擎来根据盘算图中的操纵盘算梯度。
在这个例子中，我们需要盘算的是 w 的梯度，因为 w.requires_grad=True。
梯度盘算过程
如何盘算 w 的梯度
我们可以通过链式法则来手动推导 w 的梯度：
- 盘算 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
- 盘算 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
- 使用链式法则盘算 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。
== 今天的分享就竣事了，希望小伙伴们可以开端的了解张量。==
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。 |
