Prediction using Pytorch Lightning

[sraghavm]

predict_step is thrrows following error

AttributeError Traceback (most recent call last)
/tmp/ipykernel_5454/4136182478.py in
----> 1 predictions = trainer.predict(dataloaders=data_loader)

~/venv/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py in predict(self, model, dataloaders, datamodule, return_predictions, ckpt_path)
891 self.strategy._lightning_module = model
892 return call._call_and_handle_interrupt(
--> 893 self, self._predict_impl, model, dataloaders, datamodule, return_predictions, ckpt_path
894 )
895

~/venv/lib/python3.7/site-packages/pytorch_lightning/trainer/call.py in _call_and_handle_interrupt(trainer, trainer_fn, *args, **kwargs)
36 return trainer.strategy.launcher.launch(trainer_fn, *args, trainer=trainer, **kwargs)
37 else:
---> 38 return trainer_fn(*args, **kwargs)
39
40 except _TunerExitException:

~/venv/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py in _predict_impl(self, model, dataloaders, datamodule, return_predictions, ckpt_path)
936 self._predicted_ckpt_path = self.ckpt_path # TODO: remove in v1.8
937
--> 938 results = self._run(model, ckpt_path=self.ckpt_path)
939
940 assert self.state.stopped
...
--> 300 if input.dim() != 2 and input.dim() != 3:
301 raise ValueError(
302 "expected 2D or 3D input (got {}D input)".format(input.dim())

AttributeError: 'list' object has no attribute 'dim'``

[sraghavm]

lass SoftOrdering1DCNN(pl.LightningModule):

def __init__(self,input_dim, output_dim, sign_size=32, cha_input=16, cha_hidden=32, 
             K=2, dropout_input=0.2, dropout_hidden=0.2, dropout_output=0.2):
    super().__init__()

    hidden_size = sign_size*cha_input
    sign_size1 = sign_size
    sign_size2 = sign_size//2
    output_size = (sign_size//4) * cha_hidden

    self.hidden_size = hidden_size
    self.cha_input = cha_input
    self.cha_hidden = cha_hidden
    self.K = K
    self.sign_size1 = sign_size1
    self.sign_size2 = sign_size2
    self.output_size = output_size
    self.dropout_input = dropout_input
    self.dropout_hidden = dropout_hidden
    self.dropout_output = dropout_output
    self.save_hyperparameters()
    self.batch_norm1 = nn.BatchNorm1d(input_dim)
    self.dropout1 = nn.Dropout(dropout_input)
    dense1 = nn.Linear(input_dim, hidden_size, bias=False)
    self.dense1 = nn.utils.weight_norm(dense1)
    self.accuracy = Accuracy(task='binary',average=None,num_classes=2)
    self.mcc = MatthewsCorrCoef(task='binary',average=None,num_classes=2)
    self.prec = Precision(task='binary',average=None,num_classes=2)
    self.recall = Recall(task='binary',average=None,num_classes=2)
    self.precm = Precision(task='binary',average='Macro',num_classes=2)
    self.example_input_array = torch.randn(1,len(input_features))
    
    

    # 1st conv layer
    self.batch_norm_c1 = nn.BatchNorm1d(cha_input)
    conv1 = conv1 = nn.Conv1d(
        cha_input, 
        cha_input*K, 
        kernel_size=5, 
        stride = 1, 
        padding=2,  
        groups=cha_input, 
        bias=False)
    self.conv1 = nn.utils.weight_norm(conv1, dim=None)

    self.ave_po_c1 = nn.AdaptiveAvgPool1d(output_size = sign_size2)

    # 2nd conv layer
    self.batch_norm_c2 = nn.BatchNorm1d(cha_input*K)
    self.dropout_c2 = nn.Dropout(dropout_hidden)
    conv2 = nn.Conv1d(
        cha_input*K, 
        cha_hidden, 
        kernel_size=3, 
        stride=1, 
        padding=1, 
        bias=False)
    self.conv2 = nn.utils.weight_norm(conv2, dim=None)

    # 3rd conv layer
    self.batch_norm_c3 = nn.BatchNorm1d(cha_hidden)
    self.dropout_c3 = nn.Dropout(dropout_hidden)
    conv3 = nn.Conv1d(
        cha_hidden, 
        cha_hidden, 
        kernel_size=3, 
        stride=1, 
        padding=1, 
        bias=False)
    self.conv3 = nn.utils.weight_norm(conv3, dim=None)
    

    # 4th conv layer
    self.batch_norm_c4 = nn.BatchNorm1d(cha_hidden)
    conv4 = nn.Conv1d(
        cha_hidden, 
        cha_hidden, 
        kernel_size=5, 
        stride=1, 
        padding=2, 
        groups=cha_hidden, 
        bias=False)
    self.conv4 = nn.utils.weight_norm(conv4, dim=None)

    self.avg_po_c4 = nn.AvgPool1d(kernel_size=4, stride=2, padding=1)

    self.flt = nn.Flatten()

    self.batch_norm2 = nn.BatchNorm1d(output_size)
    self.dropout2 = nn.Dropout(dropout_output)
    dense2 = nn.Linear(output_size, output_dim, bias=False)
    self.dense2 = nn.utils.weight_norm(dense2)

    self.loss = nn.BCEWithLogitsLoss()

def forward(self, x):
    x = self.batch_norm1(x)
    x = self.dropout1(x)
    x = nn.functional.celu(self.dense1(x))

    x = x.reshape(x.shape[0], self.cha_input, self.sign_size1)

    x = self.batch_norm_c1(x)
    x = nn.functional.relu(self.conv1(x))

    x = self.ave_po_c1(x)

    x = self.batch_norm_c2(x)
    x = self.dropout_c2(x)
    x = nn.functional.relu(self.conv2(x))
    x_s = x

    x = self.batch_norm_c3(x)
    x = self.dropout_c3(x)
    x = nn.functional.relu(self.conv3(x))

    x = self.batch_norm_c4(x)
    x = self.conv4(x)
    x =  x + x_s
    x = nn.functional.relu(x)

    x = self.avg_po_c4(x)

    x = self.flt(x)

    x = self.batch_norm2(x)
    x = self.dropout2(x)
    x = self.dense2(x)

    return x

def training_step(self, batch, batch_idx):
    X, y = batch
    y_hat = self.forward(X)
    #labels = torch.argmax(y_hat, 1)
    loss = self.loss(y_hat, y)
    self.log('train_loss', loss)
    
    
    
    
    return loss

def validation_step(self, batch, batch_idx):
    X, y = batch
    y_hat = self.forward(X)
    loss = self.loss(y_hat, y)
    self.log('valid_loss', loss)
    
def test_step(self, batch, batch_idx):
    X, y = batch
    y_logit = self.forward(X)
    y_probs = torch.sigmoid(y_logit).detach().cpu().numpy()
    loss = self.loss(y_logit, y)
    metric1 = roc_auc_score(y.cpu().numpy(), y_probs,average=None)
    metric2 = self.accuracy(y_logit,y)
    metric3 = self.mcc(y_logit,y)
    metric4 = self.prec(y_logit,y)
    metric5 =self.recall(y_logit,y)
    metric6 = self.precm(y_logit,y)
    
    self.log('test_loss', loss)
    self.log('Accuracy', metric2)
    self.log('AUROC', metric1)
    self.log('MCC',metric3)
    self.log('Precision',metric4)
    self.log('Recall',metric5)
    self.log('Macro Precision',metric6)
    
def predict_step(self, batch, batch_idx, dataloader_idx=0):
    return self(batch)


    
def configure_optimizers(self):
    optimizer = torch.optim.Adam(self.parameters(), lr=1e-2)
    scheduler = {
        'scheduler': ReduceLROnPlateau(
            optimizer, 
            mode="min", 
            factor=0.5, 
            patience=50, 
            min_lr=1e-5),
        'interval': 'epoch',
        'frequency': 1,
        'reduce_on_plateau': True,
        'monitor': 'valid_loss',
    }
    return [optimizer], [scheduler]

This is my my Network. Everything is running fine - train, test etc. But predict_step not working

[sraghavm]

https://colab.research.google.com/drive/1E6YRUfGIbyFrlivR6iKTRa398yTT771m?authuser=1#scrollTo=RNcxdMKNISli

This is the link to Google colab file. Please help me understand this issue