PyDLLib 1.0__py3-none-any.whl

DLL/Data/Preprocessing.py

@@ -0,0 +1,384 @@
+import torch
+from math import floor
+from itertools import combinations_with_replacement
+
+from ..Exceptions import NotCompiledError
+
+
+def data_split(X, Y, train_split=0.8, validation_split=0.2):
+    """
+    Splits the data into train, validation and test sets.
+
+    Args:
+        X (torch.Tensor of shape (n_samples, ...)): The input values.
+        Y (torch.Tensor of shape (n_samples, ...)): The target values.
+        train_split (float, optional): The precentage of train data of the whole data. Must be a real number in range (0, 1]. Defaults to 0.8.
+        validation_split (float, optional): The precentage of validation data of the whole data. Must be a real number in range [0, 1). Defaults to 0.2.
+    
+    Returns:
+        x_train, y_train, x_val, y_val, x_test, y_test (tuple[torch.Tensor]): The original data shuffled and split according to train and validation splits.
+    
+    Note:
+        The sum of train_split and validation_split must be less than or equal to 1. The remaining samples are returned as the test data.
+    """
+    if not isinstance(train_split, float | int) or train_split <= 0 or train_split > 1:
+        raise ValueError("train_split must be a real number in range (0, 1].")
+    if not isinstance(validation_split, float | int) or validation_split < 0 or validation_split >= 1:
+        raise ValueError("validation_split must be a real number in range [0, 1).")
+    if train_split + validation_split > 1:
+        raise ValueError("The sum of train_split and validation_split must be less than or equal to 1.")
+
+    data_length = X.size(0)
+    perm = torch.randperm(data_length, requires_grad=False, device=X.device)
+    x_data = X.index_select(0, perm)
+    y_data = Y.index_select(0, perm)
+    split_index1 = floor(data_length * train_split)
+    split_index2 = floor(data_length * (train_split + validation_split))
+    x_train, y_train = x_data[:split_index1], y_data[:split_index1]
+    x_val, y_val = x_data[split_index1:split_index2], y_data[split_index1:split_index2]
+    x_test, y_test = x_data[split_index2:], y_data[split_index2:]
+    return x_train, y_train, x_val, y_val, x_test, y_test
+
+
+class OneHotEncoder:
+    """
+    The one-hot encoder.
+    """
+    def fit(self, data):
+        """
+        Finds the classes in the data.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,) or (n_samples, n_features)): the true labels of samples.
+        """
+        if not isinstance(data, torch.Tensor) or (data.ndim != 1 and data.ndim != 2):
+            raise ValueError("data must be a 1 or 2 dimensional torch tensor.")
+        
+        if data.ndim == 1: data = data.unsqueeze(1)
+
+        # unique_elements = [torch.unique(feature) for feature in data.T]
+        # self.element_to_index = [{element.item(): i for i, element in enumerate(uniques)} for uniques in unique_elements]
+        # self.index_to_element = [{i: element for element, i in table.items()} for table in self.element_to_index]
+        # self.one_hot_lengths = [len(uniques) for uniques in unique_elements]
+        range_elements = [range(torch.min(feature).int(), torch.max(feature).int() + 1) for feature in data.T]
+        self.element_to_index = [{element: i for i, element in enumerate(uniques)} for uniques in range_elements]
+        self.index_to_element = [{i: element for element, i in table.items()} for table in self.element_to_index]
+        self.one_hot_lengths = [len(uniques) for uniques in range_elements]
+
+    def encode(self, data):
+        """
+        One-hot encodes the data. OneHotEncoder.fit() must be called before encoding.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,) or (n_samples, n_features)): the true labels of samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples, n_classes_1 + ... + n_classes_n_features): A one-hot encoded tensor.
+        """
+        if not isinstance(data, torch.Tensor) or (data.ndim != 1 and data.ndim != 2):
+            raise ValueError("data must be a 1 or 2 dimensional torch tensor.")
+        if not hasattr(self, "one_hot_lengths"):
+            raise NotCompiledError("OneHotEncoder.fit() must be called before encoding.")
+
+        if data.ndim == 1: data = data.unsqueeze(1)
+        encoded_features = []
+        for i in range(data.shape[1]):
+            label_to_distribution = torch.tensor([self._get_distribution(self.element_to_index[i][y.item()], self.one_hot_lengths[i]) for y in data[:, i]], device=data.device)
+            encoded_features.append(label_to_distribution)
+        return torch.cat(encoded_features, dim=1)
+    
+    def fit_encode(self, data):
+        """
+        First fits the encoder and then one-hot encodes the data.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,) or (n_samples, n_features)): the true labels of samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples, n_classes_1 + ... + n_classes_n_features): A one-hot encoded tensor.
+        """
+        if not isinstance(data, torch.Tensor) or (data.ndim != 1 and data.ndim != 2):
+            raise ValueError("data must be a 1 or 2 dimensional torch tensor.")
+
+        self.fit(data)
+        return self.encode(data)
+    
+    def decode(self, data):
+        """
+        One-hot encodes the data. OneHotEncoder.fit() must be called before decoding.
+
+        Args:
+            data (torch.Tensor of shape (n_samples, n_classes_1 + ... + n_classes_n_features)): the predictions of samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples,) or (n_samples, n_features): A decoded predictions transformed to the original classes.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim != 2:
+            raise ValueError("data must be a 2 dimensional torch tensor.")
+        if not hasattr(self, "one_hot_lengths"):
+            raise NotCompiledError("OneHotEncoder.fit() must be called before decoding.")
+
+        decoded = []
+        i = 0
+        j = 0
+        while i < sum(self.one_hot_lengths):
+            feature = data[:, i:(i + self.one_hot_lengths[j])]
+            features_decoded = [self.index_to_element[j][torch.argmax(tensor, dim=0).item()] for tensor in feature]
+            decoded.append(features_decoded)
+            i += self.one_hot_lengths[j]
+            j += 1
+        decoded = torch.tensor(decoded, device=data.device).T
+        if len(self.one_hot_lengths) == 1: decoded = decoded.squeeze(1)
+        return decoded
+
+    def _get_distribution(self, index, size):
+        distribution = [0 if i != index else 1 for i in range(size)]
+        return distribution
+
+
+class CategoricalEncoder:
+    """
+    The categorical encoder.
+    """
+    def fit(self, data):
+        """
+        Finds the classes in the data.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,)): the true labels of samples.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim != 1:
+            raise ValueError("data must be a 1 dimensional torch tensor.")
+
+        self.unique_elements = torch.unique(data)
+        self.element_to_key = {element.item(): i for i, element in enumerate(self.unique_elements)}
+
+    def encode(self, data):
+        """
+        Encodes the data to values [0, ..., n_classes - 1]. CategoricalEncoder.fit() must be called before encoding.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,)): the true labels of samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples,): An encoded tensor.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim != 1:
+            raise ValueError("data must be a 1 dimensional torch tensor.")
+        if not hasattr(self, "element_to_key"):
+            raise NotCompiledError("CategoricalEncoder.fit() must be called before encoding.")
+
+        label_to_distribution = torch.tensor([self.element_to_key[y.item()] for y in data], device=data.device)
+        return label_to_distribution
+    
+    def fit_encode(self, data):
+        """
+        First fits the encoder and then encodes the data.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,)): the true labels of samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples,): An encoded tensor.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim != 1:
+            raise ValueError("data must be a 1 dimensional torch tensor.")
+
+        self.fit(data)
+        return self.encode(data)
+    
+    def decode(self, data):
+        """
+        Decodes the data to the original classes. CategoricalEncoder.fit() must be called before decoding.
+
+        Args:
+            data (torch.Tensor of shape (n_samples,)): the predicted labels of samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples,): A decoded predictions transformed to the original classes.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim != 1:
+            raise ValueError("data must be a 1 dimensional torch tensor.")
+        if not hasattr(self, "element_to_key"):
+            raise NotCompiledError("CategoricalEncoder.fit() must be called before decoding.")
+
+        return torch.tensor([self.unique_elements[label] for label in data], device=data.device)
+
+
+class MinMaxScaler:
+    """
+    The min-max scaler.
+    """
+    def fit(self, data):
+        """
+        Finds the minimum and the maximum of the data.
+
+        Args:
+            data (torch.Tensor): the input samples.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be a torch.Tensor.")
+
+        self.min = torch.min(data, dim=0).values
+        self.max = torch.max(data, dim=0).values
+
+        if torch.any(self.max - self.min == torch.tensor(0)):
+            raise ZeroDivisionError("Some features do not change and result in division by zero.")
+
+    def transform(self, data):
+        """
+        Normalises the data between 0 and 1.
+
+        Args:
+            data (torch.Tensor): the input samples.
+
+        Returns:
+            torch.Tensor: the transformed data.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be a torch.Tensor.")
+        if not hasattr(self, "min"):
+            raise NotCompiledError("MinMaxScaler.fit() must be fitted before transforming.")
+        
+        return (data - self.min) / (self.max - self.min)
+
+    def fit_transform(self, data):
+        """
+        First fits the scaler and then transforms the data.
+
+        Args:
+            data (torch.Tensor): the input samples.
+
+        Returns:
+            torch.Tensor: the transformed data.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be a torch.Tensor.")
+
+        self.fit(data)
+        return self.transform(data)
+    
+    def inverse_transform(self, data):
+        """
+        Scales the data back to it's original space.
+
+        Args:
+            data (torch.Tensor): the input samples.
+
+        Returns:
+            torch.Tensor: the transformed data.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be a torch.Tensor.")
+        if not hasattr(self, "min"):
+            raise NotCompiledError("MinMaxScaler.fit() must be fitted before inverse transforming.")
+        
+        return data * (self.max - self.min) + self.min
+
+class StandardScaler:
+    """
+    The standard scaler.
+    """
+    def fit(self, data):
+        """
+        Finds the mean and the variance of the data.
+
+        Args:
+            data (torch.Tensor): the input samples.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be torch.Tensor.")
+
+        self.mean = torch.mean(data, dim=0)
+        self.var = torch.var(data, dim=0)
+
+    def transform(self, data):
+        """
+        Transforms the data to zero mean and one variance.
+
+        Args:
+            data (torch.Tensor): the input samples.
+
+        Returns:
+            torch.Tensor: the transformed data.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be a torch.Tensor.")
+        if not hasattr(self, "mean"):
+            raise NotCompiledError("StandardScaler.fit() must be fitted before transforming.")
+        
+        return (data - self.mean) / torch.sqrt(self.var)
+
+    def fit_transform(self, data):
+        """
+        First fits the scaler and then encodes the data.
+
+        Args:
+            data (torch.Tensor): the input samples.
+
+        Returns:
+            torch.Tensor: the transformed data.
+        """
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("data must be a torch.Tensor.")
+        
+        self.fit(data)
+        return self.transform(data)
+
+    def inverse_transform(self, data):
+        """
+        Scales the data back to it's original space.
+
+        Args:
+            data (torch.Tensor): the input samples.
+
+        Returns:
+            torch.Tensor: the transformed data.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim == 0:
+            raise ValueError("data must be a torch.Tensor.")
+        if not hasattr(self, "mean"):
+            raise NotCompiledError("StandardScaler.fit() must be fitted before inverse transforming.")
+        
+        return data * torch.sqrt(self.var) + self.mean
+
+
+class PolynomialFeatures:
+    """
+    Polynomial features.
+
+    Args:
+        degree (int, optional): The degree of the polynomial. Must be a positive integer. Defaults to 2.
+        include_bias (bool): If true, a column of ones is included. Must be a boolean. Defaults to True.
+    """
+    def __init__(self, degree=2, include_bias=True):
+        if not isinstance(degree, int) or degree <= 0:
+            raise ValueError("degree must be a positive integer.")
+        if not isinstance(include_bias, bool):
+            raise TypeError("include_bias must be a boolean.")
+        
+        self.degree = degree
+        self.include_bias = include_bias
+
+    def transform(self, data):
+        """
+        Creates a matrix of data containing every possible combination of the given set of features.
+
+        Args:
+            data (torch.Tensor of shape (n_samples, n_features)): the input samples.
+
+        Returns:
+            torch.Tensor of shape (n_samples, sum([nCr(n_features + deg - 1, deg) for deg in range(1, degree + 1)]) + 1): A tensor of the new features.
+        """
+        if not isinstance(data, torch.Tensor) or data.ndim != 2:
+            raise ValueError("data must be a 2 dimensional torch tensor.")
+
+        n_samples, n_features = data.shape
+        features = [torch.ones(n_samples, device=data.device, dtype=data.dtype)] if self.include_bias else []
+
+        for deg in range(1, self.degree + 1):
+            for items in combinations_with_replacement(range(n_features), deg):
+                new_feature = torch.prod(torch.stack([data[:, i] for i in items]), axis=0)
+                features.append(new_feature)
+
+        return torch.vstack(features).T

DLL/Data/_DataReader.py

@@ -0,0 +1,55 @@
+import torch
+
+
+class DataReader:
+    """
+    The data reader.
+
+    Args:
+        X (torch.Tensor of shape (n_samples, ...)): The input data.
+        Y (torch.Tensor of shape (n_samples, ...)): The target labels or values.
+        batch_size (int, optional): The batch size. If the batch size is larger than the number of samples, the maximum number of samples is used as the batch_size. Must be a positive integer. Defaults to 64.
+        shuffle (bool, optional): Determines if the input data is shuffled in the beginning. Defaults to True.
+        shuffle_every_epoch (bool, optional): Determines if the input data is shuffled every time all data points are used. Defaults to False.
+    """
+    def __init__(self, X, Y, batch_size=64, shuffle=True, shuffle_every_epoch=False):
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("X must be a torch.Tensor.")
+        if not isinstance(Y, torch.Tensor):
+            raise TypeError("Y must be a torch.Tensor.")
+        if len(X) != len(Y):
+            raise ValueError("X and Y must have the same number of samples.")
+        if not isinstance(batch_size, int) or batch_size <= 0:
+            raise ValueError("batch_size must be positive integer.")
+        if not isinstance(shuffle, bool):
+            raise TypeError("shuffle must be a boolean.")
+        if not isinstance(shuffle_every_epoch, bool):
+            raise TypeError("shuffle_every_epoch must be a boolean.")
+
+        self.data_length = Y.size(0)
+        self.shuffle = shuffle
+        self.shuffle_every_epoch = shuffle_every_epoch
+        if self.shuffle:
+            self.perm = torch.randperm(self.data_length, device=X.device)
+            self.X = X.index_select(0, self.perm)
+            self.Y = Y.index_select(0, self.perm)
+        else:
+            self.X = X
+            self.Y = Y
+        self.batch_size = batch_size if len(Y) >= batch_size else len(Y)
+
+    def get_data(self):
+        """
+        A generator giving going through the entire dataset.
+
+        Yields:
+            tuple[torch.Tensor, torch.Tensor]: X_batch, y_batch
+        """
+        iteration = 0
+        while iteration * self.batch_size < self.data_length:
+            yield self.X[iteration * self.batch_size:(iteration + 1) * self.batch_size], self.Y[iteration * self.batch_size:(iteration + 1) * self.batch_size]
+            iteration += 1
+        if self.shuffle_every_epoch and self.shuffle:
+            self.perm = torch.randperm(self.data_length, device=self.X.device)
+            self.X = self.X.index_select(0, self.perm)
+            self.Y = self.Y.index_select(0, self.perm)

DLL/Data/__init__.py

@@ -0,0 +1 @@
+from ._DataReader import DataReader

DLL/DeepLearning/Callbacks/_BackUp.py

@@ -0,0 +1,71 @@
+from . import Callback
+from ...Exceptions import NotCompiledError
+from ..Model import save_model
+
+
+class BackUp(Callback):
+    """
+    Saves the fitted model to the spesified filepath.
+
+    Args:
+        filepath (str | , optional): The filepath where the model is saved. Defaults to "./model.pkl".
+        frequency (int, optional): The frequency of saving the model. Must be a positive integer. Defaults to 1.
+        on_batch (bool, optional): Determines if a model is saved every frequency batch or epoch. Defaults to False.
+        verbose (bool, optional): Determines if information about the callbacks is printed. Must be a boolean. Defaults to False.
+    """
+    def __init__(self, filepath="./model.pkl", frequency=1, on_batch=False, verbose=False):
+        if not isinstance(filepath, str):
+            raise TypeError("filepath must be a string.")
+        if not isinstance(frequency, int) or frequency <= 0:
+            raise ValueError("frequency must be a positive integer.")
+        if not isinstance(on_batch, bool):
+            raise TypeError("on_batch must be boolean.")
+        if not isinstance(verbose, bool):
+            raise TypeError("verbose must be a boolean.")
+
+        self.filepath = filepath
+        self.frequency = frequency
+        self.on_batch = on_batch
+        self.counter = 0
+        self.verbose = verbose
+
+    def on_epoch_end(self, epoch, metrics):
+        """
+        Calculates if the model should be backed up on this epoch.
+
+        Args:
+            epoch (int): The current epoch.
+            metrics (dict[str, float]): The values of the chosen metrics of the last epoch.
+
+        Raises:
+            NotCompiledError: callback.set_model must be called before the training starts
+        """
+        if not hasattr(self, "model"):
+            raise NotCompiledError("callback.set_model must be called before the training starts.")
+        
+        if not self.on_batch:
+            self.counter += 1
+            if self.counter % self.frequency == 0:
+                save_model(self.model, filepath=self.filepath)
+                if self.verbose: print(f"Model backed up at epoch {epoch + 1} at {self.filepath}")
+        else:
+            self.counter = 0
+
+    def on_batch_end(self, epoch):
+        """
+        Calculates if the model should be backed up on this batch.
+
+        Args:
+            epoch (int): The current epoch.
+
+        Raises:
+            NotCompiledError: callback.set_model must be called before the training starts
+        """
+        if not hasattr(self, "model"):
+            raise NotCompiledError("callback.set_model must be called before the training starts.")
+    
+        if self.on_batch:
+            self.counter += 1
+            if self.counter % self.frequency == 0:
+                save_model(self.model, filepath=self.filepath)
+                if self.verbose: print(f"Model backed up at epoch {epoch + 1} at {self.filepath}")

DLL/DeepLearning/Callbacks/_BaseCallback.py

@@ -0,0 +1,43 @@
+from abc import ABC
+
+
+class Callback(ABC):
+    def set_model(self, model):
+        """
+        Lets the callback know about the chosen model. Is automatically called when using Model.fit()
+
+        Args:
+            Model (:ref:`models_section_label`): The chosen model.
+        """
+        self.model = model
+
+    def on_train_start(self):
+        """
+        A method, which is automatically called before the training starts.
+        """
+        pass
+
+    def on_train_end(self):
+        """
+        A method, which is automatically called after training.
+        """
+        pass
+
+    def on_epoch_end(self, epoch, metrics):
+        """
+        A method, which is automatically called after every epoch.
+
+        Args:
+            epoch (int): The current epoch.
+            metrics (dict[str, float]): The values of the chosen metrics of the last epoch.
+        """
+        pass
+
+    def on_batch_end(self, epoch):
+        """
+        A method, which is automatically called after every batch.
+
+        Args:
+            epoch (int): The current epoch.
+        """
+        pass

DLL/DeepLearning/Callbacks/_EarlyStopping.py

@@ -0,0 +1,102 @@
+from . import Callback
+from ...Exceptions import NotCompiledError
+
+
+class EarlyStopping(Callback):
+    """
+    The early stopping callback. Stops the training of the model early if no improvement is made.
+
+    Args:
+        monitor (str, optional): The quantity, which is monitored for the early stop. Must be in the metrics of the model. Defaults to "val_loss".
+        patience (int, optional): The number of epochs the model waits without improvement. Must be a positive integer. Defaults to 1.
+        mode (str, optional): Determines if the monitored metric better if it is maximized or minimized. Must be in ["min", "max"]. Defaults to "min".
+        restore_best_model (bool, optional): Determines if the best model is restored after the training is finished. Defaults to False.
+        warmup_length (int, optional): Determines how many epochs are trained no matter what. Must be non-negative. Defaults to 0.
+        verbose (bool, optional): Determines if information about the callbacks is printed. Must be a boolean. Defaults to False.
+    Note:
+        Using restore_best_model = True considerably slows down training as the best model must be saved every epoch the model improves.
+    """
+    def __init__(self, monitor="val_loss", patience=1, mode="min", restore_best_model=False, warmup_length=0, verbose=False):
+        if not isinstance(patience, int) or patience <= 0:
+            raise ValueError("patience must be a positive integer.")
+        if mode not in ["min", "max"]:
+            raise ValueError('mode must be in ["min", "max"].')
+        if not isinstance(restore_best_model, bool):
+            raise TypeError("restore_best_model must be a boolean.")
+        if not isinstance(warmup_length, int) or warmup_length < 0:
+            raise ValueError("warmup_length must be non-negative.")
+        if not isinstance(verbose, bool):
+            raise TypeError("verbose must be a boolean.")
+
+        self.monitor = monitor
+        self.patience = patience
+        self.mode = 1 if mode == "min" else -1
+        self.restore_best_model = restore_best_model
+        self.warmup_length = warmup_length
+        self.verbose = verbose
+
+    def set_model(self, model):
+        """
+        Lets the callback know about the chosen model. Is automatically called when using Model.fit()
+
+        Args:
+            Model (:ref:`models_section_label`): The chosen model.
+        """
+        if not hasattr(model, "metrics") or self.monitor not in model.metrics:
+            raise ValueError("monitor must be in the metrics of the model.")
+        
+        self.model = model
+
+    def on_train_start(self):
+        """
+        Sets the needed attributes.
+
+        Raises:
+            NotCompiledError: callback.set_model must be called before the training starts
+        """
+        if not hasattr(self, "model"):
+            raise NotCompiledError("callback.set_model must be called before the training starts.")
+
+        if self.restore_best_model:
+            self.stored_model = self.model.clone()
+        self.wait = 0
+        self.best_value = float("inf")
+
+    def on_train_end(self):
+        """
+        Resets the model to the stored model if restore_best_model was chosen.
+
+        Raises:
+            NotCompiledError: callback.set_model must be called before the training starts
+        """
+        if not hasattr(self, "model"):
+            raise NotCompiledError("callback.set_model must be called before the training starts.")
+        
+        if self.restore_best_model:
+            self.model.layers = self.stored_model.layers
+
+    def on_epoch_end(self, epoch, metrics):
+        """
+        Calculates if the model has improved on the last epoch.
+
+        Args:
+            epoch (int): The current epoch.
+            metrics (dict[str, float]): The values of the chosen metrics of the last epoch.
+
+        Raises:
+            NotCompiledError: callback.set_model must be called before the training starts
+        """
+        if not hasattr(self, "model"):
+            raise NotCompiledError("callback.set_model must be called before the training starts.")
+
+        value = metrics[self.monitor]
+        if self.mode * value < self.best_value:
+            self.wait = 0
+            self.best_value = self.mode * value
+            if self.restore_best_model:
+                self.stored_model = self.model.clone()
+        elif epoch > self.warmup_length:
+            self.wait += 1
+            if self.wait >= self.patience:
+                if self.verbose: print(f"Stopped training early at epoch {epoch + 1} after {self.patience} epochs of no improvement. The monitored metric is currently {value:.3f} and the best model has the value of {self.mode * self.best_value:.3f}.")
+                self.model.stop_training = True