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

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

@@ -1,6 +1,6 @@
 pkgbase = python-sklearn-morpho
 	pkgdesc = Scikit-learn estimator toolbox for morphological perceptrons
-	pkgver = 0.2.1
+	pkgver = 0.2.2
 	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.1.tar.gz
-	sha256sums = aaf94e85e2f546928ace464bf776c08681cd5349a48012076c3c66a9e801961f
+	source = https://files.pythonhosted.org/packages/source/s/sklearn_morpho/sklearn_morpho-0.2.2.tar.gz
+	sha256sums = 4dc5a155a32332c4da33f375c7e4e83af15fa2a0ea8bb68f1843e74d0b47bce9
 
 pkgname = python-sklearn-morpho

sklearn_morpho-0.2.3/.gitattributes

@@ -0,0 +1 @@
+*.ipynb linguist-vendored

sklearn_morpho-0.2.3/.github/workflows/code_quality.yml

@@ -0,0 +1,47 @@
+name: Code quality
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  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
+
+  lint:
+    name: Check for ${{ matrix.name }} errors
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      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"
+          cache: "pip"
+
+      - name: Install linter
+        run: pip install ruff
+
+      - name: Run linter for coding style errors
+        run: ${{ matrix.command }}

sklearn_morpho-0.2.2/.github/workflows/pypi-publish.yml → sklearn_morpho-0.2.3/.github/workflows/pypi_publish.yml

@@ -20,7 +20,8 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.14'
+          python-version: "3.13"
+          cache: "pip"
 
       - name: Install Hatch
         run: pip install -U pip hatch

sklearn_morpho-0.2.3/.github/workflows/tests.yml

@@ -0,0 +1,68 @@
+name: Testsuite
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    name: Python ${{ matrix.python-version }} on ${{ matrix.os }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ "ubuntu-latest" ]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+        # also test on other OSes, but not for all versions to save minutes
+        include:
+          - os: windows-latest
+            python-version: "3.13"
+          - os: macos-latest
+            python-version: "3.13"
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip"
+
+      - name: Install Hatch
+        run: pip install hatch
+
+      - name: Run tests with Hatch
+        run: |
+          if [ "${{ matrix.os }}" = "ubuntu-latest" ]; then
+            hatch run test.py${{ matrix.python-version }}:pytest
+          else
+            hatch run pytest
+          fi
+
+  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"
+          cache: "pip"
+
+      - name: Install Hatch
+        run: pip install hatch
+
+      - name: Install coverage utilities
+        run: pip install coverage
+
+      - name: Check coverage
+        run: |
+          hatch run pytest --cov --cov-fail-under=90

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

@@ -20,7 +20,7 @@ dccp.log
 WDBC.dat.txt
 
 # comparison
-comparison_data.json
+comparison.json
 
 # jupyter
 .ipynb_checkpoints

sklearn_morpho-0.2.3/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: sklearn-morpho
+Version: 0.2.3
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+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'
+Description-Content-Type: text/markdown
+
+# sklearn-morpho
+
+Scikit-learn classifiers toolbox for morphological perceptrons.
+
+## Current features
+
+- Scikit-learn classifiers:
+  - Linear Dilation-Erosion Perceptron (l-DEP)
+  - Reduced Dilation-Erosion Perceptron (r-DEP)
+  - Simple Dilation and Erosion Morphological Perceptrons
+- Modular wrapper for DCCP optimization tasks with `cvxpy`
+
+More information and explanations
+[here](https://github.com/d-002/sklearn-morpho).

{sklearn_morpho-0.2.2 → sklearn_morpho-0.2.3}/PKGBUILD

@@ -1,15 +1,15 @@
 pkgname=python-sklearn-morpho
 _name=sklearn_morpho
-pkgver=0.2.2
+pkgver=0.2.3
 pkgrel=1
 pkgdesc="Scikit-learn estimator toolbox for morphological perceptrons"
 arch=("any")
 url="https://github.com/d-002/sklearn-morpho"
 license=("MIT")
-depends=("python" "python-cvxpy" "python-pytest" "python-scikit-learn")
+depends=("python" "python-cvxpy" "python-numpy" "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=('aaf94e85e2f546928ace464bf776c08681cd5349a48012076c3c66a9e801961f')
+sha256sums=('4dc5a155a32332c4da33f375c7e4e83af15fa2a0ea8bb68f1843e74d0b47bce9')
 
 build() {
   cd "${_name}-${pkgver}"

sklearn_morpho-0.2.3/README-PyPI.md

@@ -0,0 +1,14 @@
+# sklearn-morpho
+
+Scikit-learn classifiers toolbox for morphological perceptrons.
+
+## Current features
+
+- Scikit-learn classifiers:
+  - Linear Dilation-Erosion Perceptron (l-DEP)
+  - Reduced Dilation-Erosion Perceptron (r-DEP)
+  - Simple Dilation and Erosion Morphological Perceptrons
+- Modular wrapper for DCCP optimization tasks with `cvxpy`
+
+More information and explanations
+[here](https://github.com/d-002/sklearn-morpho).

sklearn_morpho-0.2.3/README.md

@@ -0,0 +1,101 @@
+# sklearn-morpho
+
+Scikit-learn classifiers toolbox for [morphological perceptrons](#what-are-morphological-perceptrons).
+
+![PyPI package](https://img.shields.io/pypi/v/sklearn-morpho?style=flat-square)
+![Supported Python version](https://img.shields.io/pypi/pyversions/sklearn-morpho?style=flat-square)
+![AUR package](https://img.shields.io/aur/version/python-sklearn-morpho?style=flat-square)  
+![Code quality](https://img.shields.io/github/actions/workflow/status/d-002/sklearn-morpho/code_quality.yml?style=flat-square&label=Code%20quality)
+![Tests](https://img.shields.io/github/actions/workflow/status/d-002/sklearn-morpho/tests.yml?style=flat-square&label=Tests)
+
+## Current features
+
+- Scikit-learn classifiers:
+  - Linear Dilation-Erosion Perceptron (l-DEP)
+  - Reduced Dilation-Erosion Perceptron (r-DEP)
+  - 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 its `tests`
+  subdirectory.
+- `tests`: pytest testsuite.
+- `testing`: standalone files that use this library.
+  They are used internally for testing, but they are not tests nor part of the
+  library.
+- `MREs`: standalone jupyter notebooks to showcase some of this library's
+  features.
+
+## Getting started
+
+Take a look at the Jupyter code examples in the
+[MREs](https://github.com/d-002/sklearn-morpho/tree/master/MREs) directory.
+
+## Running the project
+
+Install Python 3 and hatch.
+Then run one of these commands:
+
+- `hatch run jupyter lab` to run the Jupyter notebooks
+- `hatch run pytest` for tests
+- `hatch shell` to run testing files like `testing/display_boundary.py` in the
+  right environment.
+
+Special note for the estimators comparison testing files: they are split in two
+files to avoid training the estimators every time one wants to view the results.
+
+## Contributing
+
+As the project is open source, any help is greatly appreciated!
+
+To keep code clean, this repository uses a CI/CD pipeline with tests and an
+enforced coding style, which can all be found in the project's configuration
+files.
+
+Please adhere to these rules when contributing.
+
+Regarding AI pull requests, they are generally discouraged as you should be able
+to understand and help maintaining any features you add to this repo.
+
+## For Arch users
+
+The Python package is available in the
+[Arch User Repository](https://aur.archlinux.org) as `python-sklearn-morpho`, as
+are all its dependencies not already in the official packages, except for
+`dccp`.
+
+Since the latter is an optional dependency, you can either:
+
+- Download `dccp` through pip or use `pip install sklearn-morpho[dccp]` in a
+  Python virtual environment.
+- Download `python-sklearn-morpho` from the AUR and use
+  `pip install dccp --user`.
+
+## What are morphological perceptrons?
+
+Perceptrons are the fundamental building blocks of many machine learning
+constructs, namely the well-known neural networks.
+
+They fulfill this role because their simple yet effective activation function
+($y = w \cdot x + b$) allows for the emergence of arbitrarily complex behavior,
+for example when such perceptrons are wired together in networks.
+
+In the equation above, $w$ and $x$ are row and column matrices respectively,
+meaning their multiplication equates to a set of scalar multiplications,
+followed by a summation of all these multiplication results.
+
+"Morphological" perceptrons are similar to the aforedescribed "classical"
+perceptrons, but differ in the fact that they generally do not have a bias $b$,
+and most importantly that the operations performed are different:
+
+While, as established above, a classical perceptron computes several
+multiplications followed by a summation, a morphological perceptron performs
+multiple additions, followed by a $\min$ or $\max$.
+
+This simple shift into a different semiring creates a more complex decision
+boundary, making these constructs a natural choice for designing binary
+classifiers.
+
+This repository explores the behavior of such perceptrons, namely standalone
+ones, but also more complex structures, such as r-DEP and l-DEP.

{sklearn_morpho-0.2.2 → sklearn_morpho-0.2.3}/pyproject.toml

@@ -4,24 +4,35 @@
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+# Production
+
 [project]
 name = "sklearn-morpho"
-version = "0.2.2"
+version = "0.2.3"
+requires-python = ">=3.11"
 dependencies = [
     "cvxpy>=1.9.0,<2.0.0",
     "numpy>=2.0.0",
     "scikit-learn>=1.8.0,<2.0.0",
 ]
+classifiers = [
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+readme = "README-PyPI.md"
 
 [project.optional-dependencies]
 dccp = [
     "dccp>=1.1.1,<2.0.0",
-    "pytest>=9.0.0,<10.0.0",
 ]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 
+# Dev
+
 [tool.hatch.envs.default]
 python = "3.13"
 path = ".venv" # for LSPs
@@ -36,7 +47,30 @@ dependencies = [
     "ruff>=0.15.0,<1.0.0", # linter
 ]
 
+[tool.hatch.envs.default.env-vars]
+SCIPY_ARRAY_API = "1" # prevent skip warnings in check_estimator
+
+# Matrix test
+
+[tool.hatch.envs.test]
+template = "test" # break inheritance from default to ignore .venv
+features = [
+    "dccp",
+]
+dependencies = [
+    "pandas>=3.0.0",
+    "pytest>=9.0.0,<10.0.0",
+    "pytest-cov>=7.1.0,<8.0.0",
+]
+
+[tool.hatch.envs.test.env-vars]
+SCIPY_ARRAY_API = "1"
+
+[[tool.hatch.envs.test.matrix]]
+python = ["3.11", "3.12", "3.13", "3.14"]
+
 # Ruff
+
 [tool.ruff]
 indent-width = 4
 line-length = 80

{sklearn_morpho-0.2.2 → sklearn_morpho-0.2.3}/testing/compare_estimators.py

@@ -1,11 +1,13 @@
 """
 Create and train different estimators and display their respective scores
 averaged from multiple datasets.
+
 Estimators selection inspired by arxiv/2011.06512
 """
 
 import json
 import signal
+import warnings
 import numpy as np
 from time import time
 from scipy.sparse._csr import csr_matrix
@@ -24,8 +26,8 @@ from sklearn.pipeline import make_pipeline
 from sklearn.neural_network import MLPClassifier
 from sklearn.multiclass import OneVsRestClassifier
 
-FILE = 'comparison_data.json'
-n_splits = 5
+FILE = 'comparison.json'
+n_folds = 5
 timeout = 60
 
 # set up estimators and datasets
@@ -34,11 +36,11 @@ print(f'Random state: {random_state}')
 
 estimators = {
     'l-DEP': OneVsRestClassifier(LDEP(random_state=random_state)),
-    'DCCP l-DEP': OneVsRestClassifier(
+    'DCCP l_DEP': OneVsRestClassifier(
         LDEP(use_dccp_library=True, random_state=random_state)
     ),
     'r-DEP': OneVsRestClassifier(RDEP(random_state=random_state)),
-    'DCCP r-DEP': OneVsRestClassifier(
+    'DCCP r_DEP': OneVsRestClassifier(
         RDEP(use_dccp_library=True, random_state=random_state)
     ),
     'Morpho_max': OneVsRestClassifier(
@@ -133,13 +135,13 @@ signal.signal(signal.SIGALRM, timeout_handler)
 def save_data():
     with open(FILE, 'w') as f:
         json.dump(
-            {'n_splits': n_splits, 'scores': scores, 'times': times},
+            {'n_folds': n_folds, 'scores': scores, 'times': times},
             f,
             indent=2,
         )
 
 
-skf = StratifiedKFold(n_splits=n_splits)
+skf = StratifiedKFold(n_splits=n_folds)
 for dataset_name in datasets_names:
     print(f'Training with dataset "{dataset_name}"...')
     scores[dataset_name] = {}
@@ -164,22 +166,19 @@ for dataset_name in datasets_names:
             estimator,
         )
 
-        for X_fold, y_fold in skf.split(X, y):
-            X_train, X_test, y_train, y_test = train_test_split(
-                X, y, test_size=0.3, random_state=random_state
-            )
+        for i_train, i_test in skf.split(X, y):
+            X_train, X_test = X[i_train], X[i_test]
+            y_train, y_test = y[i_train], y[i_test]
 
             signal.alarm(timeout)
             t0 = time()
             try:
                 estimator.fit(X_train, y_train)
             except TimeoutException:
-                print(
-                    f'    Warning: {estimator_name} timed out after {timeout}s.'
-                )
+                warnings.warn(f'{estimator_name} timed out after {timeout}s.')
                 scores[dataset_name][estimator_name].append(0)
                 times[dataset_name][estimator_name].append(timeout)
-                continue
+                break
 
             t1 = time()
             signal.alarm(0)

sklearn_morpho-0.2.3/testing/compare_estimators_multiprocess.py

@@ -0,0 +1,368 @@
+"""
+Create and train different estimators and display their respective scores
+averaged from multiple datasets.
+Train perceptrons in parallel using multiple processes, meaning timing
+information (as well as scores depending on internal solver timeouts) may be
+inaccurate, while training will take less time.
+
+Because of the multiprocessing nature of this, timeouts are not asynchronous and
+long-running cpp code can make processing take longer than is theoretically
+permitted by the timeout.
+
+Estimators selection inspired by arxiv/2011.06512
+"""
+
+import os
+import sys
+import json
+import time
+import signal
+import warnings
+import numpy as np
+
+from time import time, sleep
+from threading import Thread
+from multiprocessing import Manager
+from joblib import Parallel, delayed
+from scipy.sparse._csr import csr_matrix
+
+from sklearn.metrics import f1_score
+from sklearn.datasets import load_breast_cancer, fetch_openml
+from sklearn.preprocessing import OrdinalEncoder
+from sklearn.model_selection import train_test_split, StratifiedKFold
+
+from sklearn_morpho import LDEP, RDEP, MorphoPerceptron
+from sklearn.svm import LinearSVC, SVC
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import make_pipeline
+from sklearn.neural_network import MLPClassifier
+from sklearn.multiclass import OneVsRestClassifier
+
+## Timeouts handling
+
+
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(sugnum, frame):
+    raise TimeoutException()
+
+
+## Configuration
+
+FILE = 'comparison.json'
+# ignore warnings for cleaner logs
+ignore_warnings = True
+n_folds = 5
+max_jobs = 15
+random_state = np.random.RandomState()
+LINE_SIZE = 100
+timeout = 60
+
+if ignore_warnings:
+    warnings.filterwarnings('ignore')
+
+print(f'Random state: {random_state}')
+print(f'Comparison data will be outputted to: "{FILE}"')
+
+## Set up datasets
+
+
+def get_clean_openml(name: str, **kwargs) -> tuple[np.ndarray, np.ndarray]:
+    kwargs.setdefault('as_frame', False)
+    kwargs.setdefault('version', 1)
+    X, y = fetch_openml(name, return_X_y=True, **kwargs)
+
+    # make sure X and y are not sparse
+    if isinstance(X, csr_matrix):
+        X = X.toarray()
+    if isinstance(y, csr_matrix):
+        y = y.toarray()
+
+    # make sure X contains only numbers, not yes/no like in australian
+    oe = OrdinalEncoder()
+    X = oe.fit_transform(X)
+
+    return X, y
+
+
+skf = StratifiedKFold(n_splits=n_folds)
+datasets_names = [
+    'acute-inflammations',
+    'australian',
+    'banana',
+    'banknote-authentication',
+    'blood-transfusion-service-center',
+    'breast-cancer',
+    'colic',
+    'credit-approval',
+    'credit-g',
+    'cylinder-bands',
+    'diabetes',
+    'eeg-eye-state',
+    'haberman',
+    'hill-valley',
+    'ilpd',
+    'ionosphere',
+    'mofn-3-7-10',
+    'monks-problems-2',
+    'mushroom',
+    'phoneme',
+    'PhishingWebsites',
+    'sick',
+    'sonar',
+    'spambase',
+    'steel-plates-fault',
+    'thoracic-surgery',
+    'tic-tac-toe',
+    'titanic',
+]
+
+# datasets not included compared to arxiv/2011.06512:
+# - chess (nonexistent)
+# - internet-advertisements (internally referring to a nonexistent dataset)
+
+datasets_options = {
+    'australian': {'version': 4},
+    'Breast_Cancer_Wisconsin': {'as_frame': True},
+    'cylinder-bands': {'version': 6},
+    'titanic': {'as_frame': True},
+}
+
+## Create estimators
+
+print('Creating estimators...')
+estimators = {
+    'l-DEP': OneVsRestClassifier(LDEP(random_state=random_state)),
+    #'DCCP l_DEP': OneVsRestClassifier(
+    #    LDEP(use_dccp_library=True, random_state=random_state)
+    # ),
+    'r-DEP': OneVsRestClassifier(RDEP(random_state=random_state)),
+    #'DCCP r_DEP': OneVsRestClassifier(
+    #    RDEP(use_dccp_library=True, random_state=random_state)
+    # ),
+    'Morpho_max': OneVsRestClassifier(
+        MorphoPerceptron(kind='max', random_state=random_state)
+    ),
+    'Morpho_min': OneVsRestClassifier(
+        MorphoPerceptron(kind='min', random_state=random_state)
+    ),
+    'Linear SVC': LinearSVC(random_state=random_state),
+    'RBF SVC': SVC(kernel='rbf', random_state=random_state),
+    'MLP': MLPClassifier(max_iter=1000, random_state=random_state),
+    'Poly SVC': SVC(kernel='poly', random_state=random_state),
+}
+
+## Load datasets
+print('\nLoading datasets...')
+
+datasets = {}
+for i, dataset_name in enumerate(datasets_names):
+    print(
+        f'\033[32m=>\033[m Loading {dataset_name:<35} '
+        f'({i:02}/{len(datasets_names):02})',
+        end='\r',
+    )
+    match dataset_name:
+        case 'breast-cancer':
+            datasets[dataset_name] = load_breast_cancer(return_X_y=True)
+        case _:
+            datasets[dataset_name] = get_clean_openml(
+                dataset_name, **datasets_options.get(dataset_name, {})
+            )
+print(' ' * LINE_SIZE)
+
+## Main logic
+
+# centralized data
+manager = Manager()
+scores = manager.dict({d: {e: [] for e in estimators} for d in datasets_names})
+times = manager.dict({d: {e: [] for e in estimators} for d in datasets_names})
+
+# the elements are a list of:
+# - start timestamp, or 0 if not started
+# - number from 0 to 1 for progress, or a timestamp if ended
+progress_states = manager.dict(
+    {d: {e: [0.0, 0.0] for e in estimators} for d in datasets_names}
+)
+total_jobs = len(datasets) * len(estimators)
+
+
+def worker(dataset_name: str, estimator_name: str) -> None:
+    if ignore_warnings:
+        warnings.filterwarnings('ignore')
+
+    score_arr = []
+    time_arr = []
+    start = time()
+
+    # need to reassign because of shared data getters/setters
+    temp = progress_states[dataset_name]
+    temp[estimator_name][0] = start
+    progress_states[dataset_name] = temp
+
+    X, y = datasets[dataset_name]
+    estimator = make_pipeline(
+        SimpleImputer(strategy='mean'),  # remove NaNs
+        estimators[estimator_name],
+    )
+
+    for i, (i_train, i_test) in enumerate(skf.split(X, y)):
+        try:
+            signal.signal(signal.SIGALRM, timeout_handler)
+            signal.alarm(timeout)
+
+            X_train, X_test = X[i_train], X[i_test]
+            y_train, y_test = y[i_train], y[i_test]
+
+            t0 = time()
+            estimator.fit(X_train, y_train)
+            t1 = time()
+
+            score = f1_score(y_test, estimator.predict(X_test), average='micro')
+            score_arr.append(score)
+            time_arr.append(t1 - t0)
+
+            temp = progress_states[dataset_name]
+            temp[estimator_name][1] = (i + 1) / n_folds
+            progress_states[dataset_name] = temp
+        except TimeoutException:
+            break
+
+    for data_source, value in (
+        (scores, score_arr),
+        (times, time_arr),
+        (progress_states, [start, time()]),
+    ):
+        temp = data_source[dataset_name]
+        temp[estimator_name] = value
+        data_source[dataset_name] = temp
+    signal.alarm(0)
+
+
+def save_data():
+    with open(FILE, 'w') as f:
+        data = {
+            'n_folds': n_folds,
+            'scores': dict(scores),
+            'times': dict(times),
+        }
+        json.dump(data, f, indent=2)
+
+
+def progress_bar():
+    print('=' * LINE_SIZE)
+    print('\n')
+    prev_running = 0
+
+    def format_time(t):
+        hm, s = divmod(int(t), 60)
+        h, m = divmod(hm, 60)
+        return f'\033[34m{h:02}:{m:02}:{s:02}\033[m'
+
+    def eta_str(progress, time_spent):
+        if not progress:
+            return f'--:--:--'
+
+        eta = time_spent / progress * (1 - progress)
+        return format_time(eta)
+
+    def bar(name, time_spent, progress):
+        print(
+            f'[{"#" * round(progress * 30):-<30}] '
+            f'(\033[33m{int(progress * 100):>3}%\033[m) '
+            f'{format_time(time_spent)} {name:<50}|'
+        )
+
+    while True:
+        running = []
+        total_time = 0
+        total_progress = 0
+        states = []
+        for dataset_name, elt in dict(progress_states).items():
+            for estimator_name, (start, progress) in elt.items():
+                if progress > 1:
+                    states.append(2)
+                    total_time += progress - start
+                elif start != 0:
+                    states.append(1)
+                    total_time += time() - start
+                else:
+                    states.append(0)
+                if start != 0:
+                    if progress < 1:
+                        running.append(
+                            (dataset_name, estimator_name, start, progress)
+                        )
+                        total_progress += progress
+                    else:
+                        total_progress += 1
+
+        total_done, total_running, total_queued = (
+            states.count(k) for k in [2, 1, 0]
+        )
+        total_progress /= total_jobs
+        running.sort(key=lambda x: x[3])
+        now_running = len(running)
+
+        for i in range(prev_running + 1, -1, -1):
+            if i < now_running:
+                print(end='\033[F')
+            else:
+                print(' ' * LINE_SIZE, end='\033[F')
+
+        for dataset_name, estimator_name, start, progress in running:
+            bar(f'{dataset_name} - {estimator_name}', time() - start, progress)
+
+        print('=' * LINE_SIZE)
+        print(
+            f'TOTAL [{"#" * round(total_progress * 24):-<24}] '
+            f'(\033[33m{int(total_progress * 100):>3}%\033[m) '
+            f'ETA: {eta_str(total_progress, total_time)} - '
+            f'{total_done} done, {total_running} running, {total_queued} queued'
+        )
+
+        # a job was just done, update the results file
+        if now_running != prev_running:
+            save_data()
+
+        if total_done == total_jobs:
+            break
+
+        prev_running = now_running
+        sleep(0.2)
+
+
+## train in parallel
+print('Preparing to train')
+
+
+n_jobs = min(os.process_cpu_count(), total_jobs, max_jobs)
+if n_jobs <= 0:
+    print('Nothing to do')
+    sys.exit(0)
+
+print(f'{len(datasets)} datasets to process, splitting work in {n_jobs} jobs.')
+print()
+
+progress_bar_thread = Thread(target=progress_bar)
+progress_bar_thread.start()
+
+Parallel(n_jobs=n_jobs)(
+    delayed(worker)(dataset_name, estimator_name)
+    for dataset_name in datasets
+    for estimator_name in estimators
+)
+
+# force end all datasets
+for d in datasets:
+    for e in estimators:
+        progress_states[e][d][0] = time()
+        progress_states[e][d][1] = time()
+progress_bar_thread.join()
+
+scores, times = dict(scores), dict(times)
+
+print('Done.')
+save_data()

{sklearn_morpho-0.2.2 → sklearn_morpho-0.2.3}/testing/compare_estimators_show.py

@@ -6,19 +6,25 @@ import json
 import numpy as np
 import matplotlib.pyplot as plt
 
-FILE = 'comparison_data.json'
+FILE = 'comparison.json'
 
 with open(FILE, 'r') as f:
     data = json.load(f)
 scores = data['scores']
 times = data['times']
 
-n_splits = data['n_splits']
+n_folds = data['n_folds']
 
 # display summary table in console
 datasets_names = list(scores.keys())
 estimators_names = list(scores[datasets_names[0]].keys())
 
+for dataset_name in datasets_names:
+    for estimator_name in estimators_names:
+        for data_source in (scores, times):
+            arr = data_source[dataset_name][estimator_name]
+            data_source[dataset_name][estimator_name] = np.array(arr)
+
 print()
 params = (
     ('F1 score', scores, np.argmax, np.argmin),
@@ -36,7 +42,7 @@ for name, data_source, best_func, worst_func in params:
 
         dataset_res = []  # list of (avg, std)
         for estimator_name in estimators_names:
-            res = np.array(data_source[dataset_name][estimator_name])
+            res = data_source[dataset_name][estimator_name]
 
             avg = np.average(res)
             std = res.std()
@@ -56,19 +62,24 @@ for name, data_source, best_func, worst_func in params:
         print(f'{dataset_name:>35}' + line)
     print()
 
-# merge and display results averaged over all datasets
+# merge and display results averaged over all datasets where there are results
 estimators_scores = {}
 estimators_times = {}
 for estimator_name in estimators_names:
-    estimators_scores[estimator_name] = np.empty(len(datasets_names))
-    estimators_times[estimator_name] = np.empty(len(datasets_names))
-
-    for i, dataset_name in enumerate(datasets_names):
-        score = np.array(scores[dataset_name][estimator_name])
-        time = np.array(times[dataset_name][estimator_name])
-
-        estimators_scores[estimator_name][i] = np.average(score)
-        estimators_times[estimator_name][i] = np.average(time)
+    estimators_scores[estimator_name] = np.array(
+        [
+            score
+            for dataset_name in datasets_names
+            for score in scores[dataset_name][estimator_name]
+        ]
+    )
+    estimators_times[estimator_name] = np.array(
+        [
+            time
+            for dataset_name in datasets_names
+            for time in times[dataset_name][estimator_name]
+        ]
+    )
 
 fig, axs = plt.subplots(ncols=2, nrows=1)
 # log scale for times

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

@@ -1,90 +0,0 @@
-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.2/PKG-INFO

@@ -1,10 +0,0 @@
-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.2/README.md

@@ -1,56 +0,0 @@
-# sklearn-morpho
-
-scikit-learn estimator toolbox for morphological perceptrons.
-
-![](https://img.shields.io/pypi/v/sklearn-morpho?style=flat-square)
-![](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)
-
-Current features:
-
-- Scikit-learn estimators:
-  - Linear Dilation-Erosion Perceptron (l-DEP)
-  - Reduced Dilation-Erosion Perceptron (r-DEP)
-  - 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 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
-  features.
-
-## Getting started
-
-Take a look at the Jupyter code examples in the
-[MREs](https://github.com/d-002/sklearn-morpho/tree/master/MREs) directory.
-
-## Running the project
-
-Install Python 3 and hatch.
-Then run one of these commands:
-
-- `hatch run jupyter lab` to run the Jupyter notebooks
-- `hatch run pytest` for tests
-- `hatch shell` to run testing files like `testing/display_boundary.py` in the
-  right environment.
-
-Special note for the estimators comparison testing files: they are split in two
-files to avoid training the estimators every time one wants to view the results.
-
-## For Arch users
-
-The package is available in the
-[Arch User Repository](https://aur.archlinux.org) as `python-sklearn-morpho`, as
-are all its dependencies not already in the official packages, except for
-`dccp`.
-
-Since the latter is an optional dependency, you can either:
-
-- Download `dccp` through pip or use `pip install sklearn-morpho[dccp]` in a
-  Python virtual environment.
-- Download `python-sklearn-morpho` from the AUR and use
-  `pip install dccp --user`.