Early stopping conditioned on metric val_loss which is not available

[morestart]

this is my BaseModel:

from typing import Callable

import lightning.pytorch as pl
import torch


class BaseModel(pl.LightningModule):
    def __init__(self, loss_fn: Callable, lr: float = 1e-3):
        super().__init__()
        self.loss_fn = loss_fn
        self.lr = lr
        self.save_hyperparameters(ignore=['loss_fn'])

    def training_step(self, batch, batch_idx):
        x, y = batch
        y_hat = self(x)
        loss = self.loss_fn(y_hat, y)
        self.log('train_loss', loss)
        return loss

    def validation_step(self, batch, batch_idx):
        x, y = batch
        y_hat = self(x)
        loss = self.loss_fn(y_hat, y)
        self.log('val_loss', loss)
        return loss

    def test_step(self, batch, batch_idx):
        x, y = batch
        with torch.no_grad():
            y_hat = self(x)
            loss = self.loss_fn(y_hat, y)
            self.log('test_loss', loss)
            return loss

    def configure_optimizers(self):
        optimizer = torch.optim.AdamW(self.parameters(), lr=self.lr)
        scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5, verbose=True)
        return {"optimizer": optimizer, "lr_scheduler": scheduler, "monitor": "val_loss"}

this is my trainer:

import lightning.pytorch as pl
from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint, LearningRateMonitor, RichProgressBar, Checkpoint
from lightning.pytorch.loggers import WandbLogger, TensorBoardLogger

from ..config import Config
from ..dataProvider import WFDataModuleKFold


class TrainerKfold:
    def __init__(
            self,
            config: Config,
            model: pl.LightningModule,
    ):
        pl.seed_everything(42)
        self.cfg = config
        self.model = model

    def __call__(self, *args, **kwargs):
        self.cross_validation()

    def cross_validation(self):
        num_folds = self.cfg.num_folds
        split_seed = self.cfg.split_seed

        for k in range(num_folds):
            datamodule = WFDataModuleKFold(
                csv_path=self.cfg.csv_path,
                drop_columns=self.cfg.drop_columns,
                batch_size=self.cfg.batch_size,
                qt_save_path=self.cfg.qt_save_path,
                num_splits=self.cfg.num_folds,
                split_seed=split_seed,
                k=k
            )
            datamodule.prepare_data()
            datamodule.setup()

            trainer = pl.Trainer(
                accelerator=self.cfg.accelerator,
                devices=self.cfg.device,
                strategy='auto',
                max_epochs=self.cfg.max_epoch,
                fast_dev_run=self.cfg.fast_dev_run,
                callbacks=[
                    EarlyStopping(patience=self.cfg.patience, monitor='val_loss', min_delta=0.00, verbose=False,
                                  mode='min'),
                    ModelCheckpoint(
                        dirpath=self.cfg.checkpoint_dir,
                        auto_insert_metric_name=True,
                        monitor='val_loss'
                    ),
                    LearningRateMonitor(logging_interval='epoch'),
                    RichProgressBar(leave=True),
                ],
                # logger=WandbLogger(project='WF')
                logger=TensorBoardLogger(save_dir=r'F:\2023\工作\tyykj\WeathreForecast\check\qd')
            )

            trainer.fit(self.model, datamodule.train_dataloader())
            trainer.test(self.model, datamodule.test_dataloader())