AssertionError when running my model about alpha-beta-crown HOT 12 OPEN

def __init__(self):
    super(MModel, self).__init__()
    self.features = self._make_layer()
    self.linear1 = nn.Linear(512,100) 
    self.dropout = nn.Dropout(0.5) 
    self.linear2 = nn.Linear(100,10) 
    for m in self.modules():
        if isinstance(m, (nn.Conv2d, nn.Linear)):
            nn.init.xavier_normal_(m.weight,gain=1)
        elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
            nn.init.constant_(m.weight, 1)
            nn.init.constant_(m.bias, 0)

def _make_layer(self):
    layers = []
    in_planes=1 
    planes=32
    kernel_size=[3,2]
    pool_size = [2,2]
    padding = [1,1]
    stride = [1, 2]
    for i in range(3):
        if i!=0:
            in_planes=32
            kernel_size=[3,1]
            pool_size = [2,1]
            padding = [1,0]
            stride = [1,1]
        layers += [nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)]
        layers += [nn.BatchNorm2d(planes)]
        for j in range(4):
            layers += [nn.Conv2d(planes, planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)]
            layers += [nn.BatchNorm2d(planes)]
            layers += [nn.ReLU(inplace=True)]
        layers+=[nn.MaxPool2d(pool_size, stride=pool_size)]

    planes = 16
    kernel_size = [3, 1]
    pool_size = [2, 1]
    padding = [1, 0]
    stride = [2,1]
    layers += [nn.Conv2d(32, planes, kernel_size=1, bias=False)]
    layers += [nn.BatchNorm2d(planes)]
    layers += [nn.ReLU(inplace=True)]
    for k in range(2):
        layers += [nn.Conv2d(planes, planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)]
        layers += [nn.BatchNorm2d(planes)]
        layers += [nn.ReLU(inplace=True)]

    return nn.Sequential(*layers)

def forward(self,x):
    out = self.features(x)
    out = out.view(out.size(0), -1)
    out = F.relu(self.linear1(out))
    out = self.dropout(out)
    out = self.linear2(out)
    return out

class MModel(nn.Module):
  def __init__(self):
      super(MModel, self).__init__()
      self.features = self._make_layer()
      self.linear1 = nn.Linear(512,100) 
      self.dropout = nn.Dropout(0.5) 
      self.linear2 = nn.Linear(100,10) 
      for m in self.modules():
          if isinstance(m, (nn.Conv2d, nn.Linear)):
              nn.init.xavier_normal_(m.weight,gain=1)
          elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
              nn.init.constant_(m.weight, 1)
              nn.init.constant_(m.bias, 0)
  
  def _make_layer(self):
      layers = []
      in_planes=1 
      planes=32
      kernel_size=[3,2]
      pool_size = [2,2]
      padding = [1,1]
      stride = [1, 2]
      for i in range(3):
          if i!=0:
              in_planes=32
              kernel_size=[3,1]
              pool_size = [2,1]
              padding = [1,0]
              stride = [1,1]
          layers += [nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)]
          layers += [nn.BatchNorm2d(planes)]
          for j in range(4):
              layers += [nn.Conv2d(planes, planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)]
              layers += [nn.BatchNorm2d(planes)]
              layers += [nn.ReLU(inplace=True)]
          layers+=[nn.MaxPool2d(pool_size, stride=pool_size)]
  
      planes = 16
      kernel_size = [3, 1]
      pool_size = [2, 1]
      padding = [1, 0]
      stride = [2,1]
      layers += [nn.Conv2d(32, planes, kernel_size=1, bias=False)]
      layers += [nn.BatchNorm2d(planes)]
      layers += [nn.ReLU(inplace=True)]
      for k in range(2):
          layers += [nn.Conv2d(planes, planes, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)]
          layers += [nn.BatchNorm2d(planes)]
          layers += [nn.ReLU(inplace=True)]
  
      return nn.Sequential(*layers)
  
  def forward(self,x):
      out = self.features(x)
      out = out.view(out.size(0), -1)
      out = F.relu(self.linear1(out))
      out = self.dropout(out)
      out = self.linear2(out)
      return out

model:
  name: MModel
  path: models/MModel_ckpt.pth  
data:
  dataset: MM  
#  mean: [0.4914, 0.4822, 0.4465]  # Mean for normalization.
#  std: [0.2471, 0.2435, 0.2616]  # Std for normalization.
  start: 0  
  end: 40  
specification:
  norm: .inf  
  epsilon: 0.00784313725490196  
attack: 
  pgd_steps: 100  
  pgd_restarts: 30  
  pgd_order: skip

solver:
  batch_size: 2048  
  alpha-crown:
    iteration: 100 
    lr_alpha: 0.1   
  beta-crown:
    lr_alpha: 0.01  
    lr_beta: 0.05  
    iteration: 20  
  timeout: 120  
  branching:  
    reduceop: min  
    method: kfsb  
    candidates: 3  

[1,1,1024,2]

 python abcrown.py --config exp_configs/MModel.yaml --conv_mode patches

Traceback (most recent call last):
  File "/alpha-beta-CROWN-main/complete_verifier/abcrown.py", line 655, in <module>
    main()
  File "/alpha-beta-CROWN-main/complete_verifier/abcrown.py", line 543, in main
    incomplete_verifier(model_ori, x, data_ub=data_max, data_lb=data_min, vnnlib=vnnlib)
  File "/alpha-beta-CROWN-main/complete_verifier/abcrown.py", line 75, in incomplete_verifier
    _, global_lb, _, _, _, mask, lA, lower_bounds, upper_bounds, pre_relu_indices, slope, history, attack_images = model.build_the_model(
  File "/alpha-beta-CROWN-main/complete_verifier/beta_CROWN_solver.py", line 1068, in build_the_model
    lb, ub, aux_reference_bounds = self.net.init_slope(
  File "/alpha-beta-CROWN-main/complete_verifier/auto_LiRPA/optimized_bounds.py", line 1054, in init_slope
    node.init_opt_parameters(start_nodes)
  File "/alpha-beta-CROWN-main/complete_verifier/auto_LiRPA/operators/pooling.py", line 50, in init_opt_parameters
    self.alpha[ns] = torch.empty(
TypeError: empty(): argument 'size' must be tuple of ints, but found element of type torch.Size at pos 2