torch.nn.modules.container—PyTorch1.11.0documentationclassSequential(Module):
r"""A sequential container.    Modules will be added to it in the order they are passed in the    constructor. Alternatively, an ``OrderedDict`` of modules can be    passed in. The ``forward()`` method of ``Sequential`` accepts any    input and forwards it to the first module it contains. It then    "chains" outputs to inputs sequentially for each subsequent module,    finally returning the output of the last module.    The value a ``Sequential`` provides over manually calling a sequence    of modules is that it allows treating the whole container as a    single module, such that performing a transformation on the    ``Sequential`` applies to each of the modules it stores (which are    each a registered submodule of the ``Sequential``).    What's the difference between a ``Sequential`` and a    :class:`torch.nn.ModuleList`? A ``ModuleList`` is exactly what it    sounds like--a list for storing ``Module`` s! On the other hand,    the layers in a ``Sequential`` are connected in a cascading way.    Example::        # Using Sequential to create a small model. When `model` is run,        # input will first be passed to `Conv2d(1,20,5)`. The output of        # `Conv2d(1,20,5)` will be used as the input to the first        # `ReLU`; the output of the first `ReLU` will become the input        # for `Conv2d(20,64,5)`. Finally, the output of        # `Conv2d(20,64,5)` will be used as input to the second `ReLU`        model = nn.Sequential(                  nn.Conv2d(1,20,5),                  nn.ReLU(),                  nn.Conv2d(20,64,5),                  nn.ReLU()                )        # Using Sequential with OrderedDict. This is functionally the        # same as the above code        model = nn.Sequential(OrderedDict([                  ('conv1', nn.Conv2d(1,20,5)),                  ('relu1', nn.ReLU()),                  ('conv2', nn.Conv2d(20,64,5)),                  ('relu2', nn.ReLU())                ]))    """_modules: Dict[str, Module]  # type: ignore[assignment]@overloaddef__init__(self, *args: Module) ->None:
        ...
@overloaddef__init__(self, arg: 'OrderedDict[str, Module]') ->None:
        ...
def__init__(self, *args):
super(Sequential, self).__init__()
iflen(args) ==1andisinstance(args[0], OrderedDict):
forkey, moduleinargs[0].items():
self.add_module(key, module)
else:
foridx, moduleinenumerate(args):
self.add_module(str(idx), module)

def__init__(self, *args):
super(Sequential, self).__init__()
iflen(args) ==1andisinstance(args[0], OrderedDict):
forkey, moduleinargs[0].items():
self.add_module(key, module)
else:
foridx, moduleinenumerate(args):
self.add_module(str(idx), module)

importcollectionimporttorch.nnasnnnet2=nn.Sequential(collections.OrderedDict([
          ('fc1', nn.Linear(784, 256)),
          ('relu1', nn.ReLU()),
          ('fc2', nn.Linear(256, 10))
          ]))
print(net2)

importtorch.nnasnnnet=nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 10), 
        )
print(net)

classModuleList(Module):
r"""Holds submodules in a list.    :class:`~torch.nn.ModuleList` can be indexed like a regular Python list, but    modules it contains are properly registered, and will be visible by all    :class:`~torch.nn.Module` methods.    Args:        modules (iterable, optional): an iterable of modules to add    Example::        class MyModule(nn.Module):            def __init__(self):                super(MyModule, self).__init__()                self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])            def forward(self, x):                # ModuleList can act as an iterable, or be indexed using ints                for i, l in enumerate(self.linears):                    x = self.linears[i // 2](x) + l(x)                return x    """_modules: Dict[str, Module]  # type: ignore[assignment]def__init__(self, modules: Optional[Iterable[Module]] =None) ->None:
super(ModuleList, self).__init__()
ifmodulesisnotNone:
self+=modules

net=nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # # 类似List的append操作print(net[-1])  # 类似List的索引访问print(net)

classmodel(nn.Module):
def__init__(self, ...):
super().__init__()
self.modulelist= ...
    ...
defforward(self, x):
forlayerinself.modulelist:
x=layer(x)
returnx

classModuleDict(Module):
r"""Holds submodules in a dictionary.    :class:`~torch.nn.ModuleDict` can be indexed like a regular Python dictionary,    but modules it contains are properly registered, and will be visible by all    :class:`~torch.nn.Module` methods.    :class:`~torch.nn.ModuleDict` is an **ordered** dictionary that respects    * the order of insertion, and    * in :meth:`~torch.nn.ModuleDict.update`, the order of the merged      ``OrderedDict``, ``dict`` (started from Python 3.6) or another      :class:`~torch.nn.ModuleDict` (the argument to      :meth:`~torch.nn.ModuleDict.update`).    Note that :meth:`~torch.nn.ModuleDict.update` with other unordered mapping    types (e.g., Python's plain ``dict`` before Python version 3.6) does not    preserve the order of the merged mapping.    Args:        modules (iterable, optional): a mapping (dictionary) of (string: module)            or an iterable of key-value pairs of type (string, module)    Example::        class MyModule(nn.Module):            def __init__(self):                super(MyModule, self).__init__()                self.choices = nn.ModuleDict({                        'conv': nn.Conv2d(10, 10, 3),                        'pool': nn.MaxPool2d(3)                })                self.activations = nn.ModuleDict([                        ['lrelu', nn.LeakyReLU()],                        ['prelu', nn.PReLU()]                ])            def forward(self, x, choice, act):                x = self.choices[choice](x)                x = self.activations[act](x)                return x    """_modules: Dict[str, Module]  # type: ignore[assignment]def__init__(self, modules: Optional[Mapping[str, Module]] =None) ->None:
super(ModuleDict, self).__init__()
ifmodulesisnotNone:
self.update(modules)

net=nn.ModuleDict({
'linear': nn.Linear(784, 256),
'act': nn.ReLU(),
})
net['output'] =nn.Linear(256, 10) # 添加print(net['linear']) # 访问print(net.output)
print(net)