Pytorch how and when to use Module Sequential ModuleList and ModuleDict

Pytorch: Module, Sequential, ModuleList 및 ModuleDict를 사용하는 방법과 시기

모델의 복잡성을 공유, 재사용 및 분해하는 효과적인 방법

Pytorch 1.5에서 업데이트됨

여기에서 코드를 찾을 수 있습니다.

Pytorch는 ML 모델을 생성하는 스마트한 방법을 제공하는 오픈 소스 딥 러닝 프레임워크입니다. 문서가 잘 작성되어 있어도 대부분의 사람들이 PyTorch에서 코드를 잘 짜여지지 않고 잘 작성하지 못하는 것을 볼 수 있습니다.

오늘은 PyTorch의 세 가지 주요 구성 요소인 Module, Sequential and ModuleList 사용하는 방법을 살펴보겠습니다. 우리는 예제로 시작하여 반복적으로 더 나은 예제를 만들 것입니다.

이 네 가지 클래스는 모두 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 컨버전 + 배치노름 + relu가 포함된 두 개의 레이어를 사용하는 인코딩 부분과 두 개의 선형 레이어가 포함된 디코딩 부분이 포함된 매우 간단한 분류기입니다. PyTorch를 처음 사용하는 사람이 아니라면 이전에 이러한 유형의 코딩을 본 적이 있을 수도 있지만 두 가지 문제가 있습니다.

레이어를 추가하려면 __init__ 및 forward 함수에 많은 코드를 다시 작성해야 합니다. 또한, 다른 모델(예: 3x3 전환 + 배치노름 + 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 함수를 가져와서 다른 모델에서 사용할 수 있습니다.

Dynamic Sequential: 한 번에 여러 레이어 생성

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 배열을 만듭니다. 각 레이어에 대해 부스 크기와 크기를 지정해야 하므로 크기 배열을 하나씩 이동하여 자체적으로 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 를 추가해야 했습니다.

이제 모델을 두 개로 나눌 수도 있습니다! 인코더 + 디코더

 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 을 반환하는 함수일 수도 있습니다. 나는 모델에 첫 번째 패턴을 사용하고 빌딩 블록에 두 번째 패턴을 사용하는 것을 선호합니다.

모듈을 하위 모듈로 나누면 코드를 공유 하고 디버깅 하고 테스트하는 것이 더 쉽습니다.

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 사용하세요.

그게 전부입니다!

읽어주셔서 감사합니다