TypeError: forward() missing 1 required positional argument: 'labels'
adnan119 opened this issue · comments
I've been following and making all the necessary changes required to run the lr_finder.range_test(). However, I'm still facing this error!
Here's my code defining the Dataset class:
class HappyWhaleDataset(Dataset):
def __init__(self, df, transforms=None):
self.df = df
self.file_names = df['file_path'].values
self.labels = df['individual_id'].values
self.transforms = transforms
def __len__(self):
return len(self.df)
def __getitem__(self, index):
img_path = self.file_names[index]
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
label = self.labels[index]
if self.transforms:
img = self.transforms(image=img)["image"]
return {
'image': img,
'label': torch.tensor(label, dtype=torch.long)
}
def prepare_loaders(df, fold):
df_train = df[df.kfold != fold].reset_index(drop=True)
df_valid = df[df.kfold == fold].reset_index(drop=True)
train_dataset = HappyWhaleDataset(df_train, transforms=data_transforms["train"])
valid_dataset = HappyWhaleDataset(df_valid, transforms=data_transforms["valid"])
train_loader = DataLoader(train_dataset, batch_size=CONFIG['train_batch_size'],
num_workers=2, shuffle=True, pin_memory=True, drop_last=True)
valid_loader = DataLoader(valid_dataset, batch_size=CONFIG['valid_batch_size'],
num_workers=2, shuffle=False, pin_memory=True)
return train_loader, valid_loader
train_loader, valid_loader = prepare_loaders(df, fold=0)
Note: Model training goes without error when I'm just creating a usual train_loader with the above code.
class CustomTrainIter(TrainDataLoaderIter):
def inputs_labels_from_batch(self, batch_data):
return batch_data["image"], batch_data["label"]
custom_loader = CustomTrainIter(train_loader)
lr_finder = LRFinder(model, optimizer, criterion, device=CONFIG['device'])
lr_finder.range_test(custom_loader, end_lr=1, num_iter=100, step_mode="linear")
lr_finder.plot(log_lr=False)
lr_finder.reset()
TypeError Traceback (most recent call last)
/tmp/ipykernel_34/1446799792.py in <module>
6
7 lr_finder = LRFinder(model, optimizer, criterion, device=CONFIG['device'])
----> 8 lr_finder.range_test(custom_loader, end_lr=1, num_iter=100, step_mode="linear")
9 lr_finder.plot(log_lr=False)
10 lr_finder.reset()
/opt/conda/lib/python3.7/site-packages/torch_lr_finder/lr_finder.py in range_test(self, train_loader, val_loader, start_lr, end_lr, num_iter, step_mode, smooth_f, diverge_th, accumulation_steps, non_blocking_transfer)
318 train_iter,
319 accumulation_steps,
--> 320 non_blocking_transfer=non_blocking_transfer,
321 )
322 if val_loader:
/opt/conda/lib/python3.7/site-packages/torch_lr_finder/lr_finder.py in _train_batch(self, train_iter, accumulation_steps, non_blocking_transfer)
375
376 # Forward pass
--> 377 outputs = self.model(inputs)
378 loss = self.criterion(outputs, labels)
379
/opt/conda/lib/python3.7/site-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() missing 1 required positional argument: 'labels'
Hi @adnan119,
Can you provide the function signature of forward() in your model class? It seems the forward() function is defined with at least 2 positional arguments (excluding self), e.g., def forward(self, inputs, labels):
We assume that forward() should accept only 1 argument by default, i.e., def forward(self, inputs):. And that's why you see the function call in traceback message like this:
/opt/conda/lib/python3.7/site-packages/torch_lr_finder/lr_finder.py in _train_batch(self, train_iter, accumulation_steps, non_blocking_transfer)
375
376 # Forward pass
--> 377 outputs = self.model(inputs)
378 loss = self.criterion(outputs, labels)
379
If that's the case, you can check out this approach to see whether it could help: #61 (comment)
Yes actually! The model architecture is indeed such that it requires labels to be passed in as Input outputs = model(images, labels) during the training phase.
Yeah! Glad that information helps.
You can update this thread if you have further questions regarding implementing that approach, I will get back to you when I have time.
Thanks for the help @NaleRaphael! However, there's still an issue. As I mentioned earlier the architecture is made such that it requires labels itself to be fed along with the input image into the neural net.
The solution you've linked to in issue #61 would work if another input was some embedding/image/some other value, but in my case, it's the label itself being fed into the network while training.
Which leads to the following error when using the script you've provided:
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
/tmp/ipykernel_34/929039027.py in <module>
20
21 lr_finder = LRFinder(model_wrap, optimizer, criterion, device=CONFIG['device'])
---> 22 lr_finder.range_test(custom_loader, end_lr=1, num_iter=100, step_mode="linear")
23 lr_finder.plot(log_lr=False)
24 lr_finder.reset()
/opt/conda/lib/python3.7/site-packages/torch_lr_finder/lr_finder.py in range_test(self, train_loader, val_loader, start_lr, end_lr, num_iter, step_mode, smooth_f, diverge_th, accumulation_steps, non_blocking_transfer)
318 train_iter,
319 accumulation_steps,
--> 320 non_blocking_transfer=non_blocking_transfer,
321 )
322 if val_loader:
/opt/conda/lib/python3.7/site-packages/torch_lr_finder/lr_finder.py in _train_batch(self, train_iter, accumulation_steps, non_blocking_transfer)
375
376 # Forward pass
--> 377 outputs = self.model(inputs)
378 loss = self.criterion(outputs, labels)
379
/opt/conda/lib/python3.7/site-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 = [], []
/tmp/ipykernel_34/929039027.py in forward(self, data)
11 def forward(self, data):
12 # Unpack data to the format you need
---> 13 img, labels = data
14 return self.model(img, labels)
15
ValueError: not enough values to unpack (expected 2, got 1)
I've tried a few different things to fix this but nothing seems to work, still got a lot to learn I guess😊
Got it! This actually can be achieved by modifying your CustomTrainIter slightly.
Here is the explanation. The following code snippet is how forward pass implemented in LRFinder._train_batch():
pytorch-lr-finder/torch_lr_finder/lr_finder.py
Lines 371 to 378 in acc5e7e
We can denote those variables with simpler ones. So here is the simplified code showing how the forward pass works:
# Desired format:
X, Y = next(train_iter)
outputs = self.model(X)
loss = self.criterion(outputs, Y)Since your model needs to get 2 input arguments: (images, labels), it means the X is actually a 2-value tuple (images, labels). So the code above can be written as below:
# Actual representation:
# Replace X with `(images, labels)`, and replace Y with `labels`
(images, labels), labels = next(train_iter)
outputs = self.model((images, labels))
loss = self.criterion(outputs, labels)Now we know that train_iter has to return (images, labels), labels in each iteration, so that means you can modify your CustomTrainIter as below:
class CustomTrainIter(TrainDataLoaderIter):
def inputs_labels_from_batch(self, batch_data):
images = batch_data["image"]
labels = batch_data["label"]
return (images, labels), labelsBut since your model takes 2 input arguments rather than 1, the invocation of your model.forward() in that forward pass does not meet the requirement now. Therefore, you have to create a wrapper for model to unpack the tuple ((images, labels)) into 2 variables. That is:
class ModelWrapper(nn.Module):
def __init__(self, model):
super().__init__()
self.model = model
def forward(self, inputs):
images, labels = inputs # unpack
outputs = self.model(images, labels)
return outputsThat's it! So this should be how LRFinder runs in your case:
custom_loader = CustomTrainIter(train_loader)
model_wrapper = ModelWrapper(your_model)
lr_finder = LRFinder(model_wrapper, optimizer, criterion, device=CONFIG['device'])
lr_finder.range_test(custom_loader, end_lr=1, num_iter=100, step_mode="linear")
lr_finder.plot(log_lr=False)
lr_finder.reset()Thanks a lot for your awesome explanation @NaleRaphael this really helped me get more clarity. return (images, labels), labels is the part I was missing. You did more than just help me solve the error! Best wishes with you.