Added nn
This commit is contained in:
e2hang
0
Pytorch/nn/Module/List(Dict)AreUsedToStoreModule
Normal file
0
Pytorch/nn/Module/List(Dict)AreUsedToStoreModule
Normal file
464
Pytorch/nn/Module/nn.Module.md
Normal file
464
Pytorch/nn/Module/nn.Module.md
Normal file
@@ -0,0 +1,464 @@
|
||||
`torch.nn.Module` 是 PyTorch 中构建神经网络的核心基类，所有的神经网络模型都继承自它。它提供了许多方法来管理模块、参数、子模块和前向传播等功能。以下基于 PyTorch 官方文档（https://pytorch.org/docs/stable/generated/torch.nn.Module.html）对 `torch.nn.Module` 的所有方法进行详细讲解，力求清晰、简洁且实用。
|
||||
|
||||
---
|
||||
|
||||
### 1. `__init__` 方法
|
||||
- **描述**: 初始化方法，用于定义模块的结构（如层、子模块等）。
|
||||
- **用法**: 在自定义模块时，重写 `__init__` 来定义子模块或参数。
|
||||
- **示例**:
|
||||
```python
|
||||
import torch.nn as nn
|
||||
class MyModel(nn.Module):
|
||||
def __init__(self):
|
||||
super(MyModel, self).__init__()
|
||||
self.fc1 = nn.Linear(10, 5)
|
||||
```
|
||||
- **说明**: 调用 `super().__init__()` 确保基类的初始化，子模块需注册到模块中（通过赋值给 `self`）。
|
||||
|
||||
---
|
||||
|
||||
### 2. `forward(*args, **kwargs)`
|
||||
- **描述**: 定义模块的前向传播逻辑，子类必须实现此方法。
|
||||
- **用法**: 输入数据通过此方法计算输出。
|
||||
- **示例**:
|
||||
```python
|
||||
def forward(self, x):
|
||||
x = self.fc1(x)
|
||||
return x
|
||||
```
|
||||
- **说明**: 这是核心方法，所有输入数据的计算流程在此定义。调用模型实例（如 `model(x)`）时会自动调用 `forward`。
|
||||
|
||||
---
|
||||
|
||||
### 3. `__call__` 方法
|
||||
- **描述**: 使模块实例可调用，内部调用 `forward` 方法并添加钩子（hook）功能。
|
||||
- **用法**: 不需要显式重写，用户通过 `model(input)` 间接调用。
|
||||
- **说明**: 通常不需要直接操作，但了解它是 `model(input)` 的实现基础。
|
||||
|
||||
---
|
||||
|
||||
### 4. `add_module(name: str, module: Module) -> None`
|
||||
- **描述**: 向模块添加一个子模块，并以指定名称注册。
|
||||
- **用法**: 动态添加子模块。
|
||||
- **示例**:
|
||||
```python
|
||||
model = nn.Module()
|
||||
model.add_module("fc1", nn.Linear(10, 5))
|
||||
```
|
||||
- **说明**: 等价于 `self.name = module`，但更灵活，适合动态构建模型。
|
||||
|
||||
---
|
||||
|
||||
### 5. `apply(fn: Callable[['Module'], None]) -> T`
|
||||
- **描述**: 递归地将函数 `fn` 应用到模块及其所有子模块。
|
||||
- **用法**: 用于初始化参数或修改模块属性。
|
||||
- **示例**:
|
||||
```python
|
||||
def init_weights(m):
|
||||
if isinstance(m, nn.Linear):
|
||||
nn.init.xavier_uniform_(m.weight)
|
||||
model.apply(init_weights)
|
||||
```
|
||||
- **说明**: 常用于自定义权重初始化。
|
||||
|
||||
---
|
||||
|
||||
### 6. `buffers(recurse: bool = True) -> Iterator[Tensor]`
|
||||
- **描述**: 返回模块中所有缓冲区（如 `running_mean` 或 `running_var`）的迭代器。
|
||||
- **用法**: 获取模块的非可训练参数（如 BatchNorm 的统计数据）。
|
||||
- **示例**:
|
||||
```python
|
||||
for buf in model.buffers():
|
||||
print(buf)
|
||||
```
|
||||
- **说明**: 如果 `recurse=True`，包括子模块的缓冲区。
|
||||
|
||||
---
|
||||
|
||||
### 7. `children() -> Iterator[Module]`
|
||||
- **描述**: 返回直接子模块的迭代器。
|
||||
- **用法**: 遍历模型的直接子模块。
|
||||
- **示例**:
|
||||
```python
|
||||
for child in model.children():
|
||||
print(child)
|
||||
```
|
||||
- **说明**: 仅返回直接子模块，不递归到更深层。
|
||||
|
||||
---
|
||||
|
||||
### 8. `cpu() -> T`
|
||||
- **描述**: 将模块的所有参数和缓冲区移动到 CPU。
|
||||
- **用法**: 用于设备切换。
|
||||
- **示例**:
|
||||
```python
|
||||
model.cpu()
|
||||
```
|
||||
- **说明**: 确保模型和数据在同一设备上运行。
|
||||
|
||||
---
|
||||
|
||||
### 9. `cuda(device: Optional[Union[int, torch.device]] = None) -> T`
|
||||
- **描述**: 将模块的所有参数和缓冲区移动到指定的 GPU 设备。
|
||||
- **用法**: 指定 GPU 设备（如 `cuda:0`）。
|
||||
- **示例**:
|
||||
```python
|
||||
model.cuda(0) # 移动到 GPU 0
|
||||
```
|
||||
- **说明**: 如果不指定 `device`，使用当前默认 GPU。
|
||||
|
||||
---
|
||||
|
||||
### 10. `double() -> T`
|
||||
- **描述**: 将模块的参数和缓冲区转换为 `torch.float64`（双精度浮点）。
|
||||
- **用法**: 提高数值精度。
|
||||
- **示例**:
|
||||
```python
|
||||
model.double()
|
||||
```
|
||||
- **说明**: 通常在需要高精度计算时使用，但会增加内存占用。
|
||||
|
||||
---
|
||||
|
||||
### 11. `eval() -> T`
|
||||
- **描述**: 将模块设置为评估模式。
|
||||
- **用法**: 关闭训练特有的行为（如 Dropout 和 BatchNorm 的更新）。
|
||||
- **示例**:
|
||||
```python
|
||||
model.eval()
|
||||
```
|
||||
- **说明**: 与 `train(False)` 等效，用于推理阶段。
|
||||
|
||||
---
|
||||
|
||||
### 12. `float() -> T`
|
||||
- **描述**: 将模块的参数和缓冲区转换为 `torch.float32`（单精度浮点）。
|
||||
- **用法**: 默认浮点类型，适合大多数深度学习任务。
|
||||
- **示例**:
|
||||
```python
|
||||
model.float()
|
||||
```
|
||||
- **说明**: 比 `double()` 更节省内存。
|
||||
|
||||
---
|
||||
|
||||
### 13. `get_buffer(target: str) -> Tensor`
|
||||
- **描述**: 返回指定名称的缓冲区。
|
||||
- **用法**: 访问特定缓冲区（如 BatchNorm 的 `running_mean`）。
|
||||
- **示例**:
|
||||
```python
|
||||
running_mean = model.get_buffer("bn.running_mean")
|
||||
```
|
||||
- **说明**: 如果缓冲区不存在，会抛出 `KeyError`。
|
||||
|
||||
---
|
||||
|
||||
### 14. `get_parameter(target: str) -> Parameter`
|
||||
- **描述**: 返回指定名称的参数。
|
||||
- **用法**: 访问特定参数（如 `weight` 或 `bias`）。
|
||||
- **示例**:
|
||||
```python
|
||||
weight = model.get_parameter("fc1.weight")
|
||||
```
|
||||
- **说明**: 参数必须是注册的参数，否则抛出 `KeyError`。
|
||||
|
||||
---
|
||||
|
||||
### 15. `get_submodule(target: str) -> Module`
|
||||
- **描述**: 返回指定路径的子模块。
|
||||
- **用法**: 访问嵌套子模块。
|
||||
- **示例**:
|
||||
```python
|
||||
submodule = model.get_submodule("block1.conv1")
|
||||
```
|
||||
- **说明**: 使用点号（如 `block1.conv1`）访问嵌套结构。
|
||||
|
||||
---
|
||||
|
||||
### 16. `half() -> T`
|
||||
- **描述**: 将模块的参数和缓冲区转换为 `torch.float16`（半精度浮点）。
|
||||
- **用法**: 用于加速计算和节省 GPU 内存。
|
||||
- **示例**:
|
||||
```python
|
||||
model.half()
|
||||
```
|
||||
- **说明**: 需确保硬件支持半精度运算。
|
||||
|
||||
---
|
||||
|
||||
### 17. `load_state_dict(state_dict: Mapping[str, Any], strict: bool = True, assign: bool = False) -> _IncompatibleKeys`
|
||||
- **描述**: 从 `state_dict` 加载参数和缓冲区。
|
||||
- **用法**: 用于加载预训练模型或检查点。
|
||||
- **示例**:
|
||||
```python
|
||||
model.load_state_dict(torch.load("model.pth"))
|
||||
```
|
||||
- **说明**:
|
||||
- `strict=True`：要求 `state_dict` 的键完全匹配。
|
||||
- `assign=True`：直接赋值而非复制（实验性功能）。
|
||||
- 返回 `_IncompatibleKeys`，指示缺失或多余的键。
|
||||
|
||||
---
|
||||
|
||||
### 18. `modules() -> Iterator[Module]`
|
||||
- **描述**: 返回模块及其所有子模块（递归）的迭代器。
|
||||
- **用法**: 遍历整个模块树。
|
||||
- **示例**:
|
||||
```python
|
||||
for module in model.modules():
|
||||
print(module)
|
||||
```
|
||||
- **说明**: 比 `children()` 更深入，包含所有层级子模块。
|
||||
|
||||
---
|
||||
|
||||
### 19. `named_buffers(recurse: bool = True, prefix: str = '', remove_duplicate: bool = True) -> Iterator[Tuple[str, Tensor]]`
|
||||
- **描述**: 返回模块中所有缓冲区的名称和值的迭代器。
|
||||
- **用法**: 获取缓冲区的名称和值。
|
||||
- **示例**:
|
||||
```python
|
||||
for name, buf in model.named_buffers():
|
||||
print(name, buf)
|
||||
```
|
||||
- **说明**: 如果 `recurse=True`，包括子模块的缓冲区。
|
||||
|
||||
---
|
||||
|
||||
### 20. `named_children() -> Iterator[Tuple[str, Module]]`
|
||||
- **描述**: 返回直接子模块的名称和模块的迭代器。
|
||||
- **用法**: 遍历直接子模块及其名称。
|
||||
- **示例**:
|
||||
```python
|
||||
for name, child in model.named_children():
|
||||
print(name, child)
|
||||
```
|
||||
- **说明**: 仅返回直接子模块，不递归。
|
||||
|
||||
---
|
||||
|
||||
### 21. `named_modules(memo: Optional[Set[Module]] = None, prefix: str = '', remove_duplicate: bool = True) -> Iterator[Tuple[str, Module]]`
|
||||
- **描述**: 返回模块及其所有子模块（递归）的名称和模块的迭代器。
|
||||
- **用法**: 遍历整个模块树及其名称。
|
||||
- **示例**:
|
||||
```python
|
||||
for name, module in model.named_modules():
|
||||
print(name, module)
|
||||
```
|
||||
- **说明**: 比 `named_children()` 更深入，包含所有层级。
|
||||
|
||||
---
|
||||
|
||||
### 22. `named_parameters(recurse: bool = True, prefix: str = '', remove_duplicate: bool = True) -> Iterator[Tuple[str, Parameter]]`
|
||||
- **描述**: 返回模块中所有参数的名称和值的迭代器。
|
||||
- **用法**: 访问模型的参数（如权重和偏置）。
|
||||
- **示例**:
|
||||
```python
|
||||
for name, param in model.named_parameters():
|
||||
print(name, param.shape)
|
||||
```
|
||||
- **说明**: 如果 `recurse=True`，包括子模块的参数。
|
||||
|
||||
---
|
||||
|
||||
### 23. `parameters(recurse: bool = True) -> Iterator[Parameter]`
|
||||
- **描述**: 返回模块中所有参数的迭代器。
|
||||
- **用法**: 用于优化器配置。
|
||||
- **示例**:
|
||||
```python
|
||||
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
|
||||
```
|
||||
- **说明**: 如果 `recurse=True`，包括子模块的参数。
|
||||
|
||||
---
|
||||
|
||||
### 24. `register_buffer(name: str, tensor: Optional[Tensor], persistent: bool = True) -> None`
|
||||
- **描述**: 注册一个缓冲区（如非可训练的张量）。
|
||||
- **用法**: 用于存储不需要梯度的张量（如 BatchNorm 的 `running_mean`）。
|
||||
- **示例**:
|
||||
```python
|
||||
self.register_buffer("running_mean", torch.zeros(10))
|
||||
```
|
||||
- **说明**: `persistent=True` 表示缓冲区会保存到 `state_dict`。
|
||||
|
||||
---
|
||||
|
||||
### 25. `register_forward_hook(hook: Callable[..., None], *, prepend: bool = False, with_kwargs: bool = False) -> RemovableHandle`
|
||||
- **描述**: 注册一个前向传播钩子函数，在模块前向传播时调用。
|
||||
- **用法**: 用于监控或修改前向传播的输入/输出。
|
||||
- **示例**:
|
||||
```python
|
||||
def hook(module, input, output):
|
||||
print(output)
|
||||
handle = model.register_forward_hook(hook)
|
||||
```
|
||||
- **说明**: 返回 `RemovableHandle`，可通过 `handle.remove()` 移除钩子。
|
||||
|
||||
---
|
||||
|
||||
### 26. `register_forward_pre_hook(hook: Callable[..., None], *, prepend: bool = False, with_kwargs: bool = False) -> RemovableHandle`
|
||||
- **描述**: 注册一个前向传播前的钩子函数，在 `forward` 调用前触发。
|
||||
- **用法**: 用于修改输入或调试。
|
||||
- **示例**:
|
||||
```python
|
||||
def pre_hook(module, input):
|
||||
print(input)
|
||||
handle = model.register_forward_pre_hook(pre_hook)
|
||||
```
|
||||
- **说明**: 类似 `register_forward_hook`，但在 `forward` 之前运行。
|
||||
|
||||
---
|
||||
|
||||
### 27. `register_full_backward_hook(hook: Callable[..., None], prepend: bool = False) -> RemovableHandle`
|
||||
- **描述**: 注册一个反向传播钩子函数，在梯度计算时调用。
|
||||
- **用法**: 用于监控或修改梯度。
|
||||
- **示例**:
|
||||
```python
|
||||
def backward_hook(module, grad_input, grad_output):
|
||||
print(grad_output)
|
||||
handle = model.register_full_backward_hook(backward_hook)
|
||||
```
|
||||
- **说明**: 在 PyTorch 2.0+ 中推荐使用，替代旧的 `register_backward_hook`。
|
||||
|
||||
---
|
||||
|
||||
### 28. `register_parameter(name: str, param: Optional[Parameter]) -> None`
|
||||
- **描述**: 注册一个参数到模块。
|
||||
- **用法**: 动态添加可训练参数。
|
||||
- **示例**:
|
||||
```python
|
||||
self.register_parameter("weight", nn.Parameter(torch.randn(10, 5)))
|
||||
```
|
||||
- **说明**: 参数会自动加入 `parameters()` 和 `state_dict`。
|
||||
|
||||
---
|
||||
|
||||
### 29. `requires_grad_(requires_grad: bool = True) -> T`
|
||||
- **描述**: 设置模块所有参数的 `requires_grad` 属性。
|
||||
- **用法**: 冻结或解冻参数。
|
||||
- **示例**:
|
||||
```python
|
||||
model.requires_grad_(False) # 冻结参数
|
||||
```
|
||||
- **说明**: 常用于冻结预训练模型的部分层。
|
||||
|
||||
---
|
||||
|
||||
### 30. `share_memory() -> T`
|
||||
- **描述**: 将模块的参数和缓冲区移动到共享内存。
|
||||
- **用法**: 用于多进程数据共享。
|
||||
- **示例**:
|
||||
```python
|
||||
model.share_memory()
|
||||
```
|
||||
- **说明**: 主要用于 `torch.multiprocessing` 场景。
|
||||
|
||||
---
|
||||
|
||||
### 31. `state_dict(*args, destination: Optional[Dict[str, Tensor]] = None, prefix: str = '', keep_vars: bool = False) -> Dict[str, Tensor]`
|
||||
- **描述**: 返回模块的参数和缓冲区的状态字典。
|
||||
- **用法**: 保存模型状态。
|
||||
- **示例**:
|
||||
```python
|
||||
torch.save(model.state_dict(), "model.pth")
|
||||
```
|
||||
- **说明**: `keep_vars=True` 时保留 `Tensor` 的 `Variable` 特性（较少使用）。
|
||||
|
||||
---
|
||||
|
||||
### 32. `to(*args, **kwargs) -> T`
|
||||
- **描述**: 将模块的参数和缓冲区移动到指定设备或数据类型。
|
||||
- **用法**: 灵活的设备/类型转换。
|
||||
- **示例**:
|
||||
```python
|
||||
model.to(device="cuda", dtype=torch.float16)
|
||||
```
|
||||
- **说明**: 支持多种参数形式（如 `to(device)`, `to(dtype)`）。
|
||||
|
||||
---
|
||||
|
||||
### 33. `to_empty(*, device: Union[str, torch.device], recurse: bool = True) -> T`
|
||||
- **描述**: 将模块的参数和缓冲区移动到指定设备，但不初始化内容。
|
||||
- **用法**: 用于初始化空模型。
|
||||
- **示例**:
|
||||
```python
|
||||
model.to_empty(device="cuda")
|
||||
```
|
||||
- **说明**: 较少使用，适合特殊场景。
|
||||
|
||||
---
|
||||
|
||||
### 34. `train(mode: bool = True) -> T`
|
||||
- **描述**: 设置模块的训练模式。
|
||||
- **用法**: 启用/禁用训练特有的行为（如 Dropout、BatchNorm）。
|
||||
- **示例**:
|
||||
```python
|
||||
model.train() # 训练模式
|
||||
model.train(False) # 等同于 eval()
|
||||
```
|
||||
- **说明**: 与 `eval()` 相对，用于切换训练/评估模式。
|
||||
|
||||
---
|
||||
|
||||
### 35. `type(dst_type: Union[str, torch.dtype]) -> T`
|
||||
- **描述**: 将模块的参数和缓冲区转换为指定数据类型。
|
||||
- **用法**: 类似 `float()`, `double()` 等，但更通用。
|
||||
- **示例**:
|
||||
```python
|
||||
model.type(torch.float16)
|
||||
```
|
||||
- **说明**: 支持字符串（如 `"torch.float32"`）或 `torch.dtype`。
|
||||
|
||||
---
|
||||
|
||||
### 36. `xpu(device: Optional[Union[int, torch.device]] = None) -> T`
|
||||
- **描述**: 将模块移动到 XPU 设备（Intel GPU）。
|
||||
- **用法**: 用于支持 XPU 的设备。
|
||||
- **示例**:
|
||||
```python
|
||||
model.xpu(0)
|
||||
```
|
||||
- **说明**: 仅在支持 XPU 的环境中有效。
|
||||
|
||||
---
|
||||
|
||||
### 37. `zero_grad(set_to_none: bool = False) -> None`
|
||||
- **描述**: 将模块所有参数的梯度清零。
|
||||
- **用法**: 在优化步骤前调用。
|
||||
- **示例**:
|
||||
```python
|
||||
model.zero_grad()
|
||||
```
|
||||
- **说明**: 如果 `set_to_none=True`，梯度设为 `None` 而非 0（更节省内存）。
|
||||
|
||||
---
|
||||
|
||||
### 注意事项
|
||||
- **模块管理**: 使用 `children()`, `modules()`, `named_parameters()` 等方法可以方便地管理复杂模型的结构和参数。
|
||||
- **设备与类型**: 确保模型和输入数据在同一设备和数据类型（`to()`, `cuda()`, `float()` 等）。
|
||||
- **钩子函数**: 钩子（如 `register_forward_hook`）是调试和动态修改模型的强大工具。
|
||||
- **状态保存**: `state_dict()` 和 `load_state_dict()` 是保存和加载模型的关键方法。
|
||||
|
||||
### 实践建议
|
||||
你可以尝试以下代码来探索 `torch.nn.Module` 的功能：
|
||||
```python
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
class MyModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.fc1 = nn.Linear(10, 5)
|
||||
self.register_buffer("running_mean", torch.zeros(5))
|
||||
|
||||
def forward(self, x):
|
||||
return self.fc1(x)
|
||||
|
||||
model = MyModel()
|
||||
print(list(model.named_parameters())) # 查看参数
|
||||
print(list(model.named_buffers())) # 查看缓冲区
|
||||
model.to("cuda") # 移动到 GPU
|
||||
model.eval() # 设置评估模式
|
||||
torch.save(model.state_dict(), "model.pth") # 保存模型
|
||||
```
|
||||
|
||||
如果你想深入某个方法（如钩子函数或 `state_dict`）或需要具体代码示例，请告诉我，我可以进一步展开！
|
||||
359
Pytorch/nn/Module/nn.ModuleDict.md
Normal file
359
Pytorch/nn/Module/nn.ModuleDict.md
Normal file
@@ -0,0 +1,359 @@
|
||||
根据 PyTorch 官方文档（`torch.nn.ModuleList` 和 `torch.nn.ModuleDict`，基于 PyTorch 2.8），以下是对这两个类的详细讲解，包括它们的定义、作用以及所有方法的全面说明。`torch.nn.ModuleList` 和 `torch.nn.ModuleDict` 是 PyTorch 中用于管理子模块（`nn.Module` 实例）的容器类，类似于 Python 的 `list` 和 `dict`，但专为 PyTorch 的模块化设计优化。它们的主要作用是方便在 `nn.Module` 中组织和管理多个子模块，确保这些子模块被正确注册并参与前向传播、参数管理和设备迁移等操作。以下内容基于官方文档和其他可靠来源（如 PyTorch Forums 和 Stack Overflow），确保准确且全面。
|
||||
|
||||
---
|
||||
|
||||
## 1. `torch.nn.ModuleList`
|
||||
|
||||
### 1.1 定义与作用
|
||||
|
||||
**官方定义**：
|
||||
```python
|
||||
class torch.nn.ModuleList(modules=None)
|
||||
```
|
||||
- **作用**：`torch.nn.ModuleList` 是一个容器类，用于以列表形式存储多个 `nn.Module` 实例（子模块）。它类似于 Python 的内置 `list`，但专为 PyTorch 的模块管理设计，存储的子模块会自动注册到父模块中，参与 `parameters()`、`named_parameters()`、设备迁移（如 `to(device)`）和前向传播。
|
||||
- **特性**：
|
||||
- **自动注册**：当 `nn.ModuleList` 作为 `nn.Module` 的属性时，其中的子模块会自动被 `model.modules()` 和 `model.parameters()` 识别，而普通 Python 列表中的模块不会。
|
||||
- **动态管理**：支持动态添加或移除子模块，适合需要变长模块列表的场景（如循环神经网络或变长层结构）。
|
||||
- **用途**：常用于需要动态或顺序管理多个子模块的模型，例如堆叠多个线性层或卷积层。
|
||||
- **参数**：
|
||||
- `modules`：一个可选的可迭代对象，包含初始的 `nn.Module` 实例。
|
||||
|
||||
**示例**：
|
||||
```python
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
class MyModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
|
||||
|
||||
def forward(self, x):
|
||||
for layer in self.layers:
|
||||
x = layer(x)
|
||||
return x
|
||||
|
||||
model = MyModel()
|
||||
print(list(model.modules())) # 输出模型及其子模块
|
||||
print(list(model.parameters())) # 输出所有线性层的参数
|
||||
```
|
||||
|
||||
### 1.2 方法讲解
|
||||
|
||||
`torch.nn.ModuleList` 支持以下方法，主要继承自 Python 的 `list`，并添加了 PyTorch 的模块管理特性。以下是所有方法的详细说明（基于官方文档和实际用法）：
|
||||
|
||||
1. **`append(module)`**：
|
||||
- **作用**：向 `ModuleList` 末尾添加一个 `nn.Module` 实例。
|
||||
- **参数**：
|
||||
- `module`：一个 `nn.Module` 实例。
|
||||
- **返回值**：`self`（`ModuleList` 本身，支持链式调用）。
|
||||
- **示例**：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.append(nn.Linear(10, 10))
|
||||
print(len(module_list)) # 输出 1
|
||||
print(isinstance(module_list[0], nn.Linear)) # 输出 True
|
||||
```
|
||||
- **注意**：添加的模块会自动注册到父模块的参数和模块列表中。
|
||||
|
||||
2. **`extend(modules)`**：
|
||||
- **作用**：将一个可迭代对象中的 `nn.Module` 实例追加到 `ModuleList` 末尾。
|
||||
- **参数**：
|
||||
- `modules`：一个可迭代对象，包含 `nn.Module` 实例。
|
||||
- **返回值**：`self`。
|
||||
- **示例**：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.extend([nn.Linear(10, 10), nn.Linear(10, 5)])
|
||||
print(len(module_list)) # 输出 2
|
||||
```
|
||||
- **注意**：`extend` 比逐个 `append` 更高效，适合批量添加子模块。
|
||||
- **Stack Overflow 示例**：合并两个 `ModuleList`：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.extend(sub_list_1)
|
||||
module_list.extend(sub_list_2)
|
||||
# 或者
|
||||
module_list = nn.ModuleList([*sub_list_1, *sub_list_2])
|
||||
```
|
||||
|
||||
3. **索引操作（如 `__getitem__`, `__setitem__`）**：
|
||||
- **作用**：支持像 Python 列表一样的索引访问和赋值操作。
|
||||
- **参数**：
|
||||
- 索引（整数或切片）。
|
||||
- **返回值**：指定索引处的 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
module_list = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
|
||||
print(module_list[0]) # 访问第一个线性层
|
||||
module_list[0] = nn.Linear(10, 5) # 替换第一个模块
|
||||
```
|
||||
- **注意**：赋值时，新值必须是 `nn.Module` 实例。
|
||||
|
||||
4. **迭代操作（如 `__iter__`）**：
|
||||
- **作用**：支持迭代，允许遍历 `ModuleList` 中的所有子模块。
|
||||
- **返回值**：迭代器，逐个返回 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
for module in module_list:
|
||||
print(module) # 打印每个子模块
|
||||
```
|
||||
|
||||
5. **长度查询（如 `__len__`）**：
|
||||
- **作用**：返回 `ModuleList` 中子模块的数量。
|
||||
- **返回值**：整数。
|
||||
- **示例**：
|
||||
```python
|
||||
print(len(module_list)) # 输出子模块数量
|
||||
```
|
||||
|
||||
6. **其他列表操作**：
|
||||
- `ModuleList` 支持 Python 列表的常见方法，如 `pop()`, `clear()`, `insert()`, `remove()` 等，但这些方法在官方文档中未明确列出（基于 Python 的 `list` 实现）。
|
||||
- **示例**（`pop`）：
|
||||
```python
|
||||
module_list = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
|
||||
removed_module = module_list.pop(0) # 移除并返回第一个模块
|
||||
print(len(module_list)) # 输出 2
|
||||
```
|
||||
- **PyTorch Forums 讨论**：有用户询问如何动态移除 `ModuleList` 中的模块，可以使用 `pop(index)` 或重新构造列表：
|
||||
```python
|
||||
module_list = nn.ModuleList(module_list[:index] + module_list[index+1:])
|
||||
```
|
||||
|
||||
### 1.3 注意事项
|
||||
|
||||
- **与普通 Python 列表的区别**：普通 Python 列表中的 `nn.Module` 不会自动注册到父模块的参数或模块列表中，而 `ModuleList` 会。
|
||||
- **与 `nn.ParameterList` 的区别**：`ModuleList` 存储 `nn.Module`（子模块），而 `nn.ParameterList` 存储 `nn.Parameter`（参数）。
|
||||
- **动态性**：`ModuleList` 适合动态模型（如变长层结构），但频繁操作可能影响性能。
|
||||
- **优化器集成**：`ModuleList` 中的子模块的参数会自动被 `model.parameters()` 包含，优化器会更新这些参数。
|
||||
|
||||
---
|
||||
|
||||
## 2. `torch.nn.ModuleDict`
|
||||
|
||||
### 2.1 定义与作用
|
||||
|
||||
**官方定义**：
|
||||
```python
|
||||
class torch.nn.ModuleDict(modules=None)
|
||||
```
|
||||
- **作用**：`torch.nn.ModuleDict` 是一个容器类，用于以字典形式存储多个 `nn.Module` 实例。类似于 Python 的内置 `dict`，但专为 PyTorch 的模块管理设计，存储的子模块会自动注册到父模块中。
|
||||
- **特性**：
|
||||
- **键值存储**：使用字符串键索引子模块，便于按名称访问。
|
||||
- **自动注册**：子模块会自动被 `model.modules()` 和 `model.parameters()` 识别。
|
||||
- **用途**：适合需要按名称管理子模块的场景，例如多任务学习或具有语义化模块的复杂模型。
|
||||
- **参数**：
|
||||
- `modules`：一个可选的可迭代对象，包含键值对（键为字符串，值为 `nn.Module` 实例）。
|
||||
|
||||
**示例**：
|
||||
```python
|
||||
class MyModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.layers = nn.ModuleDict({
|
||||
'layer1': nn.Linear(10, 10),
|
||||
'layer2': nn.Linear(10, 5)
|
||||
})
|
||||
|
||||
def forward(self, x):
|
||||
x = self.layers['layer1'](x)
|
||||
x = self.layers['layer2'](x)
|
||||
return x
|
||||
|
||||
model = MyModel()
|
||||
print(list(model.modules())) # 输出模型及其子模块
|
||||
```
|
||||
|
||||
### 2.2 方法讲解
|
||||
|
||||
`torch.nn.ModuleDict` 支持以下方法，主要继承自 Python 的 `dict`，并添加了 PyTorch 的模块管理特性。以下是所有方法的详细说明：
|
||||
|
||||
1. **`__setitem__(key, module)`**：
|
||||
- **作用**：向 `ModuleDict` 添加或更新一个键值对。
|
||||
- **参数**：
|
||||
- `key`：字符串，子模块的名称。
|
||||
- `module`：`nn.Module` 实例。
|
||||
- **示例**：
|
||||
```python
|
||||
module_dict = nn.ModuleDict()
|
||||
module_dict['layer1'] = nn.Linear(10, 10)
|
||||
print(module_dict['layer1']) # 输出线性层
|
||||
```
|
||||
|
||||
2. **`update([other])`**：
|
||||
- **作用**：使用另一个字典或键值对更新 `ModuleDict`。
|
||||
- **参数**：
|
||||
- `other`：一个字典或键值对的可迭代对象，值必须是 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
module_dict = nn.ModuleDict()
|
||||
module_dict.update({'layer1': nn.Linear(10, 10), 'layer2': nn.Linear(10, 5)})
|
||||
print(len(module_dict)) # 输出 2
|
||||
```
|
||||
|
||||
3. **索引操作（如 `__getitem__`）**：
|
||||
- **作用**：通过键访问 `ModuleDict` 中的子模块。
|
||||
- **参数**：
|
||||
- 键（字符串）。
|
||||
- **返回值**：对应的 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
print(module_dict['layer1']) # 访问 layer1 模块
|
||||
```
|
||||
|
||||
4. **迭代操作（如 `__iter__`, `keys()`, `values()`, `items()`）**：
|
||||
- **作用**：支持迭代键、值或键值对。
|
||||
- **返回值**：
|
||||
- `keys()`：返回所有键的迭代器。
|
||||
- `values()`：返回所有 `nn.Module` 的迭代器。
|
||||
- `items()`：返回键值对的迭代器。
|
||||
- **示例**：
|
||||
```python
|
||||
for key, module in module_dict.items():
|
||||
print(f"Key: {key}, Module: {module}")
|
||||
```
|
||||
|
||||
5. **长度查询（如 `__len__`）**：
|
||||
- **作用**：返回 `ModuleDict` 中子模块的数量。
|
||||
- **返回值**：整数。
|
||||
- **示例**：
|
||||
```python
|
||||
print(len(module_dict)) # 输出子模块数量
|
||||
```
|
||||
|
||||
6. **其他字典操作**：
|
||||
- `ModuleDict` 支持 Python 字典的常见方法，如 `pop(key)`, `clear()`, `popitem()`, `get(key, default=None)` 等。
|
||||
- **示例**（`pop`）：
|
||||
```python
|
||||
module_dict = nn.ModuleDict({'layer1': nn.Linear(10, 10), 'layer2': nn.Linear(10, 5)})
|
||||
removed_module = module_dict.pop('layer1') # 移除并返回 layer1
|
||||
print(len(module_dict)) # 输出 1
|
||||
```
|
||||
|
||||
### 2.3 注意事项
|
||||
|
||||
- **与普通 Python 字典的区别**：普通 Python 字典中的 `nn.Module` 不会自动注册到父模块，而 `ModuleDict` 会。
|
||||
- **与 `nn.ParameterDict` 的区别**：`ModuleDict` 存储 `nn.Module`，而 `nn.ParameterDict` 存储 `nn.Parameter`。
|
||||
- **键的唯一性**：`ModuleDict` 的键必须是字符串，且不能重复。
|
||||
- **优化器集成**：`ModuleDict` 中的子模块的参数会自动被 `model.parameters()` 包含。
|
||||
|
||||
---
|
||||
|
||||
## 3. 比较与使用场景
|
||||
|
||||
| 特性 | `ModuleList` | `ModuleDict` |
|
||||
|---------------------|-------------------------------------------|-------------------------------------------|
|
||||
| **存储方式** | 列表（按索引访问） | 字典（按键访问） |
|
||||
| **访问方式** | 索引（`module_list[0]`） | 键（`module_dict['key']`） |
|
||||
| **主要方法** | `append`, `extend`, `pop`, 索引操作 | `update`, `pop`, `keys`, `values`, `items` |
|
||||
| **适用场景** | 顺序模块管理（如多层堆叠的神经网络） | 命名模块管理（如多任务模型中的模块） |
|
||||
| **动态性** | 适合动态添加/移除模块 | 适合按名称管理模块 |
|
||||
|
||||
**选择建议**：
|
||||
- 如果子模块需要按顺序调用（如多层网络），使用 `ModuleList`。
|
||||
- 如果子模块需要按名称访问或具有明确语义（如多任务模型），使用 `ModuleDict`。
|
||||
|
||||
---
|
||||
|
||||
## 4. 综合示例
|
||||
|
||||
以下是一个结合 `ModuleList` 和 `ModuleDict` 的示例，展示它们在模型中的使用：
|
||||
|
||||
```python
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
class ComplexModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
# 使用 ModuleList 存储一组线性层
|
||||
self.list_layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(2)])
|
||||
# 使用 ModuleDict 存储命名模块
|
||||
self.dict_layers = nn.ModuleDict({
|
||||
'conv': nn.Conv2d(3, 64, kernel_size=3),
|
||||
'fc': nn.Linear(10, 5)
|
||||
})
|
||||
|
||||
def forward(self, x):
|
||||
# 使用 ModuleList
|
||||
for layer in self.list_layers:
|
||||
x = layer(x)
|
||||
# 使用 ModuleDict
|
||||
x = self.dict_layers['fc'](x)
|
||||
return x
|
||||
|
||||
model = ComplexModel()
|
||||
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
|
||||
|
||||
# 打印所有模块
|
||||
for name, module in model.named_modules():
|
||||
print(f"Module name: {name}, Module: {module}")
|
||||
|
||||
# 动态修改 ModuleList
|
||||
model.list_layers.append(nn.Linear(10, 10))
|
||||
|
||||
# 动态修改 ModuleDict
|
||||
model.dict_layers['new_fc'] = nn.Linear(5, 2)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 5. 常见问题与解答
|
||||
|
||||
1. **如何高效合并两个 `ModuleList`？**
|
||||
- 使用 `extend` 方法或解包方式：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.extend(sub_list_1)
|
||||
module_list.extend(sub_list_2)
|
||||
# 或者
|
||||
module_list = nn.ModuleList([*sub_list_1, *sub_list_2])
|
||||
```
|
||||
|
||||
2. **如何从 `ModuleList` 删除模块？**
|
||||
- 使用 `pop(index)` 或重新构造列表：
|
||||
```python
|
||||
module_list.pop(0) # 移除第一个模块
|
||||
# 或者
|
||||
module_list = nn.ModuleList([module for i, module in enumerate(module_list) if i != 0])
|
||||
```
|
||||
|
||||
3. **如何检查 `ModuleDict` 中的模块？**
|
||||
- 使用 `keys()`, `values()`, 或 `items()` 遍历：
|
||||
```python
|
||||
for key, module in module_dict.items():
|
||||
print(f"Key: {key}, Module: {module}")
|
||||
```
|
||||
|
||||
4. **如何初始化子模块的参数？**
|
||||
- 使用 `nn.Module.apply` 或直接遍历：
|
||||
```python
|
||||
def init_weights(m):
|
||||
if isinstance(m, nn.Linear):
|
||||
nn.init.xavier_uniform_(m.weight)
|
||||
model.apply(init_weights)
|
||||
# 或者
|
||||
for module in module_list:
|
||||
if isinstance(module, nn.Linear):
|
||||
nn.init.xavier_uniform_(module.weight)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 6. 总结
|
||||
|
||||
- **`torch.nn.ModuleList`**：
|
||||
- 方法：`append`, `extend`, `pop`, 索引/迭代操作。
|
||||
- 特点：类似列表，适合顺序管理子模块，自动注册到父模块。
|
||||
- 场景：动态模型、多层堆叠网络。
|
||||
- **`torch.nn.ModuleDict`**：
|
||||
- 方法：`update`, `pop`, `keys`, `values`, `items`, 索引/迭代操作。
|
||||
- 特点：类似字典，适合按名称管理子模块，自动注册。
|
||||
- 场景：多任务学习、需要语义化命名的模型。
|
||||
|
||||
**参考文献**：
|
||||
- PyTorch 官方文档：`torch.nn.ModuleList` 和 `torch.nn.ModuleDict`（`docs.pytorch.org`）
|
||||
- Stack Overflow：合并 `ModuleList` 的讨论
|
||||
- PyTorch Forums：`ModuleList` 和 `ModuleDict` 的动态操作
|
||||
|
||||
如果需要更详细的代码示例、特定方法的实现，或其他相关问题（如与优化器或设备迁移的集成），请告诉我！
|
||||
359
Pytorch/nn/Module/nn.ModuleList.md
Normal file
359
Pytorch/nn/Module/nn.ModuleList.md
Normal file
@@ -0,0 +1,359 @@
|
||||
根据 PyTorch 官方文档（`torch.nn.ModuleList` 和 `torch.nn.ModuleDict`，基于 PyTorch 2.8），以下是对这两个类的详细讲解，包括它们的定义、作用以及所有方法的全面说明。`torch.nn.ModuleList` 和 `torch.nn.ModuleDict` 是 PyTorch 中用于管理子模块（`nn.Module` 实例）的容器类，类似于 Python 的 `list` 和 `dict`，但专为 PyTorch 的模块化设计优化。它们的主要作用是方便在 `nn.Module` 中组织和管理多个子模块，确保这些子模块被正确注册并参与前向传播、参数管理和设备迁移等操作。以下内容基于官方文档和其他可靠来源（如 PyTorch Forums 和 Stack Overflow），确保准确且全面。
|
||||
|
||||
---
|
||||
|
||||
## 1. `torch.nn.ModuleList`
|
||||
|
||||
### 1.1 定义与作用
|
||||
|
||||
**官方定义**：
|
||||
```python
|
||||
class torch.nn.ModuleList(modules=None)
|
||||
```
|
||||
- **作用**：`torch.nn.ModuleList` 是一个容器类，用于以列表形式存储多个 `nn.Module` 实例（子模块）。它类似于 Python 的内置 `list`，但专为 PyTorch 的模块管理设计，存储的子模块会自动注册到父模块中，参与 `parameters()`、`named_parameters()`、设备迁移（如 `to(device)`）和前向传播。
|
||||
- **特性**：
|
||||
- **自动注册**：当 `nn.ModuleList` 作为 `nn.Module` 的属性时，其中的子模块会自动被 `model.modules()` 和 `model.parameters()` 识别，而普通 Python 列表中的模块不会。
|
||||
- **动态管理**：支持动态添加或移除子模块，适合需要变长模块列表的场景（如循环神经网络或变长层结构）。
|
||||
- **用途**：常用于需要动态或顺序管理多个子模块的模型，例如堆叠多个线性层或卷积层。
|
||||
- **参数**：
|
||||
- `modules`：一个可选的可迭代对象，包含初始的 `nn.Module` 实例。
|
||||
|
||||
**示例**：
|
||||
```python
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
class MyModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
|
||||
|
||||
def forward(self, x):
|
||||
for layer in self.layers:
|
||||
x = layer(x)
|
||||
return x
|
||||
|
||||
model = MyModel()
|
||||
print(list(model.modules())) # 输出模型及其子模块
|
||||
print(list(model.parameters())) # 输出所有线性层的参数
|
||||
```
|
||||
|
||||
### 1.2 方法讲解
|
||||
|
||||
`torch.nn.ModuleList` 支持以下方法，主要继承自 Python 的 `list`，并添加了 PyTorch 的模块管理特性。以下是所有方法的详细说明（基于官方文档和实际用法）：
|
||||
|
||||
1. **`append(module)`**：
|
||||
- **作用**：向 `ModuleList` 末尾添加一个 `nn.Module` 实例。
|
||||
- **参数**：
|
||||
- `module`：一个 `nn.Module` 实例。
|
||||
- **返回值**：`self`（`ModuleList` 本身，支持链式调用）。
|
||||
- **示例**：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.append(nn.Linear(10, 10))
|
||||
print(len(module_list)) # 输出 1
|
||||
print(isinstance(module_list[0], nn.Linear)) # 输出 True
|
||||
```
|
||||
- **注意**：添加的模块会自动注册到父模块的参数和模块列表中。
|
||||
|
||||
2. **`extend(modules)`**：
|
||||
- **作用**：将一个可迭代对象中的 `nn.Module` 实例追加到 `ModuleList` 末尾。
|
||||
- **参数**：
|
||||
- `modules`：一个可迭代对象，包含 `nn.Module` 实例。
|
||||
- **返回值**：`self`。
|
||||
- **示例**：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.extend([nn.Linear(10, 10), nn.Linear(10, 5)])
|
||||
print(len(module_list)) # 输出 2
|
||||
```
|
||||
- **注意**：`extend` 比逐个 `append` 更高效，适合批量添加子模块。
|
||||
- **Stack Overflow 示例**：合并两个 `ModuleList`：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.extend(sub_list_1)
|
||||
module_list.extend(sub_list_2)
|
||||
# 或者
|
||||
module_list = nn.ModuleList([*sub_list_1, *sub_list_2])
|
||||
```
|
||||
|
||||
3. **索引操作（如 `__getitem__`, `__setitem__`）**：
|
||||
- **作用**：支持像 Python 列表一样的索引访问和赋值操作。
|
||||
- **参数**：
|
||||
- 索引（整数或切片）。
|
||||
- **返回值**：指定索引处的 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
module_list = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
|
||||
print(module_list[0]) # 访问第一个线性层
|
||||
module_list[0] = nn.Linear(10, 5) # 替换第一个模块
|
||||
```
|
||||
- **注意**：赋值时，新值必须是 `nn.Module` 实例。
|
||||
|
||||
4. **迭代操作（如 `__iter__`）**：
|
||||
- **作用**：支持迭代，允许遍历 `ModuleList` 中的所有子模块。
|
||||
- **返回值**：迭代器，逐个返回 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
for module in module_list:
|
||||
print(module) # 打印每个子模块
|
||||
```
|
||||
|
||||
5. **长度查询（如 `__len__`）**：
|
||||
- **作用**：返回 `ModuleList` 中子模块的数量。
|
||||
- **返回值**：整数。
|
||||
- **示例**：
|
||||
```python
|
||||
print(len(module_list)) # 输出子模块数量
|
||||
```
|
||||
|
||||
6. **其他列表操作**：
|
||||
- `ModuleList` 支持 Python 列表的常见方法，如 `pop()`, `clear()`, `insert()`, `remove()` 等，但这些方法在官方文档中未明确列出（基于 Python 的 `list` 实现）。
|
||||
- **示例**（`pop`）：
|
||||
```python
|
||||
module_list = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
|
||||
removed_module = module_list.pop(0) # 移除并返回第一个模块
|
||||
print(len(module_list)) # 输出 2
|
||||
```
|
||||
- **PyTorch Forums 讨论**：有用户询问如何动态移除 `ModuleList` 中的模块，可以使用 `pop(index)` 或重新构造列表：
|
||||
```python
|
||||
module_list = nn.ModuleList(module_list[:index] + module_list[index+1:])
|
||||
```
|
||||
|
||||
### 1.3 注意事项
|
||||
|
||||
- **与普通 Python 列表的区别**：普通 Python 列表中的 `nn.Module` 不会自动注册到父模块的参数或模块列表中，而 `ModuleList` 会。
|
||||
- **与 `nn.ParameterList` 的区别**：`ModuleList` 存储 `nn.Module`（子模块），而 `nn.ParameterList` 存储 `nn.Parameter`（参数）。
|
||||
- **动态性**：`ModuleList` 适合动态模型（如变长层结构），但频繁操作可能影响性能。
|
||||
- **优化器集成**：`ModuleList` 中的子模块的参数会自动被 `model.parameters()` 包含，优化器会更新这些参数。
|
||||
|
||||
---
|
||||
|
||||
## 2. `torch.nn.ModuleDict`
|
||||
|
||||
### 2.1 定义与作用
|
||||
|
||||
**官方定义**：
|
||||
```python
|
||||
class torch.nn.ModuleDict(modules=None)
|
||||
```
|
||||
- **作用**：`torch.nn.ModuleDict` 是一个容器类，用于以字典形式存储多个 `nn.Module` 实例。类似于 Python 的内置 `dict`，但专为 PyTorch 的模块管理设计，存储的子模块会自动注册到父模块中。
|
||||
- **特性**：
|
||||
- **键值存储**：使用字符串键索引子模块，便于按名称访问。
|
||||
- **自动注册**：子模块会自动被 `model.modules()` 和 `model.parameters()` 识别。
|
||||
- **用途**：适合需要按名称管理子模块的场景，例如多任务学习或具有语义化模块的复杂模型。
|
||||
- **参数**：
|
||||
- `modules`：一个可选的可迭代对象，包含键值对（键为字符串，值为 `nn.Module` 实例）。
|
||||
|
||||
**示例**：
|
||||
```python
|
||||
class MyModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.layers = nn.ModuleDict({
|
||||
'layer1': nn.Linear(10, 10),
|
||||
'layer2': nn.Linear(10, 5)
|
||||
})
|
||||
|
||||
def forward(self, x):
|
||||
x = self.layers['layer1'](x)
|
||||
x = self.layers['layer2'](x)
|
||||
return x
|
||||
|
||||
model = MyModel()
|
||||
print(list(model.modules())) # 输出模型及其子模块
|
||||
```
|
||||
|
||||
### 2.2 方法讲解
|
||||
|
||||
`torch.nn.ModuleDict` 支持以下方法，主要继承自 Python 的 `dict`，并添加了 PyTorch 的模块管理特性。以下是所有方法的详细说明：
|
||||
|
||||
1. **`__setitem__(key, module)`**：
|
||||
- **作用**：向 `ModuleDict` 添加或更新一个键值对。
|
||||
- **参数**：
|
||||
- `key`：字符串，子模块的名称。
|
||||
- `module`：`nn.Module` 实例。
|
||||
- **示例**：
|
||||
```python
|
||||
module_dict = nn.ModuleDict()
|
||||
module_dict['layer1'] = nn.Linear(10, 10)
|
||||
print(module_dict['layer1']) # 输出线性层
|
||||
```
|
||||
|
||||
2. **`update([other])`**：
|
||||
- **作用**：使用另一个字典或键值对更新 `ModuleDict`。
|
||||
- **参数**：
|
||||
- `other`：一个字典或键值对的可迭代对象，值必须是 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
module_dict = nn.ModuleDict()
|
||||
module_dict.update({'layer1': nn.Linear(10, 10), 'layer2': nn.Linear(10, 5)})
|
||||
print(len(module_dict)) # 输出 2
|
||||
```
|
||||
|
||||
3. **索引操作（如 `__getitem__`）**：
|
||||
- **作用**：通过键访问 `ModuleDict` 中的子模块。
|
||||
- **参数**：
|
||||
- 键（字符串）。
|
||||
- **返回值**：对应的 `nn.Module`。
|
||||
- **示例**：
|
||||
```python
|
||||
print(module_dict['layer1']) # 访问 layer1 模块
|
||||
```
|
||||
|
||||
4. **迭代操作（如 `__iter__`, `keys()`, `values()`, `items()`）**：
|
||||
- **作用**：支持迭代键、值或键值对。
|
||||
- **返回值**：
|
||||
- `keys()`：返回所有键的迭代器。
|
||||
- `values()`：返回所有 `nn.Module` 的迭代器。
|
||||
- `items()`：返回键值对的迭代器。
|
||||
- **示例**：
|
||||
```python
|
||||
for key, module in module_dict.items():
|
||||
print(f"Key: {key}, Module: {module}")
|
||||
```
|
||||
|
||||
5. **长度查询（如 `__len__`）**：
|
||||
- **作用**：返回 `ModuleDict` 中子模块的数量。
|
||||
- **返回值**：整数。
|
||||
- **示例**：
|
||||
```python
|
||||
print(len(module_dict)) # 输出子模块数量
|
||||
```
|
||||
|
||||
6. **其他字典操作**：
|
||||
- `ModuleDict` 支持 Python 字典的常见方法，如 `pop(key)`, `clear()`, `popitem()`, `get(key, default=None)` 等。
|
||||
- **示例**（`pop`）：
|
||||
```python
|
||||
module_dict = nn.ModuleDict({'layer1': nn.Linear(10, 10), 'layer2': nn.Linear(10, 5)})
|
||||
removed_module = module_dict.pop('layer1') # 移除并返回 layer1
|
||||
print(len(module_dict)) # 输出 1
|
||||
```
|
||||
|
||||
### 2.3 注意事项
|
||||
|
||||
- **与普通 Python 字典的区别**：普通 Python 字典中的 `nn.Module` 不会自动注册到父模块，而 `ModuleDict` 会。
|
||||
- **与 `nn.ParameterDict` 的区别**：`ModuleDict` 存储 `nn.Module`，而 `nn.ParameterDict` 存储 `nn.Parameter`。
|
||||
- **键的唯一性**：`ModuleDict` 的键必须是字符串，且不能重复。
|
||||
- **优化器集成**：`ModuleDict` 中的子模块的参数会自动被 `model.parameters()` 包含。
|
||||
|
||||
---
|
||||
|
||||
## 3. 比较与使用场景
|
||||
|
||||
| 特性 | `ModuleList` | `ModuleDict` |
|
||||
|---------------------|-------------------------------------------|-------------------------------------------|
|
||||
| **存储方式** | 列表（按索引访问） | 字典（按键访问） |
|
||||
| **访问方式** | 索引（`module_list[0]`） | 键（`module_dict['key']`） |
|
||||
| **主要方法** | `append`, `extend`, `pop`, 索引操作 | `update`, `pop`, `keys`, `values`, `items` |
|
||||
| **适用场景** | 顺序模块管理（如多层堆叠的神经网络） | 命名模块管理（如多任务模型中的模块） |
|
||||
| **动态性** | 适合动态添加/移除模块 | 适合按名称管理模块 |
|
||||
|
||||
**选择建议**：
|
||||
- 如果子模块需要按顺序调用（如多层网络），使用 `ModuleList`。
|
||||
- 如果子模块需要按名称访问或具有明确语义（如多任务模型），使用 `ModuleDict`。
|
||||
|
||||
---
|
||||
|
||||
## 4. 综合示例
|
||||
|
||||
以下是一个结合 `ModuleList` 和 `ModuleDict` 的示例，展示它们在模型中的使用：
|
||||
|
||||
```python
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
class ComplexModel(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
# 使用 ModuleList 存储一组线性层
|
||||
self.list_layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(2)])
|
||||
# 使用 ModuleDict 存储命名模块
|
||||
self.dict_layers = nn.ModuleDict({
|
||||
'conv': nn.Conv2d(3, 64, kernel_size=3),
|
||||
'fc': nn.Linear(10, 5)
|
||||
})
|
||||
|
||||
def forward(self, x):
|
||||
# 使用 ModuleList
|
||||
for layer in self.list_layers:
|
||||
x = layer(x)
|
||||
# 使用 ModuleDict
|
||||
x = self.dict_layers['fc'](x)
|
||||
return x
|
||||
|
||||
model = ComplexModel()
|
||||
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
|
||||
|
||||
# 打印所有模块
|
||||
for name, module in model.named_modules():
|
||||
print(f"Module name: {name}, Module: {module}")
|
||||
|
||||
# 动态修改 ModuleList
|
||||
model.list_layers.append(nn.Linear(10, 10))
|
||||
|
||||
# 动态修改 ModuleDict
|
||||
model.dict_layers['new_fc'] = nn.Linear(5, 2)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 5. 常见问题与解答
|
||||
|
||||
1. **如何高效合并两个 `ModuleList`？**
|
||||
- 使用 `extend` 方法或解包方式：
|
||||
```python
|
||||
module_list = nn.ModuleList()
|
||||
module_list.extend(sub_list_1)
|
||||
module_list.extend(sub_list_2)
|
||||
# 或者
|
||||
module_list = nn.ModuleList([*sub_list_1, *sub_list_2])
|
||||
```
|
||||
|
||||
2. **如何从 `ModuleList` 删除模块？**
|
||||
- 使用 `pop(index)` 或重新构造列表：
|
||||
```python
|
||||
module_list.pop(0) # 移除第一个模块
|
||||
# 或者
|
||||
module_list = nn.ModuleList([module for i, module in enumerate(module_list) if i != 0])
|
||||
```
|
||||
|
||||
3. **如何检查 `ModuleDict` 中的模块？**
|
||||
- 使用 `keys()`, `values()`, 或 `items()` 遍历：
|
||||
```python
|
||||
for key, module in module_dict.items():
|
||||
print(f"Key: {key}, Module: {module}")
|
||||
```
|
||||
|
||||
4. **如何初始化子模块的参数？**
|
||||
- 使用 `nn.Module.apply` 或直接遍历：
|
||||
```python
|
||||
def init_weights(m):
|
||||
if isinstance(m, nn.Linear):
|
||||
nn.init.xavier_uniform_(m.weight)
|
||||
model.apply(init_weights)
|
||||
# 或者
|
||||
for module in module_list:
|
||||
if isinstance(module, nn.Linear):
|
||||
nn.init.xavier_uniform_(module.weight)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 6. 总结
|
||||
|
||||
- **`torch.nn.ModuleList`**：
|
||||
- 方法：`append`, `extend`, `pop`, 索引/迭代操作。
|
||||
- 特点：类似列表，适合顺序管理子模块，自动注册到父模块。
|
||||
- 场景：动态模型、多层堆叠网络。
|
||||
- **`torch.nn.ModuleDict`**：
|
||||
- 方法：`update`, `pop`, `keys`, `values`, `items`, 索引/迭代操作。
|
||||
- 特点：类似字典，适合按名称管理子模块，自动注册。
|
||||
- 场景：多任务学习、需要语义化命名的模型。
|
||||
|
||||
**参考文献**：
|
||||
- PyTorch 官方文档：`torch.nn.ModuleList` 和 `torch.nn.ModuleDict`（`docs.pytorch.org`）
|
||||
- Stack Overflow：合并 `ModuleList` 的讨论
|
||||
- PyTorch Forums：`ModuleList` 和 `ModuleDict` 的动态操作
|
||||
|
||||
如果需要更详细的代码示例、特定方法的实现，或其他相关问题（如与优化器或设备迁移的集成），请告诉我！
|
||||
Reference in New Issue
Block a user