sklearn-morpho 0.1.0__py2.py3-none-any.whl

sklearn_morpho/__init__.py

@@ -0,0 +1,3 @@
+from .classifiers.ldep import LDEP
+from .weighting import *
+from .stopping import *

sklearn_morpho/classifiers/ldep.py

@@ -0,0 +1,172 @@
+import numpy as np
+from typing import Literal, cast
+
+from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.preprocessing import StandardScaler
+from sklearn.utils import check_random_state
+from sklearn.utils.validation import validate_data, check_is_fitted
+from sklearn.utils.multiclass import unique_labels
+
+from ..dccp.dccp_ldep import LDEPDccpTrainer
+from ..stopping import (
+        StoppingMethod,
+        CostStoppingMethod,
+        EarlyStoppingMethod,
+        EpochStoppingMethod,
+        TrainStopStoppingMethod,
+)
+from ..weighting import SampleWeighting, NoneSampleWeighting
+
+class LDEP(ClassifierMixin, BaseEstimator):
+    """
+    Scikit-learn estimator wrapper around a l-DEP (linear Dilation-Erosion
+    morphological Perceptron) for binary data classification.
+
+    l-DEP forward pass equation:
+
+    \\[ y = f(\\lambda \\tau_(R_1(x)) + (1 - \\lambda) \\tau'_(R_2(x))) \\]
+
+    Where $\\tau$ refers to the activation of a (max, +) morphological
+    perceptron and $\\tau'$ to a (min, +) one.
+    $R_1, R_2$ are linear transformations to apply to the training data.
+    They convert it into a latent space with possibly different dimensions,
+    also allowing classification of arbitrarily distributed data.
+    A higher dimension for the latent space will result in slower training
+    times, but will allow the decision boundary to be more complex.
+    """
+
+    def __init__(self, latent_dims: tuple[int, int] = (10, 10), margin = 1.,
+                 validation_ratio = .3,
+                 weighting_method: SampleWeighting | None = None,
+                 stopping_methods: list[StoppingMethod] | None = None,
+                 verbose: Literal[0, 1, 2] = 0,
+                 random_state: np.random.RandomState | None = None) -> None:
+        """
+        Initialize the classifier, see class help for more.
+
+        param latent_dims:      The dimensions of the latent spaces used for the
+                                linear transformations output
+        param margin:           Enforce a margin between the decision boundary
+                                and the data. May help with linearly separable
+                                datasets, but generally lower is more accurate.
+        param validation_radio: How much of the training set to dedicate to use
+                                as validation during fitting.
+                                Must be between 0 and 1 (inclusive, exclusive),
+                                if set to exactly 0 then incompatible stopping
+                                methods cannot be used (e.g. early stopping).
+        param weighting_method: The weighting method to use: apply weights to
+                                the cost contribution of each data point to help
+                                avoid outliers.
+                                If left to None, will use NoneWeightingMethod()
+        param stopping_methods: A list of stopping methods, must not be empty.
+                                At each epoch, these methods will be
+                                sequentially asked whether the training should
+                                stop. In this case, epoch ends by rolling back
+                                to the epoch with the best validation cost.
+                                If left to None, will use:
+                                [
+                                    CostStoppingMethod(1e-6),
+                                    EarlyStoppingMethod(5),
+                                    EpochStoppingMethod(20),
+                                    TrainStopStoppingMethod(),
+                                ]
+        param verbose:          Whether to log extra information. 0: no logging,
+                                1: basic logging / timing, 2: cvxpy solve() set
+                                to verbose mode.
+        param random_state:     A RandomState object or None to allow for seeded
+                                randomness.
+        """
+
+        self.latent_dims = latent_dims
+        self.margin = margin
+        self.validation_ratio = validation_ratio
+        self.weighting_method = weighting_method
+        self.stopping_methods = stopping_methods
+        self.verbose: Literal[0, 1, 2] = verbose
+        self.random_state = random_state
+
+    def fit(self, X: np.ndarray, y: np.ndarray) -> LDEP:
+        """
+        Fit the classifier, create attributes:
+        - self.max_perceptron_
+        - self.min_perceptron_
+        - self.lambda_
+        - self.max_matrix_
+        - self.min_matrix_
+        - self.classes_:        Unique labels generated from y
+
+        X and y must represent binary classifiable data.
+        """
+
+        # input data validation
+        random_state = check_random_state(self.random_state)
+        X, y = validate_data(self, X, y)
+        self.scaler_ = StandardScaler()
+        X_scaled = self.scaler_.fit_transform(X)
+
+        # set unset parameters to their default values
+        if self.weighting_method is None:
+            weighting_method = NoneSampleWeighting()
+        else:
+            weighting_method = self.weighting_method
+        if self.stopping_methods is None:
+            stopping_methods = [
+                CostStoppingMethod(1e-6),
+                EarlyStoppingMethod(5),
+                EpochStoppingMethod(20),
+                TrainStopStoppingMethod(),
+            ]
+        else:
+            stopping_methods = self.stopping_methods
+
+        # create classes and convert them to distinct integers for fitting
+        # the classes are persisted inside the object for use in predict
+        self.classes_ = unique_labels(y)
+        classes_list = list(self.classes_)
+        y_integers = np.array([classes_list.index(c) for c in y],
+                           dtype=np.int32)
+
+        if len(classes_list) != 2:
+            raise ValueError('Only binary classification is supported but '
+                             f'got {len(classes_list)} class(es).')
+
+        # create and train perceptrons
+        trainer = LDEPDccpTrainer(self.latent_dims, self.margin,
+                                  self.validation_ratio, weighting_method,
+                                  stopping_methods, self.verbose,
+                                  random_state)
+
+        trainer.train(X_scaled, y_integers)
+        self.max_perceptron_ = trainer.max_perceptron
+        self.min_perceptron_ = trainer.min_perceptron
+        self.lambda_ = trainer.lambda_
+        self.max_matrix_ = trainer.max_matrix
+        self.min_matrix_ = trainer.min_matrix
+
+        return self
+
+    def decision_function(self, X: np.ndarray) -> np.ndarray:
+        check_is_fitted(self)
+        X = validate_data(self, X, reset=False)
+        X_scaled = cast(np.ndarray, self.scaler_.transform(X))
+
+        expr_max = np.max(self.max_perceptron_ + X_scaled @ self.max_matrix_.T,
+                          axis=1)
+        expr_min = np.min(self.min_perceptron_ + X_scaled @ self.min_matrix_.T,
+                          axis=1)
+        return expr_max * self.lambda_ + expr_min * (1 - self.lambda_)
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        check_is_fitted(self)
+        return self.classes_[(self.decision_function(X) >= 0).astype(int)]
+
+    def __sklearn_tags__(self):
+        """
+        Overriden method to allow check_estimator to not run accuracy tests.
+        These are designed for perceptrons with a linear decision boundary,
+        which is not the case for a morphological perceptron.
+        """
+
+        tags = super().__sklearn_tags__()
+        tags.classifier_tags.multi_class = False
+        return tags

sklearn_morpho/dccp/dccp_ldep.py

@@ -0,0 +1,162 @@
+from typing import Literal
+import numpy as np
+import cvxpy as cp
+
+from .dccp_wrapper import DccpTrainer
+from ..weighting import SampleWeighting
+from ..stopping import StoppingMethod
+
+class LDEPDccpTrainer(DccpTrainer):
+    def __init__(self, latent_dims: tuple[int, int],
+                 margin: float, validation_ratio: float,
+                 weighting_method: SampleWeighting,
+                 stopping_methods: list[StoppingMethod],
+                 verbose: Literal[0, 1, 2],
+                 random_state: np.random.RandomState) -> None:
+        """
+        Initialize the l-DEP trainer.
+
+        param latent_dims: the latent dimensions for the max and min perceptrons
+        param [others]:    see base class
+        """
+
+        self.latent_dims = latent_dims
+
+        super().__init__(margin, validation_ratio, weighting_method,
+                         stopping_methods, verbose, random_state)
+
+    def at_training_start(self, data_dim: int) -> None:
+        N_max, N_min = self.latent_dims
+
+        self._objective = None
+
+        # Extracted parameters that will be populated during training but need
+        # initial values for linearization
+        self.max_perceptron = self.random_state.randn(N_max)
+        self.min_perceptron = self.random_state.randn(N_min)
+        self.max_matrix = self.random_state.randn(N_max, data_dim)
+        self.min_matrix = self.random_state.randn(N_min, data_dim)
+
+        # Create constraints for linearization derived from real parameters,
+        # used to absorbe non-convex parameters that are restored at the end.
+        # Method inspired by arXiv:2011.06512v1.
+        # TODO: is this representation an issue since the final lambda parameter
+        # is not necessarily in [0, 1]?
+        self._max_training_weights = cp.Variable(N_max)
+        self._min_training_weights = cp.Variable(N_min)
+        self._max_training_matrix = cp.Variable((N_max, data_dim))
+        self._min_training_matrix = cp.Variable((N_min, data_dim))
+
+    def get_problem(self, X: np.ndarray, y: np.ndarray,
+                    cost_weights: np.ndarray) -> cp.Problem:
+        K = X.shape[0]
+
+        # the objective and the slack variables do not change, cache them
+        if self._objective is None:
+            self._slack = cp.Variable(K)
+            self._objective = cp.Minimize(
+                    cp.sum(cp.multiply(cp.pos(self._slack), cost_weights)))
+
+        # Constraints: convex constraints are for data points in the first
+        # class, while concave ones are for points in the second class.
+        # Therefore, linearize things when needed to make the problem convex,
+        # sometimes using values from the previous epoch.
+
+        idx_max = np.argmax(self.max_perceptron + X @ self.max_matrix.T,
+                            axis=1)
+        idx_min = np.argmin(self.min_perceptron + X @ self.min_matrix.T,
+                            axis=1)
+
+        # create arrays to regroup the active indices using numpy, to then apply
+        # constraints all at once and use AST optimizations inside cvxpy
+        M_max = np.zeros((K, self.max_perceptron.size))
+        M_min = np.zeros((K, self.min_perceptron.size))
+        M_max[np.arange(K), idx_max] = 1
+        M_min[np.arange(K), idx_min] = 1
+
+        constraints = []
+        for label in [0, 1]:
+            mask = y == label
+            if not np.any(mask):
+                continue
+
+            X_ = X[mask]
+            K_ = X_.shape[0]
+
+            # start building the perceptron's outputs before the min/max
+            expr_max = X_ @ self._max_training_matrix.T
+            expr_min = X_ @ self._min_training_matrix.T
+
+            # add weights to every row of (X @ matrix.T) using np.ones to create
+            # a matrix safely for cvxpy's cpp backend
+            ones = np.ones((K_, 1))
+            expr_max += ones @ cp.reshape(self._max_training_weights,
+                                          (1, self.max_perceptron.size),
+                                          order='C')
+            expr_min += ones @ cp.reshape(self._min_training_weights,
+                                          (1, self.min_perceptron.size),
+                                          order='C')
+
+            active_max = cp.sum(cp.multiply(M_max[mask], expr_max), axis=1)
+            active_min = cp.sum(cp.multiply(M_min[mask], expr_min), axis=1)
+
+            if label == 0:
+                constraints.append(self._slack[mask] >= self.margin
+                                   + cp.max(expr_max, axis=1) + active_min)
+            else:
+                constraints.append(self._slack[mask] >= self.margin
+                                   - active_max - cp.min(expr_min, axis=1))
+        return cp.Problem(self._objective, constraints)
+
+    def get_cost(self, X: np.ndarray, y: np.ndarray) -> float:
+        expr_max = np.max(self.max_perceptron + X @ self.max_matrix.T, axis=1)
+        expr_min = np.min(self.min_perceptron + X @ self.min_matrix.T, axis=1)
+
+        # can use the expressions directly without needing to multiply by lambda
+        # since still in the training phase
+        cost = self.margin + (expr_max + expr_min) * (1 - 2 * y)
+        return np.maximum(0, cost).sum()
+
+    def after_epoch(self) -> None:
+        # update the perceptrons weights from this epoch's results
+        if self._max_training_weights.value is None or \
+                self._min_training_weights.value is None:
+            raise ValueError('CvxPy could not optimize a perceptron')
+
+        self.max_perceptron = self._max_training_weights.value
+        self.min_perceptron = self._min_training_weights.value
+
+        # extract the matrices
+        if self._max_training_matrix.value is None \
+                or self._min_training_matrix.value is None:
+            raise ValueError('CvxPy could not optimize transformation matrices')
+        self.max_matrix = self._max_training_matrix.value
+        self.min_matrix = self._min_training_matrix.value
+
+    def at_training_end(self) -> None:
+        max_matrix_norm = np.linalg.norm(self.max_matrix)
+        min_matrix_norm = np.linalg.norm(self.min_matrix)
+
+        div = max_matrix_norm + min_matrix_norm
+        if np.isclose(div, 0):
+            raise ValueError('Transformation matrices are zero, cannot solve')
+
+        self.lambda_ = max_matrix_norm / div
+        self.max_matrix /= self.lambda_
+        self.min_matrix /= 1 - self.lambda_
+        self.max_perceptron /= self.lambda_
+        self.min_perceptron /= 1 - self.lambda_
+
+    def save_best(self) -> None:
+        self.saved = {
+            'max_w': np.copy(self.max_perceptron),
+            'min_w': np.copy(self.min_perceptron),
+            'max_m': np.copy(self.max_matrix),
+            'min_m': np.copy(self.min_matrix),
+        }
+
+    def rollback_to_best(self) -> None:
+        self.max_perceptron = self.saved['max_w']
+        self.min_perceptron = self.saved['min_w']
+        self.max_matrix = self.saved['max_m']
+        self.min_matrix = self.saved['min_m']

sklearn_morpho/dccp/dccp_wrapper.py

@@ -0,0 +1,225 @@
+from abc import ABC, abstractmethod
+from typing import Literal, cast
+import numpy as np
+import cvxpy as cp
+from time import time
+
+from sklearn.model_selection import train_test_split
+from ..weighting import SampleWeighting
+from ..stopping import StoppingMethod
+
+class DccpTrainer(ABC):
+    """
+    Abstract class for DCCP optimization using cvxpy.
+    """
+
+    def __init__(self, margin: float, validation_ratio: float,
+                 weighting_method: SampleWeighting,
+                 stopping_methods: list[StoppingMethod],
+                 verbose: Literal[0, 1, 2],
+                 random_state: np.random.RandomState) -> None:
+        """
+        Initialize the trainer.
+
+        param validation_radio: How much of the training set to dedicate to use
+                                as validation during fitting.
+        param weighting_method: The weighting method to use: apply weights to
+                                the cost contribution of each data point to help
+                                avoid outliers.
+        param stopping_methods: A list of stopping methods, must not be empty.
+                                At each epoch, these methods will be
+                                sequentially asked whether the training should
+                                stop. In this case, training ends by rolling
+                                back to the epoch with the best validation cost.
+        param verbose:          Whether to log extra information. 0: no logging,
+                                1: basic logging / timing, 2: cvxpy solve() set
+                                to verbose mode.
+        param random_state:     A RandomState object or None to allow for seeded
+                                randomness.
+        """
+
+        if margin < 0:
+            raise ValueError(f'Invalid margin, expected >= 0 but got {margin}')
+        if not 0 <= validation_ratio < 1:
+            raise ValueError('Invalid validation ratio, expected >= 0 and < 1 '
+                             f'but got {validation_ratio}')
+        if not len(stopping_methods):
+            raise ValueError('Empty list of stopping methods, training would '
+                             'run indefinitely')
+
+        self.margin = margin
+        self.validation_ratio = validation_ratio
+        self.weighting_method = weighting_method
+        self.stopping_methods = stopping_methods
+        self.verbose = verbose
+        self.random_state = random_state
+
+    def at_training_start(self, data_dim: int) -> None:
+        """
+        Optional actions to take when the training starts.
+        For example, create and persist a list of additional variables to
+        optimize.
+        """
+
+    def after_epoch(self) -> None:
+        """
+        Optional additional actions to take after each epoch, that is after
+        cvxpy solve() and during wrapping code.
+        """
+
+    def at_training_end(self) -> None:
+        """
+        Optional actions to take when the training is over.
+        Ran as the very last function call in train, meaning after
+        rollback_to_best is called.
+        """
+
+    @abstractmethod
+    def save_best(self) -> None:
+        """
+        Paired with rollback_to_best.
+
+        Save the data generated by after_epoch somewhere accessible at the
+        end of the training process.
+
+        Used in the training loop to roll back to the best state of the model at
+        the end of the loop.
+        """
+
+    @abstractmethod
+    def rollback_to_best(self) -> None:
+        """
+        Paired with save_best.
+
+        Restore the state saved in save_best, after the training process is
+        done, to go back to the best performing model.
+        """
+
+    @abstractmethod
+    def get_problem(self, X: np.ndarray, y: np.ndarray,
+                    cost_weights: np.ndarray) -> cp.Problem:
+        """
+        Compute a cvxpy Objective and a list of Constraints for use in DCCP.
+        The prlblem must be DCP, meaning the constraints must all be convex.
+        For concave constraints, they must be linearized beforehand, possibly
+        from constant values taken from the previous epoch result.
+
+        param X:             The data points
+        param y:             The data points classes
+        param cost_weights: The wdccp weights, all 1 if not using wdccp, for
+                             use in computing the objective.
+                             This is an array with one element corresponding to
+                             an element in X.
+
+        return:              A tuple containing a cvxpy Objective and a list of
+                             Constraints.
+        """
+
+    @abstractmethod
+    def get_cost(self, X: np.ndarray, y: np.ndarray) -> float:
+        """
+        Compute the cost for a set of sample points in the same way as the cost
+        defined in get_problem, used in train/validation training.
+
+        If applicable, should use the weights computed in this epoch's
+        after_epoch call, as it will have been made before this method's call.
+        """
+
+    def train(self, X: np.ndarray, y: np.ndarray) -> None:
+        """
+        Train using DCCP.
+        This means this function can only solve problems where the cost function
+        can be separable in the given convex and concave parts.
+
+        param X: The set of data points to use for training.
+        param y: The set of labels associated with elements of X.
+
+        return:  The final cost, or -1 if no training happened.
+        """
+
+        if self.verbose:
+            print('Starting fitting with DCCP')
+
+        no_validation = self.validation_ratio == 0
+        if no_validation:
+            for stopping_method in self.stopping_methods:
+                if stopping_method.requires_validation():
+                    raise ValueError('Cannot train, at least one stopping '
+                                     'method requires validation which is '
+                                     'disabled by the user')
+
+            X_train, X_validation = X, np.empty(X.shape)
+            y_train, y_validation = y, np.empty(y.shape)
+        else:
+            X_train, X_validation, y_train, y_validation = train_test_split(
+                    X, y, test_size=self.validation_ratio,
+                    random_state=self.random_state)
+            X_train = cast(np.ndarray, X_train)
+            X_validation = cast(np.ndarray, X_validation)
+            y_train = cast(np.ndarray, y_train)
+            y_validation = cast(np.ndarray, y_validation)
+
+        if not X_train.size or (not X_validation.size and not no_validation):
+            raise ValueError('Current validation ratio makes unwanted '
+                             'degenerate train/validation split: '
+                             + str(self.validation_ratio))
+
+        start = time()
+        cost_weights, cost_normalizer = \
+                self.weighting_method.fit_transform(X_train, y_train)
+
+        epoch = 1
+        validation_cost: float = np.inf
+        best_validation_cost: float = np.inf
+
+        # formulate the cvxpy problem to solve, common to all epochs
+        self.at_training_start(X_train.shape[1])
+
+        while True:
+            problem = self.get_problem(X_train, y_train, cost_weights)
+
+            # solve the problem, normalize the cost when using wdccp
+            cvxpy_cost = cast(float, problem.solve(verbose=self.verbose == 2)) \
+                    * cost_normalizer
+
+            self.after_epoch()
+
+            # best score and loop logic
+            done = False
+            if no_validation:
+                train_cost = cvxpy_cost
+                validation_cost = cvxpy_cost
+            else:
+                train_cost = self.get_cost(X_train, y_train)
+                validation_cost = self.get_cost(X_validation, y_validation)
+            if validation_cost < best_validation_cost:
+                best_validation_cost = validation_cost
+                self.save_best()
+
+            if self.verbose:
+                if no_validation:
+                    validation_comment = ' [no validation]'
+                else:
+                    validation_comment = f', validation: {validation_cost:.8f}'
+
+                print(f'Epoch {epoch}, training cost: {cvxpy_cost:.8f}' +
+                      validation_comment)
+
+            for stopping_method in self.stopping_methods:
+                if stopping_method.should_stop(
+                        epoch, train_cost, validation_cost):
+                    done = True
+                    break
+
+            if done:
+                break
+
+            epoch += 1
+
+        if self.verbose:
+            dt = time() - start
+            print(f'DCCP done in {epoch} epochs, '
+                  f'final cost is {validation_cost:.8f} in {dt:.2f}s')
+
+        self.rollback_to_best()
+        self.at_training_end()

sklearn_morpho/stopping/__init__.py

@@ -0,0 +1,5 @@
+from .stopping_base import StoppingMethod
+from .stopping_cost import CostStoppingMethod
+from .stopping_early import EarlyStoppingMethod
+from .stopping_epoch import EpochStoppingMethod
+from .stopping_train_stop import TrainStopStoppingMethod

sklearn_morpho/stopping/stopping_base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+
+class StoppingMethod(ABC):
+    """
+    Abstract class for a fitting stopping method.
+    """
+
+    @abstractmethod
+    def requires_validation(self) -> bool:
+        """
+        Whether the stopping method requires the training to be split in
+        train/validation sets.
+        """
+
+    @abstractmethod
+    def should_stop(self, n_epochs: int, train_cost: float,
+                    validation_cost: float) -> bool:
+        """
+        Given some information, return whether the fitting process should stop.
+        """

sklearn_morpho/stopping/stopping_cost.py

@@ -0,0 +1,21 @@
+from . import StoppingMethod
+
+class CostStoppingMethod(StoppingMethod):
+    """
+    Stopping method that triggers whenever the cost gets lower or equal to the
+    parameter.
+    """
+
+    def __init__(self, cost_threshold: float):
+        if cost_threshold <= 0:
+            raise ValueError('invalid done_threshold, expected > 0 but got '
+                             f'{cost_threshold}')
+
+        self.cost_threshold = cost_threshold
+
+    def requires_validation(self) -> bool:
+        return False
+
+    def should_stop(self, n_epochs: int, train_cost: float,
+                    validation_cost: float) -> bool:
+        return validation_cost <= self.cost_threshold

sklearn_morpho/stopping/stopping_early.py

@@ -0,0 +1,35 @@
+from . import StoppingMethod
+
+class EarlyStoppingMethod(StoppingMethod):
+    """
+    Stopping method that triggers whenever the validation cost starts increasing
+    while the training cost keeps decreasing, this for a set number of
+    consecutive epochs.
+    """
+
+    def __init__(self, delay: int):
+        if delay <= 0:
+            raise ValueError(f'invalid delay, expected > 0 but got {delay}')
+
+        self.delay = delay
+        self.count = 0
+
+        self.best_validation_cost: float | None = None
+
+    def requires_validation(self) -> bool:
+        return True
+
+    def should_stop(self, n_epochs: int, train_cost: float,
+                    validation_cost: float) -> bool:
+        if self.best_validation_cost is None:
+            self.best_validation_cost = validation_cost
+        else:
+            if validation_cost >= self.best_validation_cost:
+                self.count += 1
+                if self.count >= self.delay:
+                    return True
+            else:
+                self.count = 0
+                self.best_validation_cost = validation_cost
+
+        return False

sklearn_morpho/stopping/stopping_epoch.py

@@ -0,0 +1,21 @@
+from . import StoppingMethod
+
+class EpochStoppingMethod(StoppingMethod):
+    """
+    Stopping method that triggers whenever the number of epochs gets greater
+    than the parameter.
+    """
+
+    def __init__(self, max_epochs: int):
+        if max_epochs <= 0:
+            raise ValueError('invalid max_epochs, expected > 0 but got '
+                             f'{max_epochs}')
+
+        self.max_epochs = max_epochs
+
+    def requires_validation(self) -> bool:
+        return False
+
+    def should_stop(self, n_epochs: int, train_cost: float,
+                    validation_cost: float) -> bool:
+        return n_epochs > self.max_epochs

sklearn_morpho/stopping/stopping_train_stop.py

@@ -0,0 +1,15 @@
+from . import StoppingMethod
+
+class TrainStopStoppingMethod(StoppingMethod):
+    """
+    Stopping method that triggers whenever the training cost gets to 0, that is
+    the perceptron found a global minimum and will no longer try to improve,
+    rendering validation-related stopping methods unusable.
+    """
+
+    def requires_validation(self) -> bool:
+        return False
+
+    def should_stop(self, n_epochs: int, train_cost: float,
+                    validation_cost: float) -> bool:
+        return train_cost <= 0

sklearn_morpho/tests/moons_test.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+from sklearn_morpho.classifiers.ldep import LDEP
+from sklearn.datasets import make_moons
+
+from sklearn_morpho.stopping import (
+        CostStoppingMethod,
+        EpochStoppingMethod,
+        TrainStopStoppingMethod,
+)
+
+def test_moons(runs=10, n_samples=500):
+    dep = LDEP(validation_ratio=0, stopping_methods=[
+        CostStoppingMethod(1e-6),
+        EpochStoppingMethod(20),
+        TrainStopStoppingMethod(),
+    ])
+
+    for _ in range(runs):
+        X, y = make_moons(n_samples=n_samples)
+        dep.fit(X, y)
+
+        fails = X.shape[0] - np.sum(dep.predict(X) == y)
+        assert fails == 0
+
+    # TODO will most likely fail the test, will get back to this
+    # basically sometimes the matrices get really big, but adding their norm to
+    # the cost makes things converge slower and epochs very expensive

sklearn_morpho/tests/sklearn_test.py

@@ -0,0 +1,19 @@
+from sklearn.utils.estimator_checks import check_estimator
+
+from sklearn_morpho.classifiers.ldep import LDEP
+from sklearn_morpho.stopping import (
+        CostStoppingMethod,
+        EpochStoppingMethod,
+        TrainStopStoppingMethod,
+)
+
+
+def test_check_estimator():
+    ldep = LDEP(validation_ratio=0,
+                stopping_methods=[
+                    CostStoppingMethod(1e-6),
+                    EpochStoppingMethod(20),
+                    TrainStopStoppingMethod(),
+                ])
+
+    assert check_estimator(ldep)

sklearn_morpho/tests/train_test.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+from sklearn_morpho.classifiers.ldep import LDEP
+from sklearn.datasets import make_classification
+
+def test_train_separable_dataset(n_samples=500):
+    # use a random state to guarantee a separable dataset
+    random_state = np.random.RandomState(11)
+    X, y = make_classification(n_samples=n_samples, n_features=2, n_redundant=0,
+                               n_classes=2, n_clusters_per_class=1,
+                               random_state=random_state)
+
+    classifier = LDEP(random_state=random_state)
+    classifier.fit(X, y)
+
+    fails = X.shape[0] - np.sum(classifier.predict(X) == y)
+    assert fails == 0

sklearn_morpho/weighting/__init__.py

@@ -0,0 +1,3 @@
+from .weighting_base import SampleWeighting
+from .weighting_dist import DistSampleWeighting
+from .weighting_none import NoneSampleWeighting

sklearn_morpho/weighting/weighting_base.py

@@ -0,0 +1,45 @@
+import numpy as np
+from abc import ABC
+
+from sklearn.base import OneToOneFeatureMixin, TransformerMixin, BaseEstimator
+
+WeightingResult = tuple[np.ndarray, float]
+
+class SampleWeighting(ABC, OneToOneFeatureMixin, TransformerMixin,
+                      BaseEstimator):
+    """
+    Abstract class for transformers that convert data points to a set of
+    respective weights.
+    These weights may be used as the cost contribution in a DCCP problem.
+
+    For example, a sample weighting with functionality `np.full(len(X), 1)`
+    corresponds to no weighting at all.
+
+    The fit() method must create both:
+    - self.weights_: np.ndarray
+    - self.cost_normalizer_: float
+
+    If the implementation does not follow these guidelines, the weighting should
+    still be able to provide a WeightingResult as the return value of
+    transform().
+    In this case, you are free to override the transform() and fit_transform()
+    methods containing boilerplate code.
+    """
+
+    # for LSPs
+    def __init__(self):
+        self.weights_: np.ndarray
+        self.cost_normalizer_: float
+
+    def transform(self, X: np.ndarray | None) -> WeightingResult:
+        if X is not None:
+            raise ValueError(f'{self.__class__.__name__}: only supports '
+                             'fitting and transforming the same data, do not '
+                             'specify it in transform()')
+
+        return self.weights_, self.cost_normalizer_
+
+    # override this to make fit_transform usable but still prevent wrong usage
+    def fit_transform(self, X: np.ndarray, y: np.ndarray) -> WeightingResult:
+        self.fit(X, y)
+        return self.transform(None)

sklearn_morpho/weighting/weighting_dist.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+from . import SampleWeighting
+
+class DistSampleWeighting(SampleWeighting):
+    """
+    Weighting method that weights its inputs inversely proportionally to the
+    distance to their class' centroid.
+    """
+
+    def fit(self, X: np.ndarray, y: np.ndarray) -> DistSampleWeighting:
+        # compute centroids, there should be no classes with no elements thanks
+        # to sklearn checks if used in the intended way with a compatible
+        # estimator
+        labels, inv, counts = np.unique(y, return_inverse=True,
+                                        return_counts=True)
+        sums = np.zeros((len(labels), X.shape[1]))
+        np.add.at(sums, inv, X)
+        centroids = sums / counts[:, np.newaxis]
+
+        # inverse distance from each data point to its respective class centroid
+        self.weights_ = 1 / (1e-6 + np.linalg.norm(X - centroids[y], axis=1))
+        max_centroid_w = np.array([self.weights_[y == y_].max()
+                                   for y_ in range(2)])
+        self.weights_ /= max_centroid_w[y]
+
+        cost_normalizer = self.weights_.sum()
+        if np.isclose(cost_normalizer, 0):
+            self.cost_normalizer_ = 1
+        else:
+            self.cost_normalizer_ = cost_normalizer
+
+        return self

sklearn_morpho/weighting/weighting_none.py

@@ -0,0 +1,14 @@
+import numpy as np
+
+from . import SampleWeighting
+
+class NoneSampleWeighting(SampleWeighting):
+    """
+    Weighting method that does not weight its inputs.
+    """
+
+    def fit(self, X: np.ndarray, y: np.ndarray) -> NoneSampleWeighting:
+        self.weights_ = np.ones(len(X))
+        self.cost_normalizer_ = 1
+
+        return self

sklearn_morpho-0.1.0.dist-info/METADATA

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: sklearn-morpho
+Version: 0.1.0
+License-File: LICENSE

sklearn_morpho-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+sklearn_morpho/__init__.py,sha256=ecP48uQBEYLb6b2ZOU4M3gd66oO_Nes_ayK6BsQ7XJU,84
+sklearn_morpho/classifiers/ldep.py,sha256=N0FRkQAKvmGcxYbAdzJypn8fCEZs9JuFQCpR8gIs554,7613
+sklearn_morpho/dccp/dccp_ldep.py,sha256=XqbF_kNa_jLy6721IiEUHa5QbwmeIXUACO9lE2I5flY,6986
+sklearn_morpho/dccp/dccp_wrapper.py,sha256=i8GwbEH4q0q3N3yqhY2dcCnL1aeLppXTHy1f7iDWqJE,8814
+sklearn_morpho/stopping/__init__.py,sha256=N4B8zlC7Q0-fJgn5O7h4Uk_CYMTP3yeB9-CaziigfHA,241
+sklearn_morpho/stopping/stopping_base.py,sha256=INPU9XvHEnnOqZ4CMSVm5-xlw7UdPQyGsFoEG6_Vzdo,560
+sklearn_morpho/stopping/stopping_cost.py,sha256=pSrp2NAF0d3H_JoMm3BcIFVszB3fqg_rlOZVuXIg24M,668
+sklearn_morpho/stopping/stopping_early.py,sha256=yUE9EaNRFtmkLbJQIvd5F5Sy0PLka1wbuwD_9IaLOtM,1104
+sklearn_morpho/stopping/stopping_epoch.py,sha256=dkJ7nW60KzfQotQwwnHS9Fvg2_EK-l6AdHgoEFs2mW0,638
+sklearn_morpho/stopping/stopping_train_stop.py,sha256=ElPYiRUjoDTvwTqUszo2RrG9N8fOcZwq7YzHWJ9udoo,520
+sklearn_morpho/tests/moons_test.py,sha256=xxKO3vNjTIcEPTmyS6HB3r_DiD82uVdQ8szfrVl5Pig,840
+sklearn_morpho/tests/sklearn_test.py,sha256=pISK-F6wjVCIzeAfeR7J0ObEozi0lTRAkCpaelotEGY,531
+sklearn_morpho/tests/train_test.py,sha256=GgZRo82wD-1ztmsWt_WwO4YAJSlx70T0_-F1sGemZoc,636
+sklearn_morpho/weighting/__init__.py,sha256=AzWBDUf33vC6hnNHfC6TftpqFODTsbeV-D_TW4Ao5Tc,140
+sklearn_morpho/weighting/weighting_base.py,sha256=928tUWDI3-bj3HahvDuOf_XtjeLk21MQ-ymNTcEc37g,1654
+sklearn_morpho/weighting/weighting_dist.py,sha256=PIwEU7gmwjWz3eRkzbDgqiG5zg894CChMBGRc5AHZUI,1268
+sklearn_morpho/weighting/weighting_none.py,sha256=1AgORveFg8EHtSr-GqdI1GjhWadzwLgryyIo0o0OE7U,333
+sklearn_morpho-0.1.0.dist-info/METADATA,sha256=p8hzjB7yxlN6Tu2P1EuIfrcCM6sdIbbBJ70HSAfWa7w,80
+sklearn_morpho-0.1.0.dist-info/WHEEL,sha256=e22IIVjxDyt0lABi4WpktFIGsmO_ebSDXLnPUbPK0E0,105
+sklearn_morpho-0.1.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+sklearn_morpho-0.1.0.dist-info/RECORD,,

sklearn_morpho-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

sklearn_morpho-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.