sklearn-morpho 0.2.1__tar.gz → 0.2.2__tar.gz

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = python-sklearn-morpho
 	pkgdesc = Scikit-learn estimator toolbox for morphological perceptrons
-	pkgver = 0.2.0
+	pkgver = 0.2.1
 	pkgrel = 1
 	url = https://github.com/d-002/sklearn-morpho
 	arch = any
@@ -13,7 +13,7 @@ pkgbase = python-sklearn-morpho
 	depends = python-cvxpy
 	depends = python-pytest
 	depends = python-scikit-learn
-	source = https://files.pythonhosted.org/packages/source/s/sklearn_morpho/sklearn_morpho-0.2.0.tar.gz
-	sha256sums = 0bba96bdf9e0d0c982276da7b7503c1812c337071bca4e813b2eb6eb0ab8e6bd
+	source = https://files.pythonhosted.org/packages/source/s/sklearn_morpho/sklearn_morpho-0.2.1.tar.gz
+	sha256sums = aaf94e85e2f546928ace464bf776c08681cd5349a48012076c3c66a9e801961f
 
 pkgname = python-sklearn-morpho

sklearn_morpho-0.2.2/.github/workflows/ci.yml

@@ -0,0 +1,90 @@
+name: CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "**" ]
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install Hatch
+        run: python -m pip install hatch
+
+      - name: Run tests
+        run: hatch run pytest
+
+  coverage:
+    name: Coverage test, ignore failed tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install Hatch
+        run: python -m pip install hatch
+
+      - name: Install coverage utilities
+        run: python -m pip install coverage
+
+      - name: Check coverage
+        run: |
+          hatch run pytest --cov --cov-fail-under=90
+
+  todo:
+    name: Check for TODOs in code
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Scan for TODOs in the code
+        run: ./check_todos.sh
+
+  linter:
+    name: Check for ${{ matrix.name }} errors
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - name: "linting"
+            command: "python -m ruff check"
+          - name: "coding style"
+            command: "[ -z \"$(python -m ruff format | grep reformatted)\" ]"
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install linter
+        run: python -m pip install ruff
+
+      - name: Run linter for coding style errors
+        run: ${{ matrix.command }}

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/.gitignore

@@ -1,7 +1,8 @@
 # python
 __pycache__
-venv
 *.pyc
+.coverage
+htmlcov
 
 # vim
 *.swp

sklearn_morpho-0.2.2/.qbuild/scripts/coverage

@@ -0,0 +1 @@
+hatch run pytest --cov --cov-report=html && xdg-open htmlcov/index.html

sklearn_morpho-0.2.2/.qbuild/scripts/main

@@ -0,0 +1 @@
+python testing/display_boundary.py

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/MREs/l-DEP.ipynb

@@ -66,7 +66,7 @@
    "source": [
     "random_state = np.random.RandomState(42)\n",
     "\n",
-    "X, y = make_moons(n_samples=1000, noise=.2, random_state=random_state)\n",
+    "X, y = make_moons(n_samples=1000, noise=0.2, random_state=random_state)\n",
     "y = np.array(['red', 'blue'])[y]"
    ]
   },
@@ -890,7 +890,8 @@
     "ldep = LDEP(verbose=1, random_state=random_state)\n",
     "\n",
     "X_train, X_test, y_train, y_test = train_test_split(\n",
-    "    X, y, test_size=.3, random_state=random_state)\n",
+    "    X, y, test_size=0.3, random_state=random_state\n",
+    ")\n",
     "\n",
     "ldep.fit(X_train, y_train)"
    ]
@@ -926,12 +927,7 @@
    ],
    "source": [
     "ldep_dccp = LDEP(use_dccp_library=True, verbose=1, random_state=random_state)\n",
-    "\n",
-    "# ignore warnings coming from the DCCP library\n",
-    "import warnings\n",
-    "with warnings.catch_warnings(action=\"ignore\"):\n",
-    "    ldep_dccp.fit(X_train, y_train)\n",
-    "del warnings"
+    "ldep_dccp.fit(X_train, y_train)"
    ]
   },
   {
@@ -991,7 +987,9 @@
    "outputs": [],
    "source": [
     "score_test = f1_score(y_test, ldep.predict(X_test), pos_label=np.unique(y)[1])\n",
-    "score_test_dccp = f1_score(y_test, ldep_dccp.predict(X_test), pos_label=np.unique(y)[1])"
+    "score_test_dccp = f1_score(\n",
+    "    y_test, ldep_dccp.predict(X_test), pos_label=np.unique(y)[1]\n",
+    ")"
    ]
   },
   {
@@ -1031,18 +1029,20 @@
    ],
    "source": [
     "for name, estimator, score in (\n",
-    "        ('l-DEP with manual linearization', ldep, score_test),\n",
-    "        ('l-DEP with dccp library', ldep_dccp, score_test_dccp)\n",
+    "    ('l-DEP with manual linearization', ldep, score_test),\n",
+    "    ('l-DEP with dccp library', ldep_dccp, score_test_dccp),\n",
     "):\n",
     "    # draw the decision boundary\n",
     "    disp = DecisionBoundaryDisplay.from_estimator(\n",
-    "        estimator, X_test, response_method='decision_function',\n",
+    "        estimator,\n",
+    "        X_test,\n",
+    "        response_method='decision_function',\n",
     "        grid_resolution=200,\n",
     "        plot_method='contour',\n",
     "        levels=[0],\n",
-    "        colors='black'\n",
+    "        colors='black',\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    # add the points\n",
     "    ax = disp.ax_\n",
     "    ax.scatter(*X_test.T, color=y_test)\n",
@@ -1067,7 +1067,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.14.5"
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/MREs/r-DEP.ipynb

@@ -62,7 +62,7 @@
    "source": [
     "random_state = np.random.RandomState(42)\n",
     "\n",
-    "X, y = make_moons(n_samples=1000, noise=.2, random_state=random_state)\n",
+    "X, y = make_moons(n_samples=1000, noise=0.2, random_state=random_state)\n",
     "y = np.array(['red', 'blue'])[y]"
    ]
   },
@@ -889,7 +889,8 @@
     "rdep = RDEP(verbose=1, random_state=random_state)\n",
     "\n",
     "X_train, X_test, y_train, y_test = train_test_split(\n",
-    "    X, y, test_size=.3, random_state=random_state)\n",
+    "    X, y, test_size=0.3, random_state=random_state\n",
+    ")\n",
     "\n",
     "rdep.fit(X_train, y_train)"
    ]
@@ -925,12 +926,7 @@
    ],
    "source": [
     "rdep_dccp = RDEP(use_dccp_library=True, verbose=1, random_state=random_state)\n",
-    "\n",
-    "# ignore warnings coming from the DCCP library\n",
-    "import warnings\n",
-    "with warnings.catch_warnings(action=\"ignore\"):\n",
-    "    rdep_dccp.fit(X_train, y_train)\n",
-    "del warnings"
+    "rdep_dccp.fit(X_train, y_train)"
    ]
   },
   {
@@ -990,7 +986,9 @@
    "outputs": [],
    "source": [
     "score_test = f1_score(y_test, rdep.predict(X_test), pos_label=np.unique(y)[1])\n",
-    "score_test_dccp = f1_score(y_test, rdep_dccp.predict(X_test), pos_label=np.unique(y)[1])"
+    "score_test_dccp = f1_score(\n",
+    "    y_test, rdep_dccp.predict(X_test), pos_label=np.unique(y)[1]\n",
+    ")"
    ]
   },
   {
@@ -1030,18 +1028,20 @@
    ],
    "source": [
     "for name, estimator, score in (\n",
-    "        ('r-DEP with manual linearization', rdep, score_test),\n",
-    "        ('r-DEP with dccp library', rdep_dccp, score_test_dccp)\n",
+    "    ('r-DEP with manual linearization', rdep, score_test),\n",
+    "    ('r-DEP with dccp library', rdep_dccp, score_test_dccp),\n",
     "):\n",
     "    # draw the decision boundary\n",
     "    disp = DecisionBoundaryDisplay.from_estimator(\n",
-    "        estimator, X_test, response_method='decision_function',\n",
+    "        estimator,\n",
+    "        X_test,\n",
+    "        response_method='decision_function',\n",
     "        grid_resolution=200,\n",
     "        plot_method='contour',\n",
     "        levels=[0],\n",
-    "        colors='black'\n",
+    "        colors='black',\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    # add the points\n",
     "    ax = disp.ax_\n",
     "    ax.scatter(*X_test.T, color=y_test)\n",
@@ -1066,7 +1066,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.14.5"
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/MREs/simple_perceptron.ipynb

@@ -64,7 +64,7 @@
    "source": [
     "random_state = np.random.RandomState(42)\n",
     "\n",
-    "X, y = make_moons(n_samples=1000, noise=.2, random_state=random_state)\n",
+    "X, y = make_moons(n_samples=1000, noise=0.2, random_state=random_state)\n",
     "y = np.array(['red', 'blue'])[y]"
    ]
   },
@@ -907,7 +907,8 @@
     "perceptron_min = MP(kind='min', verbose=1, random_state=random_state)\n",
     "\n",
     "X_train, X_test, y_train, y_test = train_test_split(\n",
-    "    X, y, test_size=.3, random_state=random_state)\n",
+    "    X, y, test_size=0.3, random_state=random_state\n",
+    ")\n",
     "\n",
     "perceptron_max.fit(X_train, y_train)\n",
     "perceptron_min.fit(X_train, y_train)"
@@ -969,8 +970,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "score_test_max = f1_score(y_test, perceptron_max.predict(X_test), pos_label=np.unique(y)[1])\n",
-    "score_test_min = f1_score(y_test, perceptron_min.predict(X_test), pos_label=np.unique(y)[1])"
+    "score_test_max = f1_score(\n",
+    "    y_test, perceptron_max.predict(X_test), pos_label=np.unique(y)[1]\n",
+    ")\n",
+    "score_test_min = f1_score(\n",
+    "    y_test, perceptron_min.predict(X_test), pos_label=np.unique(y)[1]\n",
+    ")"
    ]
   },
   {
@@ -1010,18 +1015,20 @@
    ],
    "source": [
     "for name, estimator, score in (\n",
-    "        ('dilation perceptron', perceptron_max, score_test_max),\n",
-    "        ('erosion perceptron', perceptron_min, score_test_min)\n",
+    "    ('dilation perceptron', perceptron_max, score_test_max),\n",
+    "    ('erosion perceptron', perceptron_min, score_test_min),\n",
     "):\n",
     "    # draw the decision boundary\n",
     "    disp = DecisionBoundaryDisplay.from_estimator(\n",
-    "        estimator, X_test, response_method='decision_function',\n",
+    "        estimator,\n",
+    "        X_test,\n",
+    "        response_method='decision_function',\n",
     "        grid_resolution=200,\n",
     "        plot_method='contour',\n",
     "        levels=[0],\n",
-    "        colors='black'\n",
+    "        colors='black',\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    # add the points\n",
     "    ax = disp.ax_\n",
     "    ax.scatter(*X_test.T, color=y_test)\n",

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/MREs/train_multiclass.ipynb

@@ -60,7 +60,8 @@
     "X, y = fetch_openml('diabetes', version=1, return_X_y=True, as_frame=False)\n",
     "\n",
     "X_train, X_test, y_train, y_test = train_test_split(\n",
-    "    X, y, test_size=.3, random_state=random_state)"
+    "    X, y, test_size=0.3, random_state=random_state\n",
+    ")"
    ]
   },
   {

sklearn_morpho-0.2.2/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: sklearn-morpho
+Version: 0.2.2
+License-File: LICENSE
+Requires-Dist: cvxpy<2.0.0,>=1.9.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: scikit-learn<2.0.0,>=1.8.0
+Provides-Extra: dccp
+Requires-Dist: dccp<2.0.0,>=1.1.1; extra == 'dccp'
+Requires-Dist: pytest<10.0.0,>=9.0.0; extra == 'dccp'

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/PKGBUILD

@@ -1,6 +1,6 @@
 pkgname=python-sklearn-morpho
 _name=sklearn_morpho
-pkgver=0.2.1
+pkgver=0.2.2
 pkgrel=1
 pkgdesc="Scikit-learn estimator toolbox for morphological perceptrons"
 arch=("any")
@@ -9,7 +9,7 @@ license=("MIT")
 depends=("python" "python-cvxpy" "python-pytest" "python-scikit-learn")
 makedepends=("python-build" "python-installer" "python-wheel" "python-hatchling")
 source=("https://files.pythonhosted.org/packages/source/${_name::1}/${_name}/${_name}-${pkgver}.tar.gz")
-sha256sums=('0bba96bdf9e0d0c982276da7b7503c1812c337071bca4e813b2eb6eb0ab8e6bd')
+sha256sums=('aaf94e85e2f546928ace464bf776c08681cd5349a48012076c3c66a9e801961f')
 
 build() {
   cd "${_name}-${pkgver}"

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/README.md

@@ -6,37 +6,18 @@ scikit-learn estimator toolbox for morphological perceptrons.
 ![](https://img.shields.io/aur/version/python-sklearn-morpho?style=flat-square)
 ![](https://img.shields.io/github/actions/workflow/status/d-002/sklearn-morpho/ci.yml?style=flat-square)
 
-> [!WARNING]  
-> Some features of this repository use the `dccp` module.
->
-> As of writing this (June 2026) the PyPI package has not been updated since
-> 2025 ([this commit](https://github.com/cvxgrp/dccp/commit/4322809)).
-> This means that currently the `dccp` module uses `cvxpy.reshape` with soon to
-> be outdated parameters.
->
-> As of writing this, when using this solver warnings from cvxpy are displayed,
-> however these warnings are projected to be removed in future `cvxpy` versions,
-> which may create silent errors during training.
->
-> I will leave this notice here until the `dccp` library's maintainer team
-> decides to update the package.
-> Please let me know if that is the case and I did not remove the notice.
-> See also: [issue](https://github.com/cvxgrp/dccp/issues/127)
->
-> If you wish to use the solver in its current state without the warnings, you
-> can manually clone the dccp repo into the hatch venv.
-
 Current features:
 
 - Scikit-learn estimators:
   - Linear Dilation-Erosion Perceptron (l-DEP)
   - Reduced Dilation-Erosion Perceptron (r-DEP)
-  - Simple dilation and erosion morphological perceptrons
+  - Simple Dilation and Erosion Morphological Perceptrons
 - Modular wrapper for DCCP optimization tasks with `cvxpy`
 
 File tree:
 
-- `src/sklearn_morpho`: contains the source code and a testsuite in `.../tests`
+- `src/sklearn_morpho`: contains the source code and a testsuite in its `tests`
+  subdirectory.
 - `testing`: standalone files that use this library, may contain tests but they
   are not designed to be run as a CI testsuite for example.
 - `MREs`: standalone jupyter notebooks to showcase some of this library's
@@ -45,7 +26,7 @@ File tree:
 ## Getting started
 
 Take a look at the Jupyter code examples in the
-[`MREs`](https://github.com/d-002/sklearn-morpho/tree/master/MREs) directory.
+[MREs](https://github.com/d-002/sklearn-morpho/tree/master/MREs) directory.
 
 ## Running the project
 
@@ -64,7 +45,8 @@ files to avoid training the estimators every time one wants to view the results.
 
 The package is available in the
 [Arch User Repository](https://aur.archlinux.org) as `python-sklearn-morpho`, as
-are all its dependencies except `dccp`.
+are all its dependencies not already in the official packages, except for
+`dccp`.
 
 Since the latter is an optional dependency, you can either:
 

sklearn_morpho-0.2.2/pyproject.toml

@@ -0,0 +1,49 @@
+# General
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sklearn-morpho"
+version = "0.2.2"
+dependencies = [
+    "cvxpy>=1.9.0,<2.0.0",
+    "numpy>=2.0.0",
+    "scikit-learn>=1.8.0,<2.0.0",
+]
+
+[project.optional-dependencies]
+dccp = [
+    "dccp>=1.1.1,<2.0.0",
+    "pytest>=9.0.0,<10.0.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.hatch.envs.default]
+python = "3.13"
+path = ".venv" # for LSPs
+dependencies = [
+    "dccp>=1.1.1,<2.0.0",
+    "jupyterlab>=4.5.0,<5.0.0", # for coding the MREs
+    "matplotlib>=3.10.0,<4.0.0", # for files in testing
+    "pandas>=3.0.0", # for scikit-learn's check_estimator and openml datasets
+    "pyqt6>=6.11.0,<7.0.0", # for matplotlib display on some devices
+    "pytest>=9.0.0,<10.0.0",
+    "pytest-cov>=7.1.0,<8.0.0",
+    "ruff>=0.15.0,<1.0.0", # linter
+]
+
+# Ruff
+[tool.ruff]
+indent-width = 4
+line-length = 80
+
+[tool.ruff.lint]
+select = ["E"]
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"

sklearn_morpho-0.2.2/src/sklearn_morpho/__init__.py

@@ -0,0 +1,5 @@
+from .classifiers import (
+    LDEP as LDEP,
+    RDEP as RDEP,
+    MorphoPerceptron as MorphoPerceptron,
+)

sklearn_morpho-0.2.2/src/sklearn_morpho/classifiers/__init__.py

@@ -0,0 +1,3 @@
+from .ldep import LDEP as LDEP
+from .rdep import RDEP as RDEP
+from .simple_perceptron import MorphoPerceptron as MorphoPerceptron

{sklearn_morpho-0.2.1 → sklearn_morpho-0.2.2}/src/sklearn_morpho/classifiers/ldep.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import numpy as np
 from typing import Literal, cast
 
@@ -7,16 +9,17 @@ 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 ..training.dccp_ldep import LDEPDccpTrainer
 from ..stopping import (
-        StoppingMethod,
-        CostStoppingMethod,
-        EarlyStoppingMethod,
-        EpochStoppingMethod,
-        TrainStopStoppingMethod,
+    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
@@ -35,12 +38,18 @@ class LDEP(ClassifierMixin, BaseEstimator):
     times, but will allow the decision boundary to be more complex.
     """
 
-    def __init__(self, latent_dims: tuple[int, int] = (10, 10), margin = 1.,
-                 penalty = 0., validation_ratio = .3,
-                 weighting_method: SampleWeighting | None = None,
-                 stopping_methods: list[StoppingMethod] | None = None,
-                 use_dccp_library: bool = False, verbose: Literal[0, 1, 2] = 0,
-                 random_state: np.random.RandomState | None = None) -> None:
+    def __init__(
+        self,
+        latent_dims: tuple[int, int] = (10, 10),
+        margin=1.0,
+        penalty=0.0,
+        validation_ratio=0.3,
+        weighting_method: SampleWeighting | None = None,
+        stopping_methods: list[StoppingMethod] | None = None,
+        use_dccp_library: bool = False,
+        verbose: Literal[0, 1, 2] = 0,
+        random_state: np.random.RandomState | None = None,
+    ) -> None:
         """
         Initialize the classifier, see class help for more.
 
@@ -70,9 +79,9 @@ class LDEP(ClassifierMixin, BaseEstimator):
                                 to the epoch with the best validation cost.
                                 If left to None, will use:
                                 [
-                                    CostStoppingMethod(1e-6),
-                                    EarlyStoppingMethod(5),
-                                    EpochStoppingMethod(20),
+                                    CostStoppingMethod(),
+                                    EarlyStoppingMethod(),
+                                    EpochStoppingMethod(),
                                     TrainStopStoppingMethod(),
                                 ]
                                 Ignored when using the dccp library solver.
@@ -110,7 +119,7 @@ class LDEP(ClassifierMixin, BaseEstimator):
 
         # input data validation
         random_state = check_random_state(self.random_state)
-        X, y = validate_data(self, X, y) # type: ignore
+        X, y = validate_data(self, X, y)  # type: ignore
         self.scaler_ = StandardScaler()
         X_scaled = self.scaler_.fit_transform(X)
 
@@ -121,9 +130,9 @@ class LDEP(ClassifierMixin, BaseEstimator):
             weighting_method = self.weighting_method
         if self.stopping_methods is None:
             stopping_methods = [
-                CostStoppingMethod(1e-6),
-                EarlyStoppingMethod(5),
-                EpochStoppingMethod(20),
+                CostStoppingMethod(),
+                EarlyStoppingMethod(),
+                EpochStoppingMethod(),
                 TrainStopStoppingMethod(),
             ]
         else:
@@ -133,18 +142,27 @@ class LDEP(ClassifierMixin, BaseEstimator):
         # 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)
+        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).')
+            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.penalty, self.validation_ratio,
-            weighting_method, stopping_methods, self.use_dccp_library,
-            self.verbose, random_state
+            self.latent_dims,
+            self.margin,
+            self.penalty,
+            self.validation_ratio,
+            weighting_method,
+            stopping_methods,
+            self.use_dccp_library,
+            self.verbose,
+            random_state,
         )
 
         trainer.train(X_scaled, y_integers)
@@ -158,13 +176,15 @@ class LDEP(ClassifierMixin, BaseEstimator):
 
     def decision_function(self, X: np.ndarray) -> np.ndarray:
         check_is_fitted(self)
-        X = validate_data(self, X, reset=False) # type: ignore
+        X = validate_data(self, X, reset=False)  # type: ignore
         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)
+        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: