Add CI quality kit (ruff + pre-commit + smoke test) and apply ruff format

Caller workflow -> ci-templates, ruff.toml + .pre-commit-config.yaml + pytest.ini,
tests/test_smoke.py. ruff --fix + format applied (behaviour-neutral).
Verified in-container: ruff check clean, pytest 1 passed.

Author: danielstaps

.github/workflows/ci.yml

@@ -0,0 +1,7 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  quality:
+    uses: danielstaps/ci-templates/.github/workflows/python-quality.yml@main
+    with:
+      python-version: "3.11"

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+# Canonical pre-commit config for danielstaps research repos.
+# Copy into a repo as `.pre-commit-config.yaml`, then:  pre-commit install
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.4
+    hooks:
+      - id: ruff              # lint (with autofix)
+        args: [--fix]
+      - id: ruff-format       # format
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-merge-conflict
+      - id: check-added-large-files   # blocks committing venvs / big data dumps
+        args: [--maxkb=2048]

examples/flag.py

@@ -1,16 +1,16 @@
 """GLVQ example using the spiral dataset."""
+
 import argparse
 
 import prototorch as pt
 import pytorch_lightning as pl
 import torch
+
 # Prototorch One Class Classifier
 from prototorch_oneclass import SVQ_OCC
 from prototorch_oneclass.datasets import Flag
-from prototorch_oneclass.functions.callbacks import (DynamicCallback,
-                                                     ThetaCallback)
-from prototorch_oneclass.functions.losses import (brier_score, csi_soft_loss,
-                                                  occ_entropy_loss)
+from prototorch_oneclass.functions.callbacks import DynamicCallback, ThetaCallback
+from prototorch_oneclass.functions.losses import brier_score
 
 # Configuration
 num_classes = 1

examples/triangle.py

@@ -1,16 +1,16 @@
 """GLVQ example using the spiral dataset."""
+
 import argparse
 
 import prototorch as pt
 import pytorch_lightning as pl
 import torch
+
 # Prototorch One Class Classifier
 from prototorch_oneclass import SVQ_OCC
 from prototorch_oneclass.datasets import Polygon
-from prototorch_oneclass.functions.callbacks import (DynamicCallback,
-                                                     ThetaCallback)
-from prototorch_oneclass.functions.losses import (brier_score, lpcsi_loss,
-                                                  occ_entropy_loss)
+from prototorch_oneclass.functions.callbacks import DynamicCallback, ThetaCallback
+from prototorch_oneclass.functions.losses import brier_score
 
 # Configuration
 num_classes = 3

prototorch_oneclass/__init__.py

@@ -1,3 +1,3 @@
-from prototorch_oneclass.oneclass import (SVQ_OCC)
+from prototorch_oneclass.oneclass import SVQ_OCC
 
 __all__ = ["SVQ_OCC"]

prototorch_oneclass/datasets/__init__.py

@@ -2,4 +2,4 @@
 from prototorch_oneclass.datasets.polygon import Polygon
 from prototorch_oneclass.datasets.shapes import Shapes
 
-__all__ = ['Flag', 'Polygon', 'Shapes']
+__all__ = ["Flag", "Polygon", "Shapes"]

prototorch_oneclass/datasets/flag.py

@@ -1,32 +1,28 @@
-""" Datasets for OneClassClassifier inspired by the PalauFlag """
+"""Datasets for OneClassClassifier inspired by the PalauFlag"""
 
 import numpy as np
 import torch
 
 np.random.seed(42)
 
 
-def make_flag(num_samples=300,
-              dimensions=2,
-              num_classes=1,
-              blobs_per_class=1,
-              elipses=True):
-    """ Generates a variation of the PalauFlag """
+def make_flag(num_samples=300, dimensions=2, num_classes=1, blobs_per_class=1, elipses=True):
+    """Generates a variation of the PalauFlag"""
     x = np.random.uniform(low=0.0, high=1.0, size=(num_samples, dimensions))
     y = np.full(num_samples, num_classes, dtype=int)
 
     test = 1
 
-    blob_mean = np.random.uniform(low=0.1,
-                                  high=0.9,
-                                  size=(num_classes * blobs_per_class,
-                                        dimensions))
-    #blob_mean = np.random.uniform(low=0.5, high=0.5, size=(num_classes*blobs_per_class, dimensions))
-    #blob_mean[:,0] = 0.2
-    blob_bord = np.random.uniform(low=0.05 * dimensions * test,
-                                  high=0.15 * dimensions * test,
-                                  size=(num_classes * blobs_per_class,
-                                        dimensions))
+    blob_mean = np.random.uniform(
+        low=0.1, high=0.9, size=(num_classes * blobs_per_class, dimensions)
+    )
+    # blob_mean = np.random.uniform(low=0.5, high=0.5, size=(num_classes*blobs_per_class, dimensions))
+    # blob_mean[:,0] = 0.2
+    blob_bord = np.random.uniform(
+        low=0.05 * dimensions * test,
+        high=0.15 * dimensions * test,
+        size=(num_classes * blobs_per_class, dimensions),
+    )
 
     for target in range(num_classes):
         for blob in range(blobs_per_class):
@@ -36,7 +32,7 @@ def make_flag(num_samples=300,
             x_shf_pow = np.power(x_shifted, 2)
             bbord_pow = np.power(bord, 2)
             distances = np.sum(np.divide(x_shf_pow, bbord_pow), axis=1)
-            in_border = np.where(distances < 1.)[0]
+            in_border = np.where(distances < 1.0)[0]
             y[in_border] = target
 
     print(x.shape, y.shape)
@@ -45,7 +41,7 @@ def make_flag(num_samples=300,
 
 
 class Flag(torch.utils.data.TensorDataset):
-    """ Flag dataset for OOC.
+    """Flag dataset for OOC.
 
     This datasets consists of n blobs of different classes and a background garbage noise.
 
@@ -66,14 +62,16 @@ class Flag(torch.utils.data.TensorDataset):
     :param num_samples: number of random samples
     :param noise: noise added to the spirals
     """
-    def __init__(self,
-                 num_samples: int = 500,
-                 dimensions: int = 2,
-                 num_classes: int = 1,
-                 blobs_per_class: int = 1,
-                 elipses: bool = True):
-        x, y = make_flag(num_samples, dimensions, num_classes, blobs_per_class,
-                         elipses)
+
+    def __init__(
+        self,
+        num_samples: int = 500,
+        dimensions: int = 2,
+        num_classes: int = 1,
+        blobs_per_class: int = 1,
+        elipses: bool = True,
+    ):
+        x, y = make_flag(num_samples, dimensions, num_classes, blobs_per_class, elipses)
         self.data = torch.Tensor(x)
         self.target = torch.LongTensor(y)
         super().__init__(self.data, self.target)

prototorch_oneclass/datasets/polygon.py

@@ -1,4 +1,4 @@
-""" Datasets for OneClassClassifier inspired by the PalauFlag """
+"""Datasets for OneClassClassifier inspired by the PalauFlag"""
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -20,8 +20,7 @@ def make_polygon(num_samples=300, dimensions=2, num_classes=3, thickness=0.1):
             high=[-1 + thickness, x_len + thickness],
             size=(num_samples // num_classes, dimensions),
         )
-        rot = np.asarray([[np.cos(phi), -np.sin(phi)],
-                          [np.sin(phi), np.cos(phi)]])
+        rot = np.asarray([[np.cos(phi), -np.sin(phi)], [np.sin(phi), np.cos(phi)]])
         x_ = np.matmul(x_, rot)
         x.append(x_)
         y.append(np.full(num_samples // num_classes, i))
@@ -33,7 +32,6 @@ def make_polygon(num_samples=300, dimensions=2, num_classes=3, thickness=0.1):
 
 
 class Polygon(torch.utils.data.TensorDataset):
-
     def __init__(
         self,
         num_samples: int = 500,
@@ -47,7 +45,7 @@ def __init__(
         super().__init__(self.data, self.target)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import matplotlib.pyplot as plt
 
     for i in range(2):
@@ -60,6 +58,6 @@ def __init__(
                 thickness=0.1 + 0.5 * i,
             )
             plt.subplot(2, 4, (i * 4) + j + 1)
-            plt.axis('equal')
+            plt.axis("equal")
             plt.scatter(x[:, 0], x[:, 1], c=y)
     plt.show()

prototorch_oneclass/datasets/s_shaped.py

@@ -17,7 +17,7 @@ def make_S(
         center = radius
 
     # first 'circle' centered at center with radius r
-    t1 = np.random.uniform(0., 3 * np.pi / 2, int(n_samples / 2))
+    t1 = np.random.uniform(0.0, 3 * np.pi / 2, int(n_samples / 2))
     x1 = radius * np.cos(t1)
     y1 = radius * np.sin(t1) + center
 
@@ -50,13 +50,15 @@ def make_S(
 
 
 class S_Shape(torch.utils.data.TensorDataset):
-    def __init__(self,
-                 n_samples: int = 800,
-                 center: float = 0.5,
-                 radius: float = 0.5,
-                 noise: float = 0.3,
-                 ratio: float = 0.5,
-                 **kwargs):
+    def __init__(
+        self,
+        n_samples: int = 800,
+        center: float = 0.5,
+        radius: float = 0.5,
+        noise: float = 0.3,
+        ratio: float = 0.5,
+        **kwargs,
+    ):
         x, y = make_S(n_samples, radius, noise, ratio)
         self.data = torch.squeeze(torch.Tensor(x))
         self.target = torch.squeeze(torch.LongTensor(y))

prototorch_oneclass/datasets/shapes.py

@@ -5,49 +5,46 @@
 np.random.seed(42)
 
 
-def create_shapes(num_samples=300,
-                  num_shapes=1,
-                  num_classes=1,
-                  outliers=0.0,
-                  **kwargs):
+def create_shapes(num_samples=300, num_shapes=1, num_classes=1, outliers=0.0, **kwargs):
 
-    keys = ['centers', 'cluster_std', 'random_state', 'noise', 'factor']
+    keys = ["centers", "cluster_std", "random_state", "noise", "factor"]
     for key in keys:
-        if key not in kwargs.keys() and key != 'factor':
+        if key not in kwargs.keys() and key != "factor":
             kwargs[key] = None
-        if key not in kwargs.keys() and key == 'factor':
+        if key not in kwargs.keys() and key == "factor":
             kwargs[key] = 0.8
 
     outlier = int(outliers * num_samples)
     num_samples = num_samples - outlier
 
     types = {
-        'blobs':
-        make_blobs(n_samples=num_samples,
-                   centers=kwargs['centers'],
-                   cluster_std=kwargs['cluster_std'],
-                   random_state=kwargs['random_state']),
-        'circle':
-        make_circles(n_samples=num_samples,
-                     noise=kwargs['noise'],
-                     random_state=kwargs['random_state'],
-                     factor=kwargs['factor']),
-        'moon':
-        make_moons(n_samples=num_samples,
-                   noise=kwargs['noise'],
-                   random_state=kwargs['random_state'])
+        "blobs": make_blobs(
+            n_samples=num_samples,
+            centers=kwargs["centers"],
+            cluster_std=kwargs["cluster_std"],
+            random_state=kwargs["random_state"],
+        ),
+        "circle": make_circles(
+            n_samples=num_samples,
+            noise=kwargs["noise"],
+            random_state=kwargs["random_state"],
+            factor=kwargs["factor"],
+        ),
+        "moon": make_moons(
+            n_samples=num_samples, noise=kwargs["noise"], random_state=kwargs["random_state"]
+        ),
     }
 
-    if kwargs['kind'] is None:
-        kwargs['kind'] = 'moon'
-    if not any(map(lambda shape: shape in kwargs['kind'], types.keys())):
-        msg = 'kind must be in [{}, {}, {}]'.format(*types.keys())
+    if kwargs["kind"] is None:
+        kwargs["kind"] = "moon"
+    if not any(map(lambda shape: shape in kwargs["kind"], types.keys())):
+        msg = "kind must be in [{}, {}, {}]".format(*types.keys())
         raise ValueError(msg)
 
     dataset, targets = [], []
     # TODO: extend for multiple shapes per class
     for j in range(num_shapes):
-        dataset.append(types[kwargs['kind']])
+        dataset.append(types[kwargs["kind"]])
 
     datasets, targets = zip(*dataset)
     datasets = np.asarray(datasets)
@@ -56,23 +53,24 @@ def create_shapes(num_samples=300,
 
 
 class Shapes(torch.utils.data.TensorDataset):
-    def __init__(self,
-                 num_samples: int = 300,
-                 num_shapes: int = 1,
-                 num_classes: int = 1,
-                 outliers=0.0,
-                 **kwargs):
-        x, y = create_shapes(num_samples, num_shapes, num_classes, outliers,
-                             **kwargs)
+    def __init__(
+        self,
+        num_samples: int = 300,
+        num_shapes: int = 1,
+        num_classes: int = 1,
+        outliers=0.0,
+        **kwargs,
+    ):
+        x, y = create_shapes(num_samples, num_shapes, num_classes, outliers, **kwargs)
         self.data = torch.squeeze(torch.Tensor(x))
         print(self.data.shape)
         self.target = torch.squeeze(torch.LongTensor(y))
         super().__init__(self.data, self.target)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Configuration
-    kind = 'blobs'
+    kind = "blobs"
     num_samples = 1000
     num_shapes = 1
     num_classes = 2
@@ -85,12 +83,12 @@ def __init__(self,
     prototypes_per_class = 1
 
     kwargs = {
-        'kind': kind,
-        'centers': center,
-        'cluster_std': cluster_std,
-        'random_state': random_state,
-        'noise': noise,
-        'factor': factor,
+        "kind": kind,
+        "centers": center,
+        "cluster_std": cluster_std,
+        "random_state": random_state,
+        "noise": noise,
+        "factor": factor,
     }
 
     # Dataset