validation_step not running

[GuptaVishu2002]

The validation_step does not run and I get the following error
RuntimeError: Early stopping conditioned on metric val_losswhich is not available. Pass in or modify yourEarlyStoppingcallback to use any of the following:train_loss``
when I try run pytorch lightning model with following components

train.py

trainer.fit(
            model = msdecipher, 
            datamodule = msdecipher_data,
            ckpt_path = pretrained_model_path
            )

data.py

class MSDecipherDataModule(L.LightningDataModule):
    def __init__(
            self, 
            a, 
            b
            ):
        
        super().__init__()
        self.a = a
        self.b = b


    def setup(self, stage: str):
        train_df, val_df, test_df = train_val_test_split(self.a, self.b)

        if stage == 'fit':
            if self.augment == "True":
                self.train_df = [item for item in train_df for _ in range(a=a, b=b)]
            else:
                self.train_df = train_df

            self.val_df = val_df    


        if stage == 'test':
            self.test_df = test_df


        if stage == 'predict':
            self.test_df = [item for item in test_df for _ in range(self.augment_sample_number)]
            

    def train_dataloader(self):
        return DataLoader(
            self.train_df, 
            batch_size=self.batch_size, 
            shuffle=True,
            drop_last=False
            )

    def val_dataloader(self):
        return DataLoader(
            self.val_df, 
            batch_size=self.batch_size, 
            shuffle=False,
            drop_last=False
            )

    def test_dataloader(self):
        return DataLoader(
            self.test_df, 
            batch_size=self.batch_size, 
            shuffle=False,
            drop_last=False
            )

    def predict_dataloader(self):
        return DataLoader(
            self.test_df, 
            batch_size=self.batch_size, 
            shuffle=False,
            drop_last=False
            )

model.py

class MSDecipher(L.LightningModule):

    def __init__(
            self, 
            w,
            x,
            y,
            z
            ):
        
        super().__init__()
        self.save_hyperparameters()

            
     self.residual_out = ResidualNetwork(
                input_dim =w, 
                output_dim = x, 
                hidden_layer_dims = y, 
                activation=z,
                batchnorm=True
                )    

    def configure_optimizers(self):

        optimizer = torch.optim.Adam(
                            self.parameters(), 
                            lr=self.learning_rate,
                            weight_decay=1e-5
                            )

        return optimizer


    def training_step(self, batch, batch_idx):
        # training_step defines the train loop.
        # it is independent of forward

        full_rep, y = batch

        fea_out = self.residual_out(full_rep)

        loss =  self.loss(fea_out, y)
        # Logging to TensorBoard (if installed) by default
        self.log("train_loss", loss, prog_bar=True, on_step=False, on_epoch=True)

        return loss    

    def validation_step(self, batch, batch_idx):

        full_rep, y = batch

        fea_out = self.residual_out(full_rep)

        loss =  self.loss(fea_out, y)

        # Logging to TensorBoard (if installed) by default
        self.log("val_loss", loss, prog_bar=True, on_step=False, on_epoch=True)

    def test_step(self, batch, batch_idx):

        full_rep, y = batch

        fea_out = self.residual_out(full_rep)

        loss =  self.loss(fea_out, y)
  

        # Logging to TensorBoard (if installed) by default
        self.log("test_loss", loss, prog_bar=True, on_step=False, on_epoch=True)

    def predict_step(self, batch, batch_idx):

        //some_code

        return xyz