PyTorch

PyTorch 是由 Meta（原 Facebook）开发的开源深度学习框架，于 2016 年发布，以灵活性、动态计算图和易用性为核心特点，广泛应用于学术研究和工业界。

其核心优势包括：

• 动态计算图：计算过程实时构建，支持在运行中修改网络结构，便于调试和灵活实验
• 自动求导机制：自动计算张量操作的梯度，简化反向传播实现
• GPU 加速：无缝支持 CUDA 加速，大幅提升大规模张量运算效率
• 丰富生态：配套 TorchVision（计算机视觉）、TorchText（自然语言处理）等工具库
• 良好兼容性：支持模型导出为 ONNX 格式，便于跨框架部署

PyTorch 的核心数据结构是张量（Tensor），所有神经网络操作都围绕张量展开。

Tensor

• 核心数据结构： torch.Tensor 是 PyTorch 中最基本、最重要的数据结构，类似于 NumPy 的 ndarray，但拥有额外的特性使其适用于深度学习。
• 本质： 一个多维数组（张量）。标量是 0 维张量，向量是 1 维张量，矩阵是 2 维张量，依此类推。
• 关键特性：
  • GPU 加速： 可以轻松地将 Tensor 移动到 GPU 上进行高速并行计算。
  • 自动微分 (Autograd)： Tensor 可以跟踪在其上执行的操作，以自动计算梯度（导数），这是训练神经网络的核心（反向传播）。
  • 丰富的操作： 提供了大量用于数学运算、线性代数、随机采样等的函数。

---

1 Tensor 的创建

有多种方式创建 Tensor：

1.torch.tensor

从 Python 列表或序列创建：

import torch
# 创建标量 (0维)
scalar = torch.tensor(3.14)
# 创建向量 (1维)
vector = torch.tensor([1, 2, 3, 4])
# 创建矩阵 (2维)
matrix = torch.tensor([[1., 2.], [3., 4.]])
# 创建3维张量
tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

2.torch.Tensor

# 1. 根据形状创建张量
tensor1 = torch.Tensor(2, 3)
print(tensor1)
# 2. 也可以是具体的值
tensor2 = torch.Tensor([[1, 2, 3], [4, 5, 6]])
print(tensor2, tensor2.shape, tensor2.dtype)tensor3 = torch.Tensor([10])
print(tensor3, tensor3.shape, tensor3.dtype)# 指定tensor数据类型
tensor1 = torch.Tensor([1,2,3]).short()
print(tensor1)tensor1 = torch.Tensor([1,2,3]).int()
print(tensor1)

3. 线性张量

使用 torch.arange() / torch.linspace()： 创建线性序列

• torch.arange(start=0, end, step=1)： 类似 Python range，创建从 start 到 end（不包括 end），步长为 step 的 1 维 Tensor。
• torch.linspace(start, end, steps)： 创建从 start 到 end（包括 end）的等间隔 steps 个点组成的 1 维 Tensor。

# 类似range，生成[start, end)的整数序列
t_arange = torch.arange(0, 10, step=2)  # 结果：[0, 2, 4, 6, 8]# 生成均匀分布的线性序列（包含end）
t_linspace = torch.linspace(0, 1, steps=5)  # 结果：[0.0, 0.25, 0.5, 0.75, 1.0]

4. 随机张量

使用 torch.rand() / torch.randn() / torch.randint()： 创建随机初始化的 Tensor。

• torch.rand(*size)： 从 [0, 1) 均匀分布中随机采样。
• torch.randn(*size)： 从 标准正态分布（均值为0，方差为1） 中随机采样。
• torch.randint(low, high, size)： 从 [low, high) 的整数均匀分布中随机采样。

# 均匀分布 [0,1)
t_rand = torch.rand(2, 3)  # 形状为(2,3)的随机张量# 标准正态分布（均值0，方差1）
t_randn = torch.randn(3, 3)# 随机整数 [low, high)
t_randint = torch.randint(low=0, high=10, size=(2, 2))  # 2x2的0-9随机整数# 固定随机种子（保证结果可复现）
torch.manual_seed(42)

5. 特定数值的张量

t_zeros = torch.zeros((2, 3))  # 全零张量，形状(2,3)
t_ones = torch.ones((3, 3))   # 全一张量
t_full = torch.full((2, 2), 5)  # 填充指定值（5）
t_eye = torch.eye(3)  # 单位矩阵（对角线为1，其余为0）

---

2 Tensor 常见属性

1 属性

.shape	张量的形状（各维度大小）	t = torch.rand(2, 3); print(t.shape)	torch.Size([2, 3])
.size()	与 .shape 等价，返回形状元组	print(t.size(0))	2（第 0 维大小）
.dtype	数据类型（如 float32、int64 等）	print(t.dtype)	torch.float32
.device	存储设备（CPU 或 GPU）	print(t.device)	cpu 或 cuda:0
.requires_grad	是否需要计算梯度（用于反向传播）	t = torch.tensor(2.0, requires_grad=True); print(t.requires_grad)	True
.grad	存储梯度值（需先调用 .backward()）	t.backward(); print(t.grad)	tensor(1.)（示例梯度值）
.is_cuda	是否在 GPU 上（布尔值）	print(t.is_cuda)	False（CPU 上）
.numel()	总元素数量（各维度大小乘积）	print(t.numel())	6（2×3 的张量）

2 设备切换

PyTorch 支持张量在 CPU 和 GPU 之间迁移，以利用 GPU 的并行计算能力加速深度学习任务。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

方法 1：使用 .to(device)

# 创建一个 CPU 上的张量
t_cpu = torch.tensor([1, 2, 3])
print("原始设备:", t_cpu.device)  # cpu# 迁移到 GPU（若可用）
t_gpu = t_cpu.to(device)
print("迁移后设备:", t_gpu.device)  # cuda:0（若有GPU）# 从 GPU 迁回 CPU
t_cpu2 = t_gpu.to("cpu")
print(t_cpu2.device)  # cpu

方法 2：使用 .cuda() 和 .cpu()

    t2 = torch.tensor([1,2,3])t2 = t2.cuda()print(t2)t3 = t2.cpu()print(t3)

3 类型转换

torch.Tensor.to(dtype)

通用方法，通过 dtype 参数指定目标类型，适用于所有转换场景：

import torch# 原始张量（int64类型）
t = torch.tensor([1, 2, 3], dtype=torch.int64)
print("原始类型:", t.dtype)  # torch.int64# 转换为 float32（默认浮点类型）
t_float32 = t.to(torch.float32)
print("转换为float32:", t_float32.dtype)  # torch.float32# 转换为 int32
t_int32 = t.to(torch.int32)
print("转换为int32:", t_int32.dtype)  # torch.int32# 转换为 bool 类型（非0值为True）
t_bool = t.to(torch.bool)
print("转换为bool:", t_bool.dtype, t_bool)  # torch.bool tensor([True, True, True])

类型专用方法

PyTorch 为常用类型提供了专用方法，更简洁直观：

t = torch.tensor([1, 2, 3], dtype=torch.int32)t_float = t.float()       # 等价于 to(torch.float32)
t_double = t.double()     # 等价于 to(torch.float64)
t_long = t.long()         # 等价于 to(torch.int64)
t_int = t.int()           # 等价于 to(torch.int32)
t_bool = t.bool()         # 等价于 to(torch.bool)

创建张量时直接指定类型

通过 dtype 参数在创建张量时就确定类型，避免后续转换：

# 直接创建 float16 类型张量
t_half = torch.tensor([1.5, 2.5], dtype=torch.float16)
print(t_half.dtype)  # torch.float16# 直接创建 uint8 类型张量（图像数据常用）
t_uint8 = torch.tensor([0, 128, 255], dtype=torch.uint8)
print(t_uint8.dtype)  # torch.uint8

与 NumPy 数组的类型互转

PyTorch 张量与 NumPy 数组转换时，类型会自动对应，也可显式指定：

import numpy as np# NumPy 数组（float64类型）
np_arr = np.array([1.2, 3.4], dtype=np.float64)# 转换为 PyTorch 张量（默认对应 float64）
t = torch.from_numpy(np_arr)
print(t.dtype)  # torch.float64# 转换时显式指定类型
t = torch.from_numpy(np_arr).to(torch.float32)
print(t.dtype)  # torch.float32# 张量转 NumPy 数组（保留类型）
np_arr2 = t.numpy()
print(np_arr2.dtype)  # float32

---

4 数据转换（浅拷贝与深拷贝）

在 PyTorch 中理解数据转换（尤其是涉及内存共享）非常重要，因为它直接影响内存使用和计算结果。

• 浅拷贝 (Shallow Copy)： 创建一个新对象，但新对象的内容是对原对象内容的引用。修改新对象的内容可能会改变原对象的内容（因为它们共享底层数据）。内存效率高。
• 深拷贝 (Deep Copy)： 创建一个新对象，并且递归地复制原对象及其包含的所有对象。新对象与原对象完全独立，修改其中一个不会影响另一个。内存开销更大。

张量转Numpy

numpy():张量转numpy数组，浅拷贝，修改numpy的元素会修改张量元素

numpy().copy():深拷贝，复制一个副本，修改副本不会影响源张量元素

    t = torch.tensor([1,2,3])print(t)	#tensor([1, 2, 3])# numpy():张量转numpy数组，浅拷贝，修改numpy的元素会修改张量元素a = t.numpy()a[0]=100print(a)	#[100   2   3]print(t)	#tensor([100,   2,   3])b = t.numpy().copy()# numpy().copy():深拷贝，复制一个副本，修改副本不会影响源张量元素b[0]=200print(b)	#[200   2   3]print(t)	#tensor([100,   2,   3])

Numpy转张量

torch.from_numpy():numpy数组转张量，浅拷贝，修改张量元素会修改numpy的元素

torch.tensor():numpy数组转张量，深拷贝，会创建新的存储空间，修改副本不会影响源numpy元素

    a = np.array([1,2,3])print(a)# torch.from_numpy():numpy数组转张量，浅拷贝，修改张量元素会修改numpy的元素t = torch.from_numpy(a)print(t)t[0] = 100print(t,a)# torch.tensor():numpy数组转张量，深拷贝，复制一个副本，修改副本不会影响源numpy元素t1 = torch.tensor(a)t1[0]=999print(a)

5. Tensor常见操作

5.1 获取元素值

item()方法：单个元素的数组获取元素值，维度不影响

• 和Tensor的维度没有关系，都可以取出来
• 如果有多个元素则报错；

    t = torch.tensor(10)print((t.item()))t1 = torch.tensor([[10]])print(t1.item())

5.2 元素值运算

常见的加减乘除次方取反开方等各种操作，带有_的方法则会替换原始值。

import torchdef test001():# 生成范围 [0, 10) 的 2x3 随机整数张量data = torch.randint(0, 10, (2, 3))print(data)# 元素级别的加减乘除：不修改原始值print(data.add(1))print(data.sub(1))print(data.mul(2))print(data.div(3))print(data.pow(2))# 元素级别的加减乘除：修改原始值data = data.float()data.add_(1)data.sub_(1)data.mul_(2)data.div_(3.0)data.pow_(2)print(data)if __name__ == "__main__":test001()

5.3 形状操作

调整 Tensor 的维度和形状是适配神经网络输入输出的关键操作。

5.3.1 改变形状（reshape /view）

• view(new_shape)：修改数组形状，不改变内存存储顺序，效率较高，
  • 前提是tensor在内存中是连续的，否则需先用contiguous()转换；
  • 如果进行转置等操作导致数据不连续，此时使用view()方法会报错
  • 支持 -1 自动计算维度，总元素数必须与原张量一致
• reshape(new_shape)：功能类似 NumPy 的reshape，会自动处理非连续情况（内部可能调用view或复制数据）

x = torch.arange(12)  # 形状：(12,)# reshape：灵活改变形状（推荐，自动处理非连续内存）
x1 = x.reshape(3, 4)  # 3行4列 → (3,4)
x2 = x.reshape(2, 2, 3)  # 3维 → (2,2,3)# view：类似reshape，但要求Tensor内存连续（不连续时会报错）
x3 = x.view(4, 3)  # 4行3列 → (4,3)

5.3.2 维度增减（unsqueeze /squeeze）

• unsqueeze：用于在指定位置插入一个大小为 1 的新维度。

• squeeze：用于移除所有大小为 1 的维度，或者移除指定维度的大小为 1 的维度;若删除的维度数不为1，则不做任何操作，也不报错

x = torch.tensor([1, 2, 3])  # 形状：(3,)# unsqueeze：在指定位置增加一个维度（维度大小为1）
x_unsq0 = x.unsqueeze(0)  # 形状：(1,3)（在第0维增加）
x_unsq1 = x.unsqueeze(1)  # 形状：(3,1)（在第1维增加）# squeeze：删除大小为1的维度（默认删除所有）
x_sq0 = x_unsq0.squeeze()  # 形状：(3,)（删除第0维）
x_sq1 = x_unsq1.squeeze(1)  # 形状：(3,)（指定删除第1维）

5.3.3 维度交换（transpose /permute）

transpose: 用于交换张量的两个维度,返回新张量，原张量不变

permute:重新排列张量的维度,不改变张量的数据，只改变维度的顺序

x = torch.randn(2, 3, 4)  # 形状：(2,3,4)（假设为[batch, height, width]）# transpose：交换两个维度
x_trans = x.transpose(1, 2)  # 交换1和2维 → 形状：(2,4,3)# permute：重排所有维度（更灵活）
x_perm = x.permute(2, 0, 1)  # 维度顺序变为2→0→1 → 形状：(4,2,3)

5.4 阿达玛积

对两个形状相同的 Tensor，对应位置的元素相乘，结果形状与输入相同。

实现方式：

• 运算符：*
• 函数：torch.mul(a, b)
• 方法：a.mul(b)

'''# 阿达码积:
前提：两个矩阵形状相同；
两个矩阵相同位置元素相乘：Cij = Mij * Nij
运算：mul   *
'''t = torch.tensor([[1,2,3],[3,4,5]])t1 = torch.tensor([[5,6,6],[7,8,9]])print(t.mul(t1))print(t*t1)'''tensor([[ 5, 12, 18],[21, 32, 45]])tensor([[ 5, 12, 18],[21, 32, 45]])	'''

5.5 Tensor相乘

要求前一个矩阵的列数等于后一个矩阵的行数。

实现方式：

• 运算符：@
• 函数：torch.matmul(a, b)
• 方法：a.matmul(b)

'''
矩阵运算：(M X N) x (N X M)
第一个矩阵的第一行于第二个矩阵的第一列元素分别相乘之和...
运算符号：matmul  @
'''t = torch.tensor([[1,2,3],[3,4,5]])t1 = torch.tensor([[5,6],[7,8],[9,10]])print(t.matmul(t1))print(t@t1)'''tensor([[ 46,  52],[ 88, 100]])tensor([[ 46,  52],[ 88, 100]])'''

6 广播机制（Broadcasting）

当两个 Tensor 形状不同时，PyTorch 会自动扩展它们的维度以匹配，便于元素级运算（类似 NumPy 的广播）。

广播规则：

1. 若维度数量不同，在形状较短的 Tensor 前补 1，直到维度数量一致。
2. 对于每个维度，若两个 Tensor 的大小相同，或其中一个为 1，则可广播（扩展为较大的大小）。

a = torch.tensor([[1, 2, 3], [4, 5, 6]])  # 形状：(2,3)
b = torch.tensor([10, 20, 30])           # 形状：(3,)# 广播后：
# a保持(2,3)，b扩展为(2,3) → [[10,20,30], [10,20,30]]
c = a + b  # 结果：[[11,22,33], [14,25,36]]# 另一个例子：(3,1) 与 (1,4) 广播为 (3,4)
d = torch.tensor([[1], [2], [3]])  # (3,1)
e = torch.tensor([[10, 20, 30, 40]])  # (1,4)
f = d + e  
# 结果：3x4矩阵 → [[11,21,31,41], [12,22,32,42],[13,23,33,43]]