[FIXED] ValueError: out_channels must be divisible by groups

Issue

I want to implement these three layers in a single class, but I face this problem

ValueError: out_channels must be divisible by groups I don't understand where is the mistake?!

THis is the code:

class Block(nn.Module):
def __init__(self, in_channels, out_channels, exp=1, stride=1, type=''):
    super().__init__()
    self.t = type
    self.stride = stride
    self.inc, self.outc = in_channels, out_channels
    self.exp = exp
    self.blockc = nn.Sequential(
        nn.Conv2d(self.inc, self.inc* self.exp, kernel_size=1),
        nn.ReLU(), 
        nn.Conv2d(self.inc * self.exp, self.outc, kernel_size=3, groups= self.inc * self.exp, stride= self.stride),
        nn.ReLU(),
        nn.Conv2d(self.outc, self.outc * self.exp, kernel_size=1),
        nn.Linear(self.outc * self.exp, self.outc * self.exp))

def forward(self, x):
    out = self.blockc(x)
    if self.t == 'A':
        out = torch.sum(out,x)
    return out

and here is the layers consists of depthwise convolution and conv 1x1 also there is a param exp which means out_channels = exp* in_channles

Solution

Here is a possible implementation, you will have to adjust the channels and padding for your needs:

class BType(Enum):
    A = 0
    B = 1
    C = 2

class Block(nn.Module):
    def __init__(self, c_in: int, c_out: int, btype: BType) -> nn.Module: 
        super().__init__()
        self.btype = btype

        if btype == BType.A:
            assert c_in == c_out

        self.c1 = nn.Sequential(
            nn.Conv2d(c_in, c_in, kernel_size=1),
            nn.ReLU())
        
        self.c2 = nn.Sequential(
            nn.Conv2d(c_in, c_in, kernel_size=3, groups=c_in,
                      stride=2 if btype == BType.C else 1,
                      padding=2 if btype == BType.C else 1),
            nn.ReLU())
        
        self.c3 = nn.Conv2d(c_in, c_out, kernel_size=1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        out = self.c1(x)
        out = self.c2(out)
        out = self.c3(out)

        if self.btype == BType.A:
            out += x
        return out

Here is a test with all three block types:

• block A:

  >>> block = Block(3, 3, BType.A)
  >>> block(torch.rand(2,3,10,10)).shape
  torch.Size([2, 3, 10, 10])
  

• block B:

  >>> block = Block(3, 10, BType.B)
  >>> block(torch.rand(2,3,10,10)).shape
  torch.Size([2, 10, 10, 10])
  

• block C:

  >>> block = Block(3, 10, BType.C)
  >>> block(torch.rand(2,3,10,10)).shape
  torch.Size([2, 10, 6, 6])
  

Answered By - Ivan