Hello, I have been trying to implement a small VGG network but run into this error. I have seen other posts with similar errors but none seem to match my case.
Here is the error message I am getting:
TypeError Traceback (most recent call last)
/content/drive/My Drive/Colab Projects/uvadlc_practicals_2020/assignment_1/1_mlp_cnn/code/train_convnet_pytorch.py in <module>()
206 FLAGS, unparsed = parser.parse_known_args()
207
--> 208 main()
6 frames
/content/drive/My Drive/Colab Projects/uvadlc_practicals_2020/assignment_1/1_mlp_cnn/code/train_convnet_pytorch.py in main()
186
187 # Run the training operation
--> 188 train()
189
190
/content/drive/My Drive/Colab Projects/uvadlc_practicals_2020/assignment_1/1_mlp_cnn/code/train_convnet_pytorch.py in train()
129 train_y = train_y.to(device)
130
--> 131 preds = model(train_x)
132 labels = train_y.argmax(dim=-1)
133
/usr/local/lib/python3.7/dist-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
1049 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
1050 or _global_forward_hooks or _global_forward_pre_hooks):
-> 1051 return forward_call(*input, **kwargs)
1052 # Do not call functions when jit is used
1053 full_backward_hooks, non_full_backward_hooks = [], []
/content/drive/My Drive/Colab Projects/uvadlc_practicals_2020/assignment_1/1_mlp_cnn/code/convnet_pytorch.py in forward(self, x)
151 #######################
152
--> 153 x = self.input_net(x)
154 x = self.blocks(x)
155 out = self.output_net(x)
/usr/local/lib/python3.7/dist-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
1049 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
1050 or _global_forward_hooks or _global_forward_pre_hooks):
-> 1051 return forward_call(*input, **kwargs)
1052 # Do not call functions when jit is used
1053 full_backward_hooks, non_full_backward_hooks = [], []
/usr/local/lib/python3.7/dist-packages/torch/nn/modules/container.py in forward(self, input)
137 def forward(self, input):
138 for module in self:
--> 139 input = module(input)
140 return input
141
/usr/local/lib/python3.7/dist-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
1049 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
1050 or _global_forward_hooks or _global_forward_pre_hooks):
-> 1051 return forward_call(*input, **kwargs)
1052 # Do not call functions when jit is used
1053 full_backward_hooks, non_full_backward_hooks = [], []
TypeError: forward() takes 1 positional argument but 2 were given
Following is my actual code:
class PreActResnetBlock(nn.Module):
def __init__(self, c_in, c_out, kernel=3, stride=1, padding=1):
super().__init__()
self.net = nn.Sequential(
nn.BatchNorm2d(c_in),
nn.ReLU(),
nn.Conv2d(c_in, c_out, kernel_size=kernel, padding=padding, stride=stride, bias=False)
)
def forward(x):
out = self.net(x)
out += x
class VGGBlock(nn.Module):
def __init__(self, c_in, c_out, last_block=False):
super().__init__()
layers = []
if not last_block:
layers.append(nn.Conv2d(c_in, c_out, kernel_size=1, padding=0, stride=1))
layers.extend([nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
PreActResnetBlock(c_out, c_out),
PreActResnetBlock(c_out, c_out)])
self.net = nn.Sequential(*layers)
def forward(x):
x = self.net(x)
return x
class ConvNet(nn.Module):
def __init__(self, n_channels, n_classes):
super().__init__()
self.hparams = SimpleNamespace(n_channels = n_channels,
n_classes = n_classes)
self._create_network()
def _create_network(self):
hidden_dims = [64, 128, 256, 512]
# Stemm to scale up the channel size
c_out = hidden_dims[0]
self.input_net = nn.Sequential(
nn.Conv2d(self.hparams.n_channels, c_out, kernel_size=3, padding=1, bias=False),
PreActResnetBlock(64, 64)
)
#VGGBlocks
blocks = []
for i in range(4):
if i == 3:
c_in = c_out = hidden_dims[-1]
blocks.append(VGGBlock(c_in, c_out, last_block=True))
break
c_in = hidden_dims[i]
c_out = hidden_dims[i+1]
blocks.append(VGGBlock(c_in, c_out))
self.blocks = nn.Sequential(*blocks)
# Mapping for classification head to target
self.output_net = nn.Sequential(
nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
nn.Linear(c_out, self.hparams.n_classes)
)
def forward(self, x):
x = self.input_net(x)
x = self.blocks(x)
out = self.output_net(x)
return out