Question

想知道，为什么我无法在torch.nn中找到subj？ nn.Sequential非常方便，它允许在一个地方定义网络，清晰可见，但仅限于非常简单的网络！借助并行模拟（以及残余连接的“身份”节点的利特尔帮助），它构成了构建任何前馈网络组合方式的完整方法。我想念什么吗？

Answer 1

好吧，也许不应该将其包含在标准模块集合中，只是因为它可以非常简单地定义：

class ParallelModule(nn.Sequential):
    def __init__(self, *args):
        super(ParallelModule, self).__init__( *args )

    def forward(self, input):
        output = []
        for module in self:
            output.append( module(input) )
        return torch.cat( output, dim=1 )

从“顺序”继承“并行”在思想上是不好的，但效果很好。现在，可以使用以下代码定义如图所示的网络：

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.net = nn.Sequential(
            nn.Conv2d(  1, 32, 3, padding=1 ),        nn.ReLU(),
            nn.Conv2d( 32, 64, 3, padding=1 ),        nn.ReLU(),
            nn.MaxPool2d( 3, stride=2 ),              nn.Dropout2d( 0.25 ),

            ParallelModule(
                nn.Conv2d(  64, 64, 1 ),
                nn.Sequential( 
                    nn.Conv2d(  64, 64, 1 ),          nn.ReLU(),
                    ParallelModule(
                        nn.Conv2d(  64, 32, (3,1), padding=(1,0) ),
                        nn.Conv2d(  64, 32, (1,3), padding=(0,1) ),
                    ),
                ),
                nn.Sequential( 
                    nn.Conv2d(  64, 64, 1 ),          nn.ReLU(),
                    nn.Conv2d(  64, 64, 3, padding=1 ), nn.ReLU(),
                    ParallelModule(
                        nn.Conv2d(  64, 32, (3,1), padding=(1,0) ),
                        nn.Conv2d(  64, 32, (1,3), padding=(0,1) ),
                    ),
                ),
                nn.Sequential( 
                    #PrinterModule(),
                    nn.AvgPool2d( 3, stride=1, padding=1 ),
                    nn.Conv2d(  64, 64, 1 ),
                ),
            ),
            nn.ReLU(),
            nn.Conv2d( 256, 64, 1 ),                  nn.ReLU(),

            nn.Conv2d( 64, 128, 3, padding=1 ),       nn.ReLU(),
            nn.MaxPool2d( 3, stride=2 ),              nn.Dropout2d( 0.5 ),
            nn.Flatten(),
            nn.Linear( 4608, 128 ),                   nn.ReLU(),
            nn.Linear(  128,  10 ),                   nn.LogSoftmax( dim=1 ),
        )

    def forward(self, x):
        return self.net.forward( x )

与torch.nn.Sequential容器的并行模拟

1 个答案: