Pytorch how and when to use Module Sequential ModuleList and ModuleDict

Pytorch: Module、Sequential、ModuleList、ModuleDict をいつどのように使用するか

モデルの複雑さを共有、再利用、分解する効果的な方法

Pytorch 1.5 で更新されました

ここでコードを見つけることができます

Pytorch は、ML モデルを作成するスマートな方法を提供するオープンソースの深層学習フレームワークです。たとえドキュメントがきちんと作られていたとしても、ほとんどの人は PyTorch でうまく整理されたコードを書いていないことがわかります。

今日は、PyTorch の 3 つの主要な構成要素であるModule, Sequential and ModuleListの使用方法を見ていきます。まずは例から始めて、繰り返して改善していきます。

これら 4 つのクラスはすべてtorch.nnに含まれています

 import torch . nn as nn

# nn.Module
# nn.Sequential
# nn.Module 

モジュール: 主要な構成要素

モジュールは主要な構成要素であり、すべてのニューラル ネットワークの基本クラスを定義するため、それをサブクラス化する必要があります。

例として、古典的な CNN 分類器を作成してみましょう。

 import torch . nn . functional as F

class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , n_classes ):
        super (). __init__ ()
        self . conv1 = nn . Conv2d ( in_c , 32 , kernel_size = 3 , stride = 1 , padding = 1 )
        self . bn1 = nn . BatchNorm2d ( 32 )
        
        self . conv2 = nn . Conv2d ( 32 , 64 , kernel_size = 3 , stride = 1 , padding = 1 )
        self . bn2 = nn . BatchNorm2d ( 64 )

        self . fc1 = nn . Linear ( 64 * 28 * 28 , 1024 )
        self . fc2 = nn . Linear ( 1024 , n_classes )
        
    def forward ( self , x ):
        x = self . conv1 ( x )
        x = self . bn1 ( x )
        x = F . relu ( x )
        
        x = self . conv2 ( x )
        x = self . bn2 ( x )
        x = F . relu ( x )

        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . fc1 ( x )
        x = F . sigmoid ( x )
        x = self . fc2 ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , 10 )
print ( model )

 MyCNNClassifier(
  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (fc1): Linear(in_features=50176, out_features=1024, bias=True)
  (fc2): Linear(in_features=1024, out_features=10, bias=True)
)

これは、3x3 convs + patchnorm + relu の 2 つの層を使用するエンコード部分と、2 つの線形層を含むデコード部分を備えた非常に単純な分類器です。 PyTorch を初めて使用する場合は、このタイプのコーディングを以前に見たことがあるかもしれませんが、2 つの問題があります。

レイヤーを追加したい場合は、 __init__とforward関数に再び大量のコードを記述する必要があります。また、別のモデルで使用したい共通のブロックがある場合 (例: 3x3 conv + patchnorm + relu)、それを再度作成する必要があります。

シーケンシャル: レイヤーをスタックしてマージします

Sequential は、積み重ねて同時に実行できるモジュールのコンテナです。

すべてをself中に蓄えなければならないことに気づくでしょう。 Sequential使用してコードを改善できます。

 class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , n_classes ):
        super (). __init__ ()
        self . conv_block1 = nn . Sequential (
            nn . Conv2d ( in_c , 32 , kernel_size = 3 , stride = 1 , padding = 1 ),
            nn . BatchNorm2d ( 32 ),
            nn . ReLU ()
        )
        
        self . conv_block2 = nn . Sequential (
            nn . Conv2d ( 32 , 64 , kernel_size = 3 , stride = 1 , padding = 1 ),
            nn . BatchNorm2d ( 64 ),
            nn . ReLU ()
        )
        
        self . decoder = nn . Sequential (
            nn . Linear ( 64 * 28 * 28 , 1024 ),
            nn . Sigmoid (),
            nn . Linear ( 1024 , n_classes )
        )

        
    def forward ( self , x ):
        x = self . conv_block1 ( x )
        x = self . conv_block2 ( x )

        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , 10 )
print ( model )

 MyCNNClassifier(
  (conv_block1): Sequential(
    (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (conv_block2): Sequential(
    (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (decoder): Sequential(
    (0): Linear(in_features=50176, out_features=1024, bias=True)
    (1): Sigmoid()
    (2): Linear(in_features=1024, out_features=10, bias=True)
  )
)

ずっと良くなりましたね？

conv_block1とconv_block2ほぼ同じに見えることに気づきましたか? nn.Sequentialを返す関数を作成してコードを簡素化することもできます。

 def conv_block ( in_f , out_f , * args , ** kwargs ):
    return nn . Sequential (
        nn . Conv2d ( in_f , out_f , * args , ** kwargs ),
        nn . BatchNorm2d ( out_f ),
        nn . ReLU ()
    )

その後、モジュール内でこの関数を呼び出すだけです。

 class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , n_classes ):
        super (). __init__ ()
        self . conv_block1 = conv_block ( in_c , 32 , kernel_size = 3 , padding = 1 )
        
        self . conv_block2 = conv_block ( 32 , 64 , kernel_size = 3 , padding = 1 )

        
        self . decoder = nn . Sequential (
            nn . Linear ( 64 * 28 * 28 , 1024 ),
            nn . Sigmoid (),
            nn . Linear ( 1024 , n_classes )
        )

        
    def forward ( self , x ):
        x = self . conv_block1 ( x )
        x = self . conv_block2 ( x )

        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , 10 )
print ( model )

 MyCNNClassifier(
  (conv_block1): Sequential(
    (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (conv_block2): Sequential(
    (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (decoder): Sequential(
    (0): Linear(in_features=50176, out_features=1024, bias=True)
    (1): Sigmoid()
    (2): Linear(in_features=1024, out_features=10, bias=True)
  )
)

さらにきれいに！それでもconv_block1とconv_block2はほぼ同じです。 nn.Sequential使用してそれらをマージできます。

 class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , n_classes ):
        super (). __init__ ()
        self . encoder = nn . Sequential (
            conv_block ( in_c , 32 , kernel_size = 3 , padding = 1 ),
            conv_block ( 32 , 64 , kernel_size = 3 , padding = 1 )
        )

        
        self . decoder = nn . Sequential (
            nn . Linear ( 64 * 28 * 28 , 1024 ),
            nn . Sigmoid (),
            nn . Linear ( 1024 , n_classes )
        )

        
    def forward ( self , x ):
        x = self . encoder ( x )
        
        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , 10 )
print ( model )

 MyCNNClassifier(
  (encoder): Sequential(
    (0): Sequential(
      (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (1): Sequential(
      (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
  )
  (decoder): Sequential(
    (0): Linear(in_features=50176, out_features=1024, bias=True)
    (1): Sigmoid()
    (2): Linear(in_features=1024, out_features=10, bias=True)
  )
)

self.encoderブースconv_block保持するようになりました。モデルのロジックを分離し、読みやすく再利用しやすくしました。 conv_block関数は、別のモデルにインポートして使用できます。

ダイナミック シーケンシャル: 複数のレイヤーを一度に作成します

self.encoderに新しいレイヤーを追加できるとしたらどうしますか。ハードコーディングするのは不便です。

 self . encoder = nn . Sequential (
            conv_block ( in_c , 32 , kernel_size = 3 , padding = 1 ),
            conv_block ( 32 , 64 , kernel_size = 3 , padding = 1 ),
            conv_block ( 64 , 128 , kernel_size = 3 , padding = 1 ),
            conv_block ( 128 , 256 , kernel_size = 3 , padding = 1 ),

        )

サイズを配列として定義して、各レイヤーを記述することなくすべてのレイヤーを自動的に作成できたら便利ですよね?幸いなことに、配列を作成してSequentialに渡すことができます。

 class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , n_classes ):
        super (). __init__ ()
        self . enc_sizes = [ in_c , 32 , 64 ]
        
        conv_blocks = [ conv_block ( in_f , out_f , kernel_size = 3 , padding = 1 ) 
                       for in_f , out_f in zip ( self . enc_sizes , self . enc_sizes [ 1 :])]
        
        self . encoder = nn . Sequential ( * conv_blocks )

        
        self . decoder = nn . Sequential (
            nn . Linear ( 64 * 28 * 28 , 1024 ),
            nn . Sigmoid (),
            nn . Linear ( 1024 , n_classes )
        )

        
    def forward ( self , x ):
        x = self . encoder ( x )
        
        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , 10 )
print ( model )

 MyCNNClassifier(
  (encoder): Sequential(
    (0): Sequential(
      (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (1): Sequential(
      (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
  )
  (decoder): Sequential(
    (0): Linear(in_features=50176, out_features=1024, bias=True)
    (1): Sigmoid()
    (2): Linear(in_features=1024, out_features=10, bias=True)
  )
)

分解してみましょう。エンコーダーのサイズを保持する配列self.enc_sizesを作成しました。次に、サイズを反復して配列conv_blocksを作成します。ブースに各レイヤーのイン サイズとアウトサイズを指定する必要があるため、size 配列を 1 つずらしてそれ自体でzip圧縮しました。

明確にするために、次の例を見てください。

 sizes = [ 1 , 32 , 64 ]

for in_f , out_f in zip ( sizes , sizes [ 1 :]):
    print ( in_f , out_f )

 1 32
32 64

次に、 Sequentialリストを受け入れないため、 *演算子を使用してリストを分解します。

タダ！サイズを追加したいだけの場合は、リストに新しい数値を簡単に追加できます。サイズをパラメータにするのが一般的です。

 class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , enc_sizes , n_classes ):
        super (). __init__ ()
        self . enc_sizes = [ in_c , * enc_sizes ]
        
        conv_blocks = [ conv_block ( in_f , out_f , kernel_size = 3 , padding = 1 ) 
                       for in_f , out_f in zip ( self . enc_sizes , self . enc_sizes [ 1 :])]
        
        self . encoder = nn . Sequential ( * conv_blocks )

        
        self . decoder = nn . Sequential (
            nn . Linear ( 64 * 28 * 28 , 1024 ),
            nn . Sigmoid (),
            nn . Linear ( 1024 , n_classes )
        )

        
    def forward ( self , x ):
        x = self . encoder ( x )
        
        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , [ 32 , 64 , 128 ], 10 )
print ( model )

 MyCNNClassifier(
  (encoder): Sequential(
    (0): Sequential(
      (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (1): Sequential(
      (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (2): Sequential(
      (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
  )
  (decoder): Sequential(
    (0): Linear(in_features=50176, out_features=1024, bias=True)
    (1): Sigmoid()
    (2): Linear(in_features=1024, out_features=10, bias=True)
  )
)

デコーダ部分でも同じことができます

 def dec_block ( in_f , out_f ):
    return nn . Sequential (
        nn . Linear ( in_f , out_f ),
        nn . Sigmoid ()
    )

class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , enc_sizes , dec_sizes ,  n_classes ):
        super (). __init__ ()
        self . enc_sizes = [ in_c , * enc_sizes ]
        self . dec_sizes = [ 64 * 28 * 28 , * dec_sizes ]

        conv_blocks = [ conv_block ( in_f , out_f , kernel_size = 3 , padding = 1 ) 
                       for in_f , out_f in zip ( self . enc_sizes , self . enc_sizes [ 1 :])]
        
        self . encoder = nn . Sequential ( * conv_blocks )

        
        dec_blocks = [ dec_block ( in_f , out_f ) 
                       for in_f , out_f in zip ( self . dec_sizes , self . dec_sizes [ 1 :])]
        
        self . decoder = nn . Sequential ( * dec_blocks )
        
        self . last = nn . Linear ( self . dec_sizes [ - 1 ], n_classes )

        
    def forward ( self , x ):
        x = self . encoder ( x )
        
        x = x . view ( x . size ( 0 ), - 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , [ 32 , 64 ], [ 1024 , 512 ], 10 )
print ( model )

 MyCNNClassifier(
  (encoder): Sequential(
    (0): Sequential(
      (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
    (1): Sequential(
      (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
    )
  )
  (decoder): Sequential(
    (0): Sequential(
      (0): Linear(in_features=50176, out_features=1024, bias=True)
      (1): Sigmoid()
    )
    (1): Sequential(
      (0): Linear(in_features=1024, out_features=512, bias=True)
      (1): Sigmoid()
    )
  )
  (last): Linear(in_features=512, out_features=10, bias=True)
)

同じパターンに従い、デコード部分に線形 + シグモイドの新しいブロックを作成し、サイズを含む配列を渡します。出力をアクティブにしたくないため、 self.lastを追加する必要がありました。

これで、モデルを 2 つに分解することもできます。エンコーダー + デコーダー

 class MyEncoder ( nn . Module ):
    def __init__ ( self , enc_sizes ):
        super (). __init__ ()
        self . conv_blocks = nn . Sequential ( * [ conv_block ( in_f , out_f , kernel_size = 3 , padding = 1 ) 
                       for in_f , out_f in zip ( enc_sizes , enc_sizes [ 1 :])])

        def forward ( self , x ):
            return self . conv_blocks ( x )
        
class MyDecoder ( nn . Module ):
    def __init__ ( self , dec_sizes , n_classes ):
        super (). __init__ ()
        self . dec_blocks = nn . Sequential ( * [ dec_block ( in_f , out_f ) 
                       for in_f , out_f in zip ( dec_sizes , dec_sizes [ 1 :])])
        self . last = nn . Linear ( dec_sizes [ - 1 ], n_classes )

    def forward ( self , x ):
        return self . dec_blocks ()
    
    
class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , enc_sizes , dec_sizes ,  n_classes ):
        super (). __init__ ()
        self . enc_sizes = [ in_c , * enc_sizes ]
        self . dec_sizes = [ self . enc_sizes [ - 1 ] * 28 * 28 , * dec_sizes ]

        self . encoder = MyEncoder ( self . enc_sizes )
        
        self . decoder = MyDecoder ( self . dec_sizes , n_classes )
        
    def forward ( self , x ):
        x = self . encoder ( x )
        
        x = x . flatten ( 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , [ 32 , 64 ], [ 1024 , 512 ], 10 )
print ( model )

 MyCNNClassifier(
  (encoder): MyEncoder(
    (conv_blocks): Sequential(
      (0): Sequential(
        (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU()
      )
      (1): Sequential(
        (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU()
      )
    )
  )
  (decoder): MyDecoder(
    (dec_blocks): Sequential(
      (0): Sequential(
        (0): Linear(in_features=50176, out_features=1024, bias=True)
        (1): Sigmoid()
      )
      (1): Sequential(
        (0): Linear(in_features=1024, out_features=512, bias=True)
        (1): Sigmoid()
      )
    )
    (last): Linear(in_features=512, out_features=10, bias=True)
  )
)

MyEncoderとMyDecoder nn.Sequential返す関数である可能性があることに注意してください。私は最初のパターンをモデルに使用し、2 番目のパターンをビルディング ブロックに使用することを好みます。

モジュールをサブモジュールに分割すると、コードの共有、デバッグ、テストが容易になります。

ModuleList : 反復処理が必要な場合

ModuleList使用すると、 Moduleリストとして保存できます。 U-net のように、レイヤーを反復処理して情報を保存/使用する必要がある場合に便利です。

Sequentialとの主な違いは、 ModuleList forwardメソッドがないため、内部層が接続されていないことです。デコーダの各層の各出力が必要であると仮定すると、次のようにして保存できます。

 class MyModule ( nn . Module ):
    def __init__ ( self , sizes ):
        super (). __init__ ()
        self . layers = nn . ModuleList ([ nn . Linear ( in_f , out_f ) for in_f , out_f in zip ( sizes , sizes [ 1 :])])
        self . trace = []
        
    def forward ( self , x ):
        for layer in self . layers :
            x = layer ( x )
            self . trace . append ( x )
        return x 

 model = MyModule ([ 1 , 16 , 32 ])
import torch

model ( torch . rand (( 4 , 1 )))

[ print ( trace . shape ) for trace in model . trace ]

 torch.Size([4, 16])
torch.Size([4, 32])





[None, None]

ModuleDict: 選択する必要がある場合

conv_blockでLearkyReluに切り替えたい場合はどうすればよいでしょうか? ModuleDict使用してModuleの辞書を作成し、必要に応じてModule動的に切り替えることができます。

 def conv_block ( in_f , out_f , activation = 'relu' , * args , ** kwargs ):
    
    activations = nn . ModuleDict ([
                [ 'lrelu' , nn . LeakyReLU ()],
                [ 'relu' , nn . ReLU ()]
    ])
    
    return nn . Sequential (
        nn . Conv2d ( in_f , out_f , * args , ** kwargs ),
        nn . BatchNorm2d ( out_f ),
        activations [ activation ]
    )

 print ( conv_block ( 1 , 32 , 'lrelu' , kernel_size = 3 , padding = 1 ))
print ( conv_block ( 1 , 32 , 'relu' , kernel_size = 3 , padding = 1 ))

 Sequential(
  (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): LeakyReLU(negative_slope=0.01)
)
Sequential(
  (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU()
)

最終実装

すべてをまとめてみましょう！

 def conv_block ( in_f , out_f , activation = 'relu' , * args , ** kwargs ):
    activations = nn . ModuleDict ([
                [ 'lrelu' , nn . LeakyReLU ()],
                [ 'relu' , nn . ReLU ()]
    ])
    
    return nn . Sequential (
        nn . Conv2d ( in_f , out_f , * args , ** kwargs ),
        nn . BatchNorm2d ( out_f ),
        activations [ activation ]
    )

def dec_block ( in_f , out_f ):
    return nn . Sequential (
        nn . Linear ( in_f , out_f ),
        nn . Sigmoid ()
    )

class MyEncoder ( nn . Module ):
    def __init__ ( self , enc_sizes , * args , ** kwargs ):
        super (). __init__ ()
        self . conv_blocks = nn . Sequential ( * [ conv_block ( in_f , out_f , kernel_size = 3 , padding = 1 , * args , ** kwargs ) 
                       for in_f , out_f in zip ( enc_sizes , enc_sizes [ 1 :])])
        
        def forward ( self , x ):
            return self . conv_blocks ( x )
        
class MyDecoder ( nn . Module ):
    def __init__ ( self , dec_sizes , n_classes ):
        super (). __init__ ()
        self . dec_blocks = nn . Sequential ( * [ dec_block ( in_f , out_f ) 
                       for in_f , out_f in zip ( dec_sizes , dec_sizes [ 1 :])])
        self . last = nn . Linear ( dec_sizes [ - 1 ], n_classes )

    def forward ( self , x ):
        return self . dec_blocks ()
    
    
class MyCNNClassifier ( nn . Module ):
    def __init__ ( self , in_c , enc_sizes , dec_sizes ,  n_classes , activation = 'relu' ):
        super (). __init__ ()
        self . enc_sizes = [ in_c , * enc_sizes ]
        self . dec_sizes = [ 32 * 28 * 28 , * dec_sizes ]

        self . encoder = MyEncoder ( self . enc_sizes , activation = activation )
        
        self . decoder = MyDecoder ( dec_sizes , n_classes )
        
    def forward ( self , x ):
        x = self . encoder ( x )
        
        x = x . flatten ( 1 ) # flat
        
        x = self . decoder ( x )
        
        return x 

 model = MyCNNClassifier ( 1 , [ 32 , 64 ], [ 1024 , 512 ], 10 , activation = 'lrelu' )
print ( model )

 MyCNNClassifier(
  (encoder): MyEncoder(
    (conv_blocks): Sequential(
      (0): Sequential(
        (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): LeakyReLU(negative_slope=0.01)
      )
      (1): Sequential(
        (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): LeakyReLU(negative_slope=0.01)
      )
    )
  )
  (decoder): MyDecoder(
    (dec_blocks): Sequential(
      (0): Sequential(
        (0): Linear(in_features=1024, out_features=512, bias=True)
        (1): Sigmoid()
      )
    )
    (last): Linear(in_features=512, out_features=10, bias=True)
  )
)

結論

ということで、要約すると。

• 大きなブロックを複数の小さなブロックで構成する場合は、 Moduleを使用します。
• レイヤーから小さなブロックを作成する場合はSequentialを使用します。
• いくつかのレイヤーまたはビルディングブロックを反復処理して何かを行う必要がある場合は、 ModuleListを使用します。
• モデルの一部のブロック (活性化関数など) をパラメータ化する必要がある場合は、 ModuleDict使用します。

以上です！

読んでいただきありがとうございます