diff --git a/Pytorch/Optim/readme.md b/Pytorch/Optim/readme.md
new file mode 100644
index 0000000..9acf96c
--- /dev/null
+++ b/Pytorch/Optim/readme.md
@@ -0,0 +1,466 @@
+根据 PyTorch 官网（pytorch.org）的文档，`torch.optim` 是 PyTorch 中用于优化神经网络参数的模块，提供了多种优化算法（如 SGD、Adam 等）。以下是对 `torch.optim` 模块中所有优化器及其核心方法的详细讲解，基于官方文档（截至 2025 年 9 月 9 日的最新信息）以及 `torch.optim` 的功能。
+
+`torch.optim` 模块包含多个优化器类，每个优化器都继承自 `torch.optim.Optimizer` 基类。优化器的主要作用是通过梯度下降或其他优化算法更新模型参数。以下是 `torch.optim` 模块中常见优化器及其方法的讲解，结合代码示例和实际用途。
+
+---
+
+### 1. `torch.optim.Optimizer` 基类
+所有优化器都继承自 `torch.optim.Optimizer`，它是所有优化器的基类，定义了通用的方法和属性。
+
+#### 核心方法
+以下是 `torch.optim.Optimizer` 基类中定义的主要方法：
+
+- **`__init__(params, defaults)`**
+ - **作用**: 初始化优化器，指定需要优化的参数和默认超参数。
+ - **参数**:
+ - `params`: 可迭代对象，通常是模型参数（通过 `model.parameters()` 获取）或参数组（包含参数和特定超参数的字典列表）。
+ - `defaults`: 默认的超参数字典（如学习率 `lr`、动量 `momentum` 等）。
+ - **示例**:
+ ```python
+ import torch
+ import torch.nn as nn
+ import torch.optim as optim
+
+ model = nn.Linear(10, 2)
+ optimizer = optim.SGD(model.parameters(), lr=0.01)
+ ```
+
+- **`zero_grad(set_to_none=True)`**
+ - **作用**: 将所有优化参数的梯度清零，为下一次前向传播和反向传播做准备。
+ - **参数**:
+ - `set_to_none`: 如果为 `True`，梯度张量被设置为 `None`（更高效）；如果为 `False`，梯度被置为 0。
+ - **用途**: 在每次优化步骤前调用，以避免梯度累积。
+ - **示例**:
+ ```python
+ optimizer.zero_grad() # 清零梯度
+ ```
+
+- **`step(closure=None)`**
+ - **作用**: 执行一次优化步骤，更新模型参数。
+ - **参数**:
+ - `closure`: 可选的闭包函数，用于某些需要多次计算梯度的优化器（如 LBFGS）。
+ - **用途**: 根据梯度和优化算法更新参数。
+ - **示例**:
+ ```python
+ loss = loss_fn(model(inputs), targets)
+ loss.backward() # 计算梯度
+ optimizer.step() # 更新参数
+ ```
+
+- **`add_param_group(param_group)`**
+ - **作用**: 向优化器添加新的参数组，允许对不同参数设置不同的超参数（如学习率）。
+ - **参数**:
+ - `param_group`: 包含参数和超参数的字典，如 `{'params': parameters, 'lr': 0.01}`。
+ - **用途**: 用于动态调整优化器管理的参数或为不同层设置不同的学习率。
+ - **示例**:
+ ```python
+ optimizer.add_param_group({'params': model.new_layer.parameters(), 'lr': 0.001})
+ ```
+
+- **`state_dict()`**
+ - **作用**: 返回优化器的状态字典，包含优化器的超参数和状态（如动量缓冲区）。
+ - **用途**: 用于保存优化器状态以便后续恢复。
+ - **示例**:
+ ```python
+ torch.save(optimizer.state_dict(), 'optimizer.pth')
+ ```
+
+- **`load_state_dict(state_dict)`**
+ - **作用**: 从状态字典中加载优化器状态。
+ - **参数**:
+ - `state_dict`: 通过 `state_dict()` 保存的状态字典。
+ - **用途**: 用于恢复优化器状态，通常与模型权重恢复一起使用。
+ - **示例**:
+ ```python
+ optimizer.load_state_dict(torch.load('optimizer.pth'))
+ ```
+
+- **`param_groups` 属性**
+ - **作用**: 优化器管理的参数组列表，每个参数组是一个字典，包含参数和对应的超参数。
+ - **用途**: 可用于检查或修改优化器的参数组。
+ - **示例**:
+ ```python
+ for group in optimizer.param_groups:
+ print(group['lr']) # 打印每个参数组的学习率
+ ```
+
+---
+
+### 2. 常见优化器
+`torch.optim` 提供了多种优化算法，每种优化器都继承自 `Optimizer` 基类，并实现了特定的 `step()` 方法。以下是常见优化器的介绍及其特定参数。
+
+#### 2.1 `torch.optim.SGD`
+- **描述**: 随机梯度下降（Stochastic Gradient Descent），支持动量法和 Nesterov 动量。
+- **初始化参数**:
+ - `params`: 优化参数。
+ - `lr` (float): 学习率（必须）。
+ - `momentum` (float, optional): 动量因子（默认 0）。
+ - `weight_decay` (float, optional): L2 正则化系数（默认 0）。
+ - `dampening` (float, optional): 动量阻尼（默认 0）。
+ - `nesterov` (bool, optional): 是否使用 Nesterov 动量（默认 False）。
+- **示例**:
+ ```python
+ optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)
+ ```
+
+#### 2.2 `torch.optim.Adam`
+- **描述**: Adam 优化器，结合一阶和二阶动量，自适应调整学习率。
+- **初始化参数**:
+ - `params`: 优化参数。
+ - `lr` (float, optional): 学习率（默认 1e-3）。
+ - `betas` (tuple, optional): 动量系数 `(beta1, beta2)`（默认 (0.9, 0.999)）。
+ - `eps` (float, optional): 数值稳定性小值（默认 1e-8）。
+ - `weight_decay` (float, optional): L2 正则化系数（默认 0）。
+ - `amsgrad` (bool, optional): 是否使用 AMSGrad 变体（默认 False）。
+- **示例**:
+ ```python
+ optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), weight_decay=1e-2)
+ ```
+
+#### 2.3 `torch.optim.AdamW`
+- **描述**: Adam 的改进版本，解耦权重衰减（更适合正则化）。
+- **初始化参数**:
+ - 与 `Adam` 类似，但 `weight_decay` 默认值为 1e-2。
+- **示例**:
+ ```python
+ optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
+ ```
+
+#### 2.4 `torch.optim.RMSprop`
+- **描述**: RMSprop 优化器，使用移动平均的平方梯度来归一化梯度。
+- **初始化参数**:
+ - `params`: 优化参数。
+ - `lr` (float, optional): 学习率（默认 1e-2）。
+ - `alpha` (float, optional): 平滑因子（默认 0.99）。
+ - `eps` (float, optional): 数值稳定性小值（默认 1e-8）。
+ - `weight_decay` (float, optional): L2 正则化系数（默认 0）。
+ - `momentum` (float, optional): 动量因子（默认 0）。
+ - `centered` (bool, optional): 是否中心化梯度（默认 False）。
+- **示例**:
+ ```python
+ optimizer = optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99)
+ ```
+
+#### 2.5 `torch.optim.Adagrad`
+- **描述**: Adagrad 优化器，自适应调整学习率，适合稀疏数据。
+- **初始化参数**:
+ - `params`: 优化参数。
+ - `lr` (float, optional): 学习率（默认 1e-2）。
+ - `lr_decay` (float, optional): 学习率衰减（默认 0）。
+ - `weight_decay` (float, optional): L2 正则化系数（默认 0）。
+ - `eps` (float, optional): 数值稳定性小值（默认 1e-10）。
+- **示例**:
+ ```python
+ optimizer = optim.Adagrad(model.parameters(), lr=0.01)
+ ```
+
+#### 2.6 `torch.optim.Adadelta`
+- **描述**: Adadelta 优化器，Adagrad 的改进版本，无需手动设置学习率。
+- **初始化参数**:
+ - `params`: 优化参数。
+ - `lr` (float, optional): 初始学习率（默认 1.0）。
+ - `rho` (float, optional): 梯度平方移动平均的衰减率（默认 0.9）。
+ - `eps` (float, optional): 数值稳定性小值（默认 1e-6）。
+ - `weight_decay` (float, optional): L2 正则化系数（默认 0）。
+- **示例**:
+ ```python
+ optimizer = optim.Adadelta(model.parameters(), lr=1.0)
+ ```
+
+#### 2.7 `torch.optim.LBFGS`
+- **描述**: L-BFGS 优化器，适合小规模数据，使用二阶信息。
+- **初始化参数**:
+ - `params`: 优化参数。
+ - `lr` (float): 学习率（默认 1）。
+ - `max_iter` (int, optional): 每次优化的最大迭代次数（默认 20）。
+ - `max_eval` (int, optional): 每次优化的最大函数评估次数（默认 None）。
+ - `tolerance_grad` (float, optional): 梯度收敛阈值（默认 1e-7）。
+ - `tolerance_change` (float, optional): 参数变化收敛阈值（默认 1e-9）。
+ - `history_size` (int, optional): 历史更新向量数量（默认 100）。
+- **注意**: 需要提供闭包函数给 `step()`。
+- **示例**:
+ ```python
+ optimizer = optim.LBFGS(model.parameters(), lr=1)
+ def closure():
+ optimizer.zero_grad()
+ loss = loss_fn(model(inputs), targets)
+ loss.backward()
+ return loss
+ optimizer.step(closure)
+ ```
+
+#### 2.8 其他优化器
+- **`torch.optim.Adamax`**: Adam 的变体，基于无穷范数。
+- **`torch.optim.ASGD`**: 平均随机梯度下降，适合非凸问题。
+- **`torch.optim.Rprop`**: 弹性反向传播，适合全批量梯度下降。
+- **`torch.optim.SparseAdam`**: Adam 的稀疏版本，适合稀疏张量。
+
+---
+
+### 3. 学习率调度器（`torch.optim.lr_scheduler`）
+虽然 `lr_scheduler` 不是 `torch.optim` 的核心部分，但它与优化器密切相关，用于动态调整学习率。以下是常见调度器及其方法：
+
+- **常见调度器**:
+ - `torch.optim.lr_scheduler.StepLR`: 每隔固定步数降低学习率。
+ - `torch.optim.lr_scheduler.MultiStepLR`: 在指定步数降低学习率。
+ - `torch.optim.lr_scheduler.ExponentialLR`: 指数衰减学习率。
+ - `torch.optim.lr_scheduler.CosineAnnealingLR`: 余弦退火调整学习率。
+ - `torch.optim.lr_scheduler.ReduceLROnPlateau`: 根据指标（如验证损失）降低学习率。
+
+- **核心方法**:
+ - `step()`: 更新学习率，通常在每个 epoch 或 step 调用。
+ - `get_last_lr()`: 获取当前学习率。
+ - `state_dict()` 和 `load_state_dict()`: 保存和加载调度器状态。
+
+- **示例**:
+ ```python
+ scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
+ for epoch in range(100):
+ optimizer.step()
+ scheduler.step() # 每 10 个 epoch 降低学习率
+ ```
+
+---
+
+### 4. 实际使用示例
+以下是一个完整的训练循环示例，展示优化器和调度器的使用：
+
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+# 定义模型
+model = nn.Linear(10, 1)
+criterion = nn.MSELoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
+
+# 训练循环
+for epoch in range(50):
+ optimizer.zero_grad() # 清零梯度
+ outputs = model(inputs)
+ loss = criterion(outputs, targets)
+ loss.backward() # 计算梯度
+ optimizer.step() # 更新参数
+ scheduler.step() # 更新学习率
+ print(f'Epoch {epoch}, Loss: {loss.item()}, LR: {scheduler.get_last_lr()[0]}')
+```
+
+---
+
+### 5. 注意事项
+- **选择优化器**: 根据任务选择合适的优化器。Adam 和 AdamW 是大多数深度学习任务的默认选择；SGD 适合需要精细控制的任务；LBFGS 适合小规模数据集。
+- **超参数调优**: 学习率、动量等超参数对收敛影响很大，需通过实验调整。
+- **梯度裁剪**: 对于梯度爆炸问题，可使用 `torch.nn.utils.clip_grad_norm_`。
+- **保存和加载**: 训练时应同时保存模型和优化器状态。
+
+如果需要更详细的某优化器或方法的解释，或者需要针对具体任务的优化建议，请告诉我！
+
+---
+
+我来为你详细解释 `torch.optim` 中提到的这些优化器（SGD、LBFGS、Adadelta、Adagrad、RMSProp、Adam、AdamW）的概念和特点。这些都是 PyTorch 中用于优化神经网络参数的算法，基于梯度下降的原理，但各有不同的改进和适用场景。以下是简洁而清晰的讲解，尽量避免重复之前的内容，并专注于每个优化器的核心思想、公式和用途。
+
+---
+
+### 1. SGD（Stochastic Gradient Descent，随机梯度下降）
+- **是什么**:
+ - SGD 是最基础的优化算法，通过梯度下降更新参数，每次使用一个样本或一个小批量（mini-batch）计算梯度。
+ - 支持动量法（Momentum）和 Nesterov 动量，进一步加速收敛。
+- **核心思想**:
+ - 参数更新基于梯度的负方向，步长由学习率控制。
+ - 动量法通过累积历史梯度加速更新，Nesterov 动量在计算梯度时考虑了动量的前瞻性。
+- **更新公式**:
+ - 基本 SGD:
+ \( \theta_{t+1} = \theta_t - \eta \cdot \nabla_\theta J(\theta_t) \)
+ - \(\eta\): 学习率
+ - \(\nabla_\theta J\): 损失函数 \(J\) 对参数 \(\theta\) 的梯度
+ - 带动量:
+ \( v_t = \gamma v_{t-1} + \eta \cdot \nabla_\theta J(\theta_t) \)
+ \( \theta_{t+1} = \theta_t - v_t \)
+ - \(\gamma\): 动量因子（通常 0.9）
+ - Nesterov 动量:
+ \( v_t = \gamma v_{t-1} + \eta \cdot \nabla_\theta J(\theta_t - \gamma v_{t-1}) \)
+ \( \theta_{t+1} = \theta_t - v_t \)
+- **特点**:
+ - 简单，易于理解，适合大多数任务。
+ - 需要手动调整学习率，可能收敛较慢。
+ - 动量和 Nesterov 动量能加速收敛，减少震荡。
+- **适用场景**:
+ - 凸优化问题或需要精细控制的任务。
+ - 常用于简单的神经网络或大型数据集。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, nesterov=True)
+ ```
+
+---
+
+### 2. LBFGS（Limited-memory Broyden-Fletcher-Goldfarb-Shanno）
+- **是什么**:
+ - LBFGS 是一种准牛顿法（Quasi-Newton Method），使用二阶信息（近似 Hessian 矩阵）来优化参数。
+ - 它是 BFGS 算法的内存优化版本，适合小规模数据集。
+- **核心思想**:
+ - 利用历史梯度和参数更新信息近似计算 Hessian 矩阵的逆，指导更高效的参数更新。
+ - 需要闭包函数多次计算梯度和损失。
+- **更新公式**:
+ - 复杂且依赖于近似 Hessian 的逆，无法简单表达。
+ - 核心是基于历史梯度和参数变化构建搜索方向，更新参数。
+- **特点**:
+ - 收敛速度快，适合小型数据集。
+ - 计算开销大，内存需求较高。
+ - 需要提供闭包函数，代码实现稍复杂。
+- **适用场景**:
+ - 小规模数据集或非深度学习任务（如逻辑回归）。
+ - 不适合大规模深度神经网络（因内存和计算限制）。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.LBFGS(model.parameters(), lr=1)
+ def closure():
+ optimizer.zero_grad()
+ loss = loss_fn(model(inputs), targets)
+ loss.backward()
+ return loss
+ optimizer.step(closure)
+ ```
+
+---
+
+### 3. Adagrad（Adaptive Gradient Algorithm）
+- **是什么**:
+ - Adagrad 是一种自适应学习率的优化算法，通过累积历史梯度的平方来自动调整学习率。
+- **核心思想**:
+ - 为每个参数分配不同的学习率，频繁更新的参数学习率较小，稀疏更新的参数学习率较大。
+ - 适合处理稀疏数据（如自然语言处理中的词嵌入）。
+- **更新公式**:
+ - \( G_t = G_{t-1} + (\nabla_\theta J(\theta_t))^2 \)
+ - \( \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{G_t} + \epsilon} \cdot \nabla_\theta J(\theta_t) \)
+ - \(G_t\): 梯度平方的累积
+ - \(\epsilon\): 数值稳定性小值（防止除零）
+- **特点**:
+ - 自适应学习率，初期收敛快。
+ - 后期因 \(G_t\) 持续累积，学习率可能变得过小，导致收敛停滞。
+- **适用场景**:
+ - 稀疏数据或凸优化问题。
+ - 不适合深度神经网络（因学习率衰减过快）。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.Adagrad(model.parameters(), lr=0.01)
+ ```
+
+---
+
+### 4. Adadelta
+- **是什么**:
+ - Adadelta 是 Adagrad 的改进版本，解决了学习率过快衰减的问题，无需手动设置初始学习率。
+- **核心思想**:
+ - 使用固定时间窗口的梯度平方移动平均代替 Adagrad 的累积和。
+ - 引入参数更新的移动平均来稳定更新步长。
+- **更新公式**:
+ - \( E[g^2]_t = \rho E[g^2]_{t-1} + (1-\rho)(\nabla_\theta J(\theta_t))^2 \)
+ - \( \Delta \theta_t = -\frac{\sqrt{E[\Delta \theta^2]_{t-1} + \epsilon}}{\sqrt{E[g^2]_t + \epsilon}} \cdot \nabla_\theta J(\theta_t) \)
+ - \( \theta_{t+1} = \theta_t + \Delta \theta_t \)
+ - \(\rho\): 衰减率（类似动量）
+ - \(E[\Delta \theta^2]\): 参数更新的移动平均
+- **特点**:
+ - 无需手动设置学习率，适合长期训练。
+ - 比 Adagrad 更稳定，但仍可能对超参数敏感。
+- **适用场景**:
+ - 稀疏数据或需要稳定学习率的场景。
+ - 比 Adagrad 更适合深度学习任务。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.Adadelta(model.parameters(), lr=1.0, rho=0.9)
+ ```
+
+---
+
+### 5. RMSProp（Root Mean Square Propagation）
+- **是什么**:
+ - RMSProp 是 Adagrad 的另一种改进，通过指数移动平均来限制梯度平方的累积，保持学习率稳定。
+- **核心思想**:
+ - 类似 Adadelta，使用梯度平方的指数移动平均来归一化梯度。
+ - 比 Adagrad 更适合非凸问题（如深度神经网络）。
+- **更新公式**:
+ - \( E[g^2]_t = \alpha E[g^2]_{t-1} + (1-\alpha)(\nabla_\theta J(\theta_t))^2 \)
+ - \( \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{E[g^2]_t + \epsilon}} \cdot \nabla_\theta J(\theta_t) \)
+ - \(\alpha\): 平滑因子（默认 0.99）
+- **特点**:
+ - 学习率自适应，适合深度学习。
+ - 超参数（如 \(\alpha\)、\(\epsilon\)）对性能影响较大。
+- **适用场景**:
+ - 深度神经网络，尤其适合非平稳目标函数。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99)
+ ```
+
+---
+
+### 6. Adam（Adaptive Moment Estimation）
+- **是什么**:
+ - Adam 结合了动量法和 RMSProp，通过一阶动量（梯度均值）和二阶动量（梯度平方均值）自适应调整学习率。
+- **核心思想**:
+ - 使用梯度的指数移动平均（一阶动量）和梯度平方的指数移动平均（二阶动量）来更新参数。
+ - 包含偏差校正，初期更稳定。
+- **更新公式**:
+ - 一阶动量: \( m_t = \beta_1 m_{t-1} + (1-\beta_1) \nabla_\theta J(\theta_t) \)
+ - 二阶动量: \( v_t = \beta_2 v_{t-1} + (1-\beta_2) (\nabla_\theta J(\theta_t))^2 \)
+ - 偏差校正: \( \hat{m}_t = \frac{m_t}{1-\beta_1^t} \), \( \hat{v}_t = \frac{v_t}{1-\beta_2^t} \)
+ - 参数更新: \( \theta_{t+1} = \theta_t - \frac{\eta \hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} \)
+ - \(\beta_1, \beta_2\): 动量系数（默认 0.9, 0.999）
+- **特点**:
+ - 收敛快，超参数鲁棒性强。
+ - 是深度学习任务的默认选择。
+- **适用场景**:
+ - 几乎所有深度学习任务（图像、NLP 等）。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))
+ ```
+
+---
+
+### 7. AdamW
+- **是什么**:
+ - AdamW 是 Adam 的改进版本，解耦了权重衰减（Weight Decay）与优化步骤，优化正则化效果。
+- **核心思想**:
+ - 在 Adam 的基础上，将权重衰减从梯度更新中分离，直接应用于参数。
+ - 更适合正则化，防止过拟合。
+- **更新公式**:
+ - 与 Adam 类似，但在参数更新时显式添加权重衰减项:
+ \( \theta_{t+1} = \theta_t - \frac{\eta \hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} - \eta \lambda \theta_t \)
+ - \(\lambda\): 权重衰减系数
+- **特点**:
+ - 比 Adam 更适合需要强正则化的任务。
+ - 通常比 Adam 性能略好，尤其在 Transformer 等模型中。
+- **适用场景**:
+ - 深度学习任务，尤其是需要正则化的场景（如 Transformer 模型）。
+- **PyTorch 示例**:
+ ```python
+ optimizer = torch.optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
+ ```
+
+---
+
+### 总结对比
+| 优化器 | 自适应学习率 | 动量 | 适合场景 | 优点 | 缺点 |
+|------------|--------------|------|-----------------------------|--------------------------|-----------------------------|
+| SGD | 否 | 可选 | 简单任务、大规模数据 | 简单，易于调试 | 收敛慢，需调学习率 |
+| LBFGS | 否 | 无 | 小规模数据集、凸优化 | 收敛快 | 内存占用高，不适合深度学习 |
+| Adagrad | 是 | 无 | 稀疏数据、凸优化 | 自适应，适合稀疏数据 | 学习率过快衰减 |
+| Adadelta | 是 | 无 | 稀疏数据、深度学习 | 无需设学习率，较稳定 | 超参数敏感 |
+| RMSProp | 是 | 可选 | 深度学习、非平稳目标 | 适合非凸问题 | 超参数需调优 |
+| Adam | 是 | 是 | 几乎所有深度学习任务 | 收敛快，鲁棒性强 | 正则化效果稍弱 |
+| AdamW | 是 | 是 | 深度学习、需要正则化 | 改进正则化，性能更优 | 超参数需调优 |
+
+---
+
+### 选择建议
+- **默认选择**: Adam 或 AdamW，适合大多数深度学习任务，收敛快且超参数鲁棒。
+- **稀疏数据**: Adagrad 或 Adadelta，适合 NLP 或推荐系统。
+- **简单任务或需精细控制**: SGD（带动量）。
+- **小数据集**: LBFGS（需闭包函数）。
+- **Transformer 模型**: AdamW 是首选（如 BERT、GPT 等）。
+
+如果你对某个优化器的实现细节、数学推导或具体应用场景有疑问，或者想看某优化器的代码示例，请告诉我，我可以进一步展开！
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/.idea/ez0.iml b/Pytorch/Project/ez0/.idea/ez0.iml
new file mode 100644
index 0000000..b910500
--- /dev/null
+++ b/Pytorch/Project/ez0/.idea/ez0.iml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/.idea/inspectionProfiles/Project_Default.xml b/Pytorch/Project/ez0/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000..8f50a20
--- /dev/null
+++ b/Pytorch/Project/ez0/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,239 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/.idea/inspectionProfiles/profiles_settings.xml b/Pytorch/Project/ez0/.idea/inspectionProfiles/profiles_settings.xml
new file mode 100644
index 0000000..105ce2d
--- /dev/null
+++ b/Pytorch/Project/ez0/.idea/inspectionProfiles/profiles_settings.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/.idea/misc.xml b/Pytorch/Project/ez0/.idea/misc.xml
new file mode 100644
index 0000000..5c8f845
--- /dev/null
+++ b/Pytorch/Project/ez0/.idea/misc.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/.idea/modules.xml b/Pytorch/Project/ez0/.idea/modules.xml
new file mode 100644
index 0000000..b3b0c86
--- /dev/null
+++ b/Pytorch/Project/ez0/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/.idea/workspace.xml b/Pytorch/Project/ez0/.idea/workspace.xml
new file mode 100644
index 0000000..dd4fd27
--- /dev/null
+++ b/Pytorch/Project/ez0/.idea/workspace.xml
@@ -0,0 +1,81 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {
+ "associatedIndex": 0
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1757405400023
+
+
+ 1757405400023
+
+
+
+
\ No newline at end of file
diff --git a/Pytorch/Project/ez0/HandWriteCNN.py b/Pytorch/Project/ez0/HandWriteCNN.py
new file mode 100644
index 0000000..abe1bfb
--- /dev/null
+++ b/Pytorch/Project/ez0/HandWriteCNN.py
@@ -0,0 +1,115 @@
+import torch
+import matplotlib.pyplot as plt
+from torch import nn
+import torch.optim as optim
+import torch.nn.functional as F
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
+from main import optimizer
+
+# 设置超参数
+batch_size = 64
+
+# 定义预处理步骤
+transform = transforms.Compose([
+ transforms.ToTensor(), # 转换为张量，范围 [0,1]
+ transforms.Normalize((0.1307,), (0.3081,)) # 标准化：均值、方差是 MNIST 的经验值
+])
+
+# 加载训练集
+train_dataset = datasets.MNIST(
+ root='./data', # 数据存放路径
+ train=True, # 训练集
+ download=True, # 如果没有就下载
+ transform=transform # 应用预处理
+)
+
+# 加载测试集
+test_dataset = datasets.MNIST(
+ root='./data',
+ train=False, # 测试集
+ download=True,
+ transform=transform
+)
+
+# 构建 DataLoader
+train_loader = DataLoader(
+ dataset=train_dataset,
+ batch_size=batch_size,
+ shuffle=True # 打乱数据，适合训练
+)
+
+test_loader = DataLoader(
+ dataset=test_dataset,
+ batch_size=batch_size,
+ shuffle=False # 测试集不需要打乱
+)
+
+# 简单测试一下
+print(f"训练集大小: {len(train_dataset)}")
+print(f"测试集大小: {len(test_dataset)}")
+
+# 取一个 batch 看看形状
+images, labels = next(iter(train_loader))
+print(f"图片批次维度: {images.shape}") # [batch_size, 1, 28, 28]
+print(f"标签批次维度: {labels.shape}") # [batch_size]
+
+class CNN(nn.Module):
+ def __init__(self):
+ super(CNN, self).__init__()
+ self.c1 = nn.Conv2d(1, 16, 3, padding=1)
+ self.c2 = nn.Conv2d(16, 32, 3, padding=1)
+ self.c3 = nn.Conv2d(32, 64, 3, padding=1)
+ self.pool = nn.MaxPool2d(2, 2)
+ self.linear0 = nn.Linear(64 * 7 * 7, 128) # 注意这里是14*14，如果只池化一次，池化一次减半
+ self.linear1 = nn.Linear(128, 64)
+ self.linear2 = nn.Linear(64, 32)
+ self.linear3 = nn.Linear(32, 10)
+ self.drop = nn.Dropout(p=0.31) # 丢弃概率
+
+ def forward(self, x):
+ x = F.relu(self.c1(x))
+ x = self.pool(F.relu(self.c2(x))) # [batch,32,14,14] → pool → [batch,32,7,7]
+ x = self.pool(F.relu(self.c3(x)))
+ x = x.view(x.size(0), -1) # flatten
+ x = F.relu(self.linear0(x))
+ x = F.relu(self.linear1(x))
+ x = self.drop(x)
+ x = F.relu(self.linear2(x))
+ x = self.linear3(x)
+ return x
+
+ez = CNN()
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(ez.parameters(), lr=0.001)
+
+for i in range(10):
+ ez.train()
+ for images, labels in train_loader:
+ out = ez(images)
+ loss = criterion(out, labels)
+ #反向传播
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+ print(f": {loss}")
+
+#训练结束
+ez.eval() # 关闭 dropout/batchnorm 等训练特性
+
+correct = 0
+total = 0
+
+with torch.no_grad(): # 测试不需要计算梯度，节省显存
+ for images, labels in test_loader:
+ outputs = ez(images) # [batch_size, 10]
+
+ # 取每行最大值对应的索引作为预测类别
+ _, predicted = torch.max(outputs, 1)
+
+ total += labels.size(0)
+ correct += (predicted == labels).sum().item()
+
+print(f"测试集准确率: {correct}/{total} = {correct/total*100:.2f}%")
diff --git a/Pytorch/Project/ez0/HandWriteMLP.py b/Pytorch/Project/ez0/HandWriteMLP.py
new file mode 100644
index 0000000..3caae29
--- /dev/null
+++ b/Pytorch/Project/ez0/HandWriteMLP.py
@@ -0,0 +1,111 @@
+import torch
+import matplotlib.pyplot as plt
+from torch import nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
+from main import optimizer
+
+# 设置超参数
+batch_size = 64
+
+# 定义预处理步骤
+transform = transforms.Compose([
+ transforms.ToTensor(), # 转换为张量，范围 [0,1]
+ transforms.Normalize((0.1307,), (0.3081,)) # 标准化：均值、方差是 MNIST 的经验值
+])
+
+# 加载训练集
+train_dataset = datasets.MNIST(
+ root='./data', # 数据存放路径
+ train=True, # 训练集
+ download=True, # 如果没有就下载
+ transform=transform # 应用预处理
+)
+
+# 加载测试集
+test_dataset = datasets.MNIST(
+ root='./data',
+ train=False, # 测试集
+ download=True,
+ transform=transform
+)
+
+# 构建 DataLoader
+train_loader = DataLoader(
+ dataset=train_dataset,
+ batch_size=batch_size,
+ shuffle=True # 打乱数据，适合训练
+)
+
+test_loader = DataLoader(
+ dataset=test_dataset,
+ batch_size=batch_size,
+ shuffle=False # 测试集不需要打乱
+)
+
+# 简单测试一下
+print(f"训练集大小: {len(train_dataset)}")
+print(f"测试集大小: {len(test_dataset)}")
+
+# 取一个 batch 看看形状
+images, labels = next(iter(train_loader))
+print(f"图片批次维度: {images.shape}") # [batch_size, 1, 28, 28]
+print(f"标签批次维度: {labels.shape}") # [batch_size]
+
+# 从训练集中取一个 batch
+images, labels = next(iter(train_loader))
+'''
+# 画前 9 张图
+fig, axes = plt.subplots(3, 3, figsize=(6, 6))
+for i, ax in enumerate(axes.flat):
+ img = images[i].squeeze().numpy() # [1,28,28] -> [28,28]
+ label = labels[i].item()
+ ax.imshow(img, cmap="gray")
+ ax.set_title(f"Label: {label}")
+ ax.axis("off")
+
+plt.tight_layout()
+plt.show()
+'''
+
+ez = nn.Sequential(
+ nn.Linear(28 * 28, 256),
+ nn.ReLU(),
+ nn.Linear(256, 100),
+ nn.ReLU(),
+ nn.Linear(100, 10),
+)
+criterion = nn.CrossEntropyLoss()
+
+optimizer = optim.Adam(ez.parameters(), lr=0.002)
+
+for images, labels in train_loader:
+ images = images.view(images.size(0), -1) # [batch_size, 28*28]
+ out = ez(images)
+ loss = criterion(out, labels)
+ #反向传播
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+ print(f": {loss}")
+
+#训练结束
+ez.eval() # 关闭 dropout/batchnorm 等训练特性
+
+correct = 0
+total = 0
+
+with torch.no_grad(): # 测试不需要计算梯度，节省显存
+ for images, labels in test_loader:
+ images = images.view(images.size(0), -1) # flatten
+ outputs = ez(images) # [batch_size, 10]
+
+ # 取每行最大值对应的索引作为预测类别
+ _, predicted = torch.max(outputs, 1)
+
+ total += labels.size(0)
+ correct += (predicted == labels).sum().item()
+
+print(f"测试集准确率: {correct}/{total} = {correct/total*100:.2f}%")
diff --git a/Pytorch/Project/ez0/MyFirstModule.py b/Pytorch/Project/ez0/MyFirstModule.py
new file mode 100644
index 0000000..f573307
--- /dev/null
+++ b/Pytorch/Project/ez0/MyFirstModule.py
@@ -0,0 +1,49 @@
+import torch
+import torch.nn as nn
+
+ez = nn.Sequential(
+ nn.Linear(2, 8),
+ nn.ReLU(),
+ nn.Linear(8, 8),
+ nn.ReLU(),
+ nn.Linear(8, 1)
+)
+# y = w1 @ x + w2 @ x^2 + b
+# 两个特征，第一个是x，第二个是x^2
+criterion = nn.MSELoss()
+
+x = torch.linspace(-10, 10, 10000).unsqueeze(1)
+X = torch.cat([x, x**2], dim=1)
+y = x**2 + 2 * x + 1
+
+inx = torch.tensor([[2, 4], [1, 1], [3, 9], [4, 16]], dtype=torch.float32)
+target = torch.tensor([[9], [4], [16], [25]], dtype=torch.float32)
+
+lr = 0.00001
+for i in range(10000):
+ #向前传播
+ out = ez(X)
+ loss = criterion(out, y)
+
+ #反向传播
+ loss.backward()
+
+ with torch.no_grad():
+ # 3. 手动更新参数
+ with torch.no_grad(): # 禁止 autograd 追踪
+ for param in ez.parameters():
+ param -= lr * param.grad # 梯度下降更新参数
+
+ #梯度清零
+ ez.zero_grad()
+
+ if i % 1000 == 0:
+ print(f"Epoch {i}: loss={loss.item():.4f}")
+
+import matplotlib.pyplot as plt
+
+y_pred = ez(X).detach()
+plt.scatter(x.numpy(), x.numpy()**2 + 2*x.numpy() + 1, label='real y = x^2 + 2x + 1')
+plt.plot(x.numpy(), y_pred.numpy(), color='r', label='Predicted y = x^2 + 2x + 1')
+plt.legend()
+plt.show()
diff --git a/Pytorch/Project/ez0/__pycache__/main.cpython-313.pyc b/Pytorch/Project/ez0/__pycache__/main.cpython-313.pyc
new file mode 100644
index 0000000..795a8c0
Binary files /dev/null and b/Pytorch/Project/ez0/__pycache__/main.cpython-313.pyc differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/t10k-images-idx3-ubyte b/Pytorch/Project/ez0/data/MNIST/raw/t10k-images-idx3-ubyte
new file mode 100644
index 0000000..1170b2c
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/t10k-images-idx3-ubyte differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/t10k-images-idx3-ubyte.gz b/Pytorch/Project/ez0/data/MNIST/raw/t10k-images-idx3-ubyte.gz
new file mode 100644
index 0000000..5ace8ea
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/t10k-images-idx3-ubyte.gz differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/t10k-labels-idx1-ubyte b/Pytorch/Project/ez0/data/MNIST/raw/t10k-labels-idx1-ubyte
new file mode 100644
index 0000000..d1c3a97
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/t10k-labels-idx1-ubyte differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/t10k-labels-idx1-ubyte.gz b/Pytorch/Project/ez0/data/MNIST/raw/t10k-labels-idx1-ubyte.gz
new file mode 100644
index 0000000..a7e1415
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/t10k-labels-idx1-ubyte.gz differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/train-images-idx3-ubyte b/Pytorch/Project/ez0/data/MNIST/raw/train-images-idx3-ubyte
new file mode 100644
index 0000000..bbce276
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/train-images-idx3-ubyte differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/train-images-idx3-ubyte.gz b/Pytorch/Project/ez0/data/MNIST/raw/train-images-idx3-ubyte.gz
new file mode 100644
index 0000000..b50e4b6
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/train-images-idx3-ubyte.gz differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/train-labels-idx1-ubyte b/Pytorch/Project/ez0/data/MNIST/raw/train-labels-idx1-ubyte
new file mode 100644
index 0000000..d6b4c5d
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/train-labels-idx1-ubyte differ
diff --git a/Pytorch/Project/ez0/data/MNIST/raw/train-labels-idx1-ubyte.gz b/Pytorch/Project/ez0/data/MNIST/raw/train-labels-idx1-ubyte.gz
new file mode 100644
index 0000000..707a576
Binary files /dev/null and b/Pytorch/Project/ez0/data/MNIST/raw/train-labels-idx1-ubyte.gz differ
diff --git a/Pytorch/Project/ez0/main.py b/Pytorch/Project/ez0/main.py
new file mode 100644
index 0000000..2cf26a0
--- /dev/null
+++ b/Pytorch/Project/ez0/main.py
@@ -0,0 +1,26 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+# 1. 定义网络
+model = nn.Sequential(
+ nn.Linear(10, 20), # 输入10维 → 输出20维
+ nn.ReLU(),
+ nn.Linear(20, 2) # 输出2维（比如2分类）
+)
+
+# 2. 定义损失函数 & 优化器
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(model.parameters(), lr=0.01)
+
+# 3. 模拟训练一步
+x = torch.randn(5, 10) # batch=5, feature=10
+y = torch.tensor([0, 1, 0, 1, 1]) # 分类标签
+
+out = model(x) # forward
+loss = criterion(out, y) # loss
+optimizer.zero_grad() # 梯度清零
+loss.backward() # backward
+optimizer.step() # 更新参数
+
+print("loss =", loss.item())
diff --git a/Pytorch/Project/ez0/noise.py b/Pytorch/Project/ez0/noise.py
new file mode 100644
index 0000000..917dcdf
--- /dev/null
+++ b/Pytorch/Project/ez0/noise.py
@@ -0,0 +1,55 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import matplotlib.pyplot as plt
+from torch import optim
+
+# x 张量
+x = torch.linspace(-10, 10, 100).unsqueeze(1)
+
+# 特征矩阵
+X = torch.cat([x, x**2, x**3, torch.sin(2*x)], dim=1)
+
+# 高斯噪声
+noise = torch.from_numpy(np.random.normal(0, 3, size=x.shape)).float()
+
+# 带噪声的 y
+y_noisy = 0.5 * x**3 - 2 * x**2 + 3*x + 5 + 4 * torch.sin(2*x) + noise
+
+# 可视化
+'''
+plt.scatter(x, y_noisy, label="Noisy data")
+plt.plot(x, 0.5 * x**3 - 2 * x**2 + 3*x + 5 + 4 * torch.sin(2*x), color='red', label="Original function")
+plt.legend()
+plt.show()
+'''
+ez = nn.Sequential(
+ nn.Linear(4, 8),
+ nn.ReLU(),
+ nn.Linear(8, 4),
+ nn.ReLU(),
+ nn.Linear(4, 1),
+)
+
+criterion = nn.MSELoss()
+optimizer = optim.Adam(ez.parameters(), lr=0.0065)
+
+for i in range(10000):
+ #向前传播
+ out = ez(X)
+ loss = criterion(out, y_noisy)
+ #反向传播
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+
+ if i % 100 == 0:
+ print("Step:", i, "loss =", loss.item())
+
+with torch.no_grad():
+ y_pred = ez(X)
+
+plt.scatter(x.numpy(), y_noisy.numpy(), alpha=0.3, label="Noisy data")
+plt.plot(x.numpy(), y_pred.numpy(), color='red', label="NN prediction")
+plt.legend()
+plt.show()