一、认识人工智能：AI的本质与实现逻辑

1. 人工智能的核心本质

• AI = 数学计算 + 算力 + 算法： AI的本质是通过数学模型模拟人类智能（如感知、学习、决策），其中：
• 数学是理论基础（如线性代数、微积分、概率论）；
• 算力（CPU/GPU/TPU）是实现关键（支撑大规模数据处理和模型训练）；
• 算法（如神经网络、大模型）是核心驱动力（将数学理论转化为可执行的计算流程）。

• AI的应用方向：NLP（自然语言处理，如ChatGPT）、CV（计算机视觉，如图像识别）、自动驾驶、机器人等。

2. AI实现的三要素与流程

• 三要素：
• 数据：模型的“原料”（如图像、文本），需标注（如分类标签）和预处理（如归一化）；
• 网络：数学模型（如神经网络），定义输入到输出的映射关系；
• 算力：支撑模型训练的硬件（如GPU加速张量计算）。

• 实现流程： ① 设计神经网络（找到合适的数学公式，如y = wx + b）； ② 训练：用标注数据调整网络参数（通过梯度下降最小化损失函数）； ③ 推理：用训练好的模型预测新样本（如输入图像，输出类别）。

二、初识PyTorch：为什么选它？

1. PyTorch的核心优势

• 动态计算图： 与TensorFlow的静态图（先定义图再执行）不同，PyTorch采用动态图（边执行边构建），更灵活，适合调试和研究（如动态调整网络结构）。

• 自动微分： 内置torch.autograd模块，自动计算张量操作的梯度（无需手动推导），是反向传播算法的核心支撑。

• GPU加速： 张量可通过.to('cuda')迁移到GPU，大幅提升计算效率（如训练大型神经网络时，GPU比CPU快10-100倍）。

• 易用性： API设计符合Python习惯，文档丰富，社区活跃（如Hugging Face、TorchVision等生态支持）。

2. 深度学习框架对比

三、Tensor：PyTorch的核心数据结构

1. Tensor的概念与维度

• 定义：Tensor（张量）是元素类型相同的多维数组，是PyTorch中数据存储与计算的基本单位。

• 维度理解：
• 标量（0维）：torch.tensor(5)（形状()）；
• 向量（1维）：torch.tensor([1,2,3])（形状(3,)）；
• 矩阵（2维）：torch.tensor([[1,2],[3,4]])（形状(2,2)）；
• 高维张量：如图像（3维，H×W×C，高度×宽度×通道）、视频（4维，T×H×W×C，时间×高度×宽度×通道）。

2. Tensor的核心特点

• 动态计算图：Tensor的操作会被记录到计算图中，用于后续梯度计算（自动微分）。

• GPU加速：通过.to('cuda')将Tensor迁移到GPU，大幅提升计算速度（如矩阵乘法）。

• 自动微分：通过requires_grad=True标记Tensor，PyTorch会自动计算其梯度（用于模型参数更新）。

3. Tensor的数据类型

• 常见类型：
• 浮点数：torch.float32（默认，占4字节）、torch.float64（双精度，占8字节）、torch.float16（半精度，占2字节，适合GPU加速）；
• 整数：torch.int32、torch.int64（默认整数类型）；
• 布尔：torch.bool（占1字节）。

• 选择原则：
• 精度越高，计算越准确，但内存占用越大（如float64比float32多占一倍内存）；
• GPU加速优先选float16或float32（GPU对浮点数计算优化更好）。

四、Tensor的创建与关键区别

1. 常用创建方法

• 从数据创建：torch.tensor(data)
• 示例：torch.tensor([1,2,3])（自动推断类型为int64）；torch.tensor([1.0,2.0], dtype=torch.float32)（指定类型）。

• 从形状创建：torch.Tensor(shape)
• 示例：torch.Tensor(2,3)（创建2×3的浮点张量，默认float32）。

• 指定类型创建：torch.IntTensor(shape)、torch.FloatTensor(shape)等
• 示例：torch.IntTensor(2,3)（创建2×3的整数张量，类型int32）。

• 线性张量：torch.arange(start, end, step)、torch.linspace(start, end, steps)
• 示例：torch.arange(0,10,2)（生成[0,2,4,6,8]）；torch.linspace(0,1,5)（生成[0,0.25,0.5,0.75,1]）。

• 随机张量：torch.rand(shape)（均匀分布，0-1）、torch.randn(shape)（标准正态分布，均值0，标准差1）、torch.normal(mean, std, shape)（自定义正态分布）。
• 随机种子：torch.manual_seed(seed)（固定种子，复现实验结果）。

2. 关键区别：torch.tensor vs torch.Tensor

五、Tensor的核心操作

1. 元素级运算（Element-wise）

• 常用操作：add（加）、sub（减）、mul（乘）、div（除）、pow（次方）。

• 原地操作：带_的方法（如add_）会修改原始Tensor，无需返回新对象。
• 示例：data.add_(1)（将data的每个元素加1，修改原始数据）。

2. 矩阵运算

• 阿达玛积（逐元素相乘）：或torch.mul(a, b)（要求a和b形状相同）。
• 示例：a = torch.tensor([1,2]); b = torch.tensor([3,4]); a*b（结果[3,8]）。

• 矩阵乘法（线性代数）：@或torch.matmul(a, b)（要求a的列数等于b的行数）。
• 示例：a = torch.tensor([[1,2],[3,4]]); b = torch.tensor([[5],[6]]); a@b（结果[[17],[39]]）。

3. 形状调整

• reshape：调整形状（需保证元素数量不变），支持1自动计算维度。
• 示例：data = torch.rand(4,3); data.reshape(2,6)（将4×3调整为2×6）；data.reshape(2,-1)（自动计算第二维为6）。

• view：与reshape类似，但要求Tensor在内存中连续（即元素存储顺序与形状一致）。
• 示例：data.view(2,6)（若data连续，则返回视图；否则报错）。

• transpose：交换两个维度（如torch.transpose(data, 0, 1)交换0维和1维）。

• permute：重新排列所有维度（如data.permute(2,0,1)将形状(H,W,C)转为(C,H,W)）。

• squeeze/unsqueeze：降维/升维（squeeze移除大小为1的维度；unsqueeze添加大小为1的维度）。
• 示例：data = torch.rand(32,32,3); data.unsqueeze(0)（添加 batch 维度，形状变为(1,32,32,3)）。

4. 广播机制（Broadcasting）

• 规则：当两个Tensor形状不同时，PyTorch会自动扩展较小的Tensor，使其与较大的Tensor形状一致（右对齐，维度扩展）。
• 示例：a = torch.tensor([1,2,3]); b = torch.tensor([[4],[5]]); a + b（a扩展为[[1,2,3],[1,2,3]]，b扩展为[[4,4,4],[5,5,5]]，结果为[[5,6,7],[6,7,8]]）。

• 注意：广播不会复制数据（仅逻辑扩展），因此效率很高，但需确保形状兼容（如(2,3)与(3,)可以广播，(2,3)与(2,4)不能广播）。

六、自动微分：PyTorch的核心优势

1. 基础概念

• 计算图：记录Tensor操作的流程（节点是Tensor，边是操作）。
• 示例：y = x**2; loss = y.sum()（计算图为x → y → loss）。

• 叶子节点：用户直接创建的Tensor（如模型参数w、b），requires_grad=True（需要计算梯度）。

• 反向传播：从损失函数（loss）倒推每个叶子节点的梯度（loss.backward()）。

2. 梯度计算示例

• 标量梯度（最常见）： 示例：x = torch.tensor(1.0, requires_grad=True); y = x**2; y.backward()（x.grad为2.0，即dy/dx=2x）。

• 向量梯度（需转为标量）： 示例：x = torch.tensor([1.0,2.0], requires_grad=True); y = x**2; loss = y.mean(); loss.backward()（x.grad为[1.0, 2.0]，即d(loss)/dx = (2x)/n，n=2）。

• 多变量梯度： 示例：x1 = torch.tensor(5.0, requires_grad=True); x2 = torch.tensor(3.0, requires_grad=True); y = x1**2 + 2*x2 +7; y.backward()（x1.grad为10.0，x2.grad为2.0）。

3. 梯度上下文控制

• 禁用梯度计算：with torch.no_grad()（推理时使用，减少内存占用）。 示例：with torch.no_grad(): y = x**2（y的requires_grad为False）。

• 梯度累加：循环中不清零梯度（用于小批量训练，如batch_size=2，循环两次累加梯度，再更新参数）。

• 梯度清零：x.grad.zero_()（每次反向传播前清零，避免梯度累加）。 示例：for epoch in range(100): loss.backward(); optimizer.step(); optimizer.zero_grad()（优化器自动清零梯度）。

4. 关键注意事项

• Tensor必须是浮点类型：整数类型无法求导（如torch.int64的requires_grad=True会报错）。

• backward()仅能调用一次：默认情况下，计算图会被释放（节省内存），若需多次调用，需设置retain_graph=True（如loss.backward(retain_graph=True)）。

• 叶子节点不能原地修改：如x -= lr * x.grad（x是叶子节点，requires_grad=True）会报错，需用with torch.no_grad(): x -= lr * x.grad（禁用梯度计算后修改）。

七、案例：线性回归（梯度下降实践）

1. 问题定义

2. 代码逻辑

• 数据准备：x = torch.tensor([1,2,3,4,5], dtype=torch.float32); y = torch.tensor([3,5,7,9,11], dtype=torch.float32)。

• 初始化参数：a = torch.tensor([1.0], requires_grad=True); b = torch.tensor([1.0], requires_grad=True)。

• 训练循环： ① 前向传播：y_pred = a*x + b； ② 计算损失：loss = ((y_pred - y)**2).mean()（MSE损失）； ③ 反向传播：loss.backward()；（对损失求导并将结果分别存入a.grad,b.grad） ④ 更新参数：with torch.no_grad(): a -= lr * a.grad; b -= lr * b.grad；（必须使用-=，原地修改） ⑤ 清零梯度：a.grad.zero_(); b.grad.zero_() （清空grad）

3. 结果分析

• 学习率调整：lr=0.01（过小，收敛慢）、lr=0.1（过大，发散）、lr=0.05（合适，收敛快）。

• 收敛效果：迭代500次后，a≈1.98，b≈1.05（无限接近真实值）。