build: bump version 0.4.0 → 0.4.1

* chore: update pre-commit versions

* ci: remove old configurations

* ci: copy workflow from prototorch

* ci: run precommit for all files

* ci: add examples CPU test

* ci(test): failing example test

* ci: fix workflow definition

* ci(test): repeat failing example test

* ci: fix workflow definition

* ci(test): repeat failing example test II

* ci: fix test command

* ci: cleanup example test

* ci: remove travis badge

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.3.0
+current_version = 0.4.1
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)

.codacy.yml

@@ -1,15 +0,0 @@
-# To validate the contents of your configuration file
-# run the following command in the folder where the configuration file is located:
-# codacy-analysis-cli validate-configuration --directory `pwd`
-# To analyse, run:
-# codacy-analysis-cli analyse --tool remark-lint --directory `pwd`
----
-engines:
-  pylintpython3:
-    exclude_paths:
-      - config/engines.yml
-  remark-lint:
-    exclude_paths:
-      - config/engines.yml
-exclude_paths:
-  - 'tests/**'

.codecov.yml

@@ -1,2 +0,0 @@
-comment:
-  require_changes: yes

.github/workflows/examples.yml

@@ -0,0 +1,25 @@
+# Thi workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: examples
+
+on:
+  push:
+    paths:
+      - 'examples/**.py'
+jobs:
+  cpu:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.9
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[all]
+    - name: Run examples
+      run: |
+        ./tests/test_examples.sh examples/

.github/workflows/pythonapp.yml

@@ -0,0 +1,73 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: tests
+
+on:
+  push:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  style:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.9
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[all]
+    - uses: pre-commit/action@v2.0.3
+  compatibility:
+    needs: style
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.7", "3.8", "3.9"]
+        os: [ubuntu-latest, windows-latest]
+        exclude:
+        - os: windows-latest
+          python-version: "3.7"
+        - os: windows-latest
+          python-version: "3.8"
+
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[all]
+    - name: Test with pytest
+      run: |
+        pytest
+  publish_pypi:
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
+    needs: compatibility
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v2
+      with:
+        python-version: "3.9"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[all]
+        pip install wheel
+    - name: Build package
+      run: python setup.py sdist bdist_wheel
+    - name: Publish a Python distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

.pre-commit-config.yaml

@@ -3,7 +3,7 @@
 
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.0.1
+  rev: v4.1.0
   hooks:
   - id: trailing-whitespace
   - id: end-of-file-fixer
@@ -18,19 +18,19 @@ repos:
   - id: autoflake
 
 - repo: http://github.com/PyCQA/isort
-  rev: 5.9.3
+  rev: 5.10.1
   hooks:
   - id: isort
 
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v0.910-1
+  rev: v0.931
   hooks:
   - id: mypy
     files: prototorch
     additional_dependencies: [types-pkg_resources]
 
 - repo: https://github.com/pre-commit/mirrors-yapf
-  rev: v0.31.0
+  rev: v0.32.0
   hooks:
   - id: yapf
 
@@ -42,10 +42,9 @@ repos:
   - id: python-check-blanket-noqa
 
 - repo: https://github.com/asottile/pyupgrade
-  rev: v2.29.0
+  rev: v2.31.0
   hooks:
   - id: pyupgrade
-    args: [--py36-plus]
 
 - repo: https://github.com/si-cim/gitlint
   rev: v0.15.2-unofficial

.travis.yml

@@ -1,44 +0,0 @@
-dist: bionic
-sudo: false
-language: python
-python:
-  - 3.9
-  - 3.8
-  - 3.7
-  - 3.6
-cache:
-  directories:
-  - "$HOME/.cache/pip"
-  - "./tests/artifacts"
-  - "$HOME/datasets"
-install:
-- pip install git+git://github.com/si-cim/prototorch@dev --progress-bar off
-- pip install .[all] --progress-bar off
-script:
-- coverage run -m pytest
-- ./tests/test_examples.sh examples/
-after_success:
-- bash <(curl -s https://codecov.io/bash)
-
-# Publish on PyPI
-jobs:
-  include:
-    - stage: build
-      python: 3.9
-      script: echo "Starting Pypi build"
-      deploy:
-        provider: pypi
-        username: __token__
-        distributions: "sdist bdist_wheel"
-        password:
-          secure: PDoASdYdVlt1aIROYilAsCW6XpBs/TDel0CSptDzX0CI7i4+ksEW6Jk0JyL58bQt7V4F8PeGty4A8SODzAUIk2d8sty5RI4VJjvXZFCXlUsW+JGUN3EvWNqJLnwN8TDxgu2ENao37GUh0dC6pL8b6bVDGeOLaY1E/YR1jimmTJuxxjKjBIU8ByqTNBnC3rzybMTPU3nRoOM/WMQUyReHrPoUJj685sLqrLruhAqhiYsPbotP8xY6i8+KBbhp5vgiARV2+LkbeGcYZwozCzrEqPKY7YIfVPh895cw0v4NRyFwK1P2jyyIt22Z9Ni0Uy1J5/Qp9Sv6mBPeGjm3pnpDCQyS+2bNIDaj08KUYTIo1mC/Jcu4jQgppZEF+oey9q1tgGo+/JhsTeERKV9BoPF5HDiRArU1s5aWJjFnCsHfu+W1XqX8bwN3aTYsEIaApT3/irc6XyFJIfMN82+z+lUcZ4Y1yAHT3nH1Vif+pZYZB0UOSGrHwuI/UayjKzbCzHMuHWylWB/9ehd4o4YVp6iubVHc7Sj0KQkwBgwgl6TvwNcUuFsplFabCxmX0mVcavXsWiOBc+ivPmU6574zGj0JcEk5ghVgnKH+QS96aVrKOzegwbl4O13jY8dJp+/zgXl0gJOvRKr4BhuBJKcBaMQHdSKUChVsJJtqDyt59GvWcbg=
-        on:
-          tags: true
-          skip_existing: true
-
-# The password is encrypted with:
-# `cd prototorch && travis encrypt your-pypi-api-token --add deploy.password`
-# See https://docs.travis-ci.com/user/deployment/pypi and
-# https://github.com/travis-ci/travis.rb#installation
-# for more details
-# Note: The encrypt command does not work well in ZSH.

README.md

@@ -1,6 +1,5 @@
 # ProtoTorch Models
 
-[![Build Status](https://api.travis-ci.com/si-cim/prototorch_models.svg?branch=main)](https://travis-ci.com/github/si-cim/prototorch_models)
 [![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/si-cim/prototorch_models?color=yellow&label=version)](https://github.com/si-cim/prototorch_models/releases)
 [![PyPI](https://img.shields.io/pypi/v/prototorch_models)](https://pypi.org/project/prototorch_models/)
 [![GitHub license](https://img.shields.io/github/license/si-cim/prototorch_models)](https://github.com/si-cim/prototorch_models/blob/master/LICENSE)

docs/source/conf.py

@@ -23,7 +23,7 @@ author = "Jensun Ravichandran"
 
 # The full version, including alpha/beta/rc tags
 #
-release = "0.3.0"
+release = "0.4.1"
 
 # -- General configuration ---------------------------------------------------
 

examples/cbc_iris.py

@@ -38,12 +38,10 @@ if __name__ == "__main__":
     )
 
     # Callbacks
-    vis = pt.models.Visualize2DVoronoiCallback(
-        data=train_ds,
-        title="CBC Iris Example",
-        resolution=100,
-        axis_off=True,
-    )
+    vis = pt.models.VisCBC2D(data=train_ds,
+                             title="CBC Iris Example",
+                             resolution=100,
+                             axis_off=True)
 
     # Setup trainer
     trainer = pl.Trainer.from_argparse_args(

examples/glvq_iris.py

@@ -3,7 +3,6 @@
 import argparse
 
 import prototorch as pt
-import prototorch.models.clcc
 import pytorch_lightning as pl
 import torch
 from torch.optim.lr_scheduler import ExponentialLR
@@ -30,7 +29,7 @@ if __name__ == "__main__":
     )
 
     # Initialize the model
-    model = prototorch.models.GLVQ(
+    model = pt.models.GLVQ(
         hparams,
         optimizer=torch.optim.Adam,
         prototypes_initializer=pt.initializers.SMCI(train_ds),
@@ -42,13 +41,7 @@ if __name__ == "__main__":
     model.example_input_array = torch.zeros(4, 2)
 
     # Callbacks
-    vis = pt.models.Visualize2DVoronoiCallback(
-        data=train_ds,
-        resolution=200,
-        title="Example: GLVQ on Iris",
-        x_label="sepal length",
-        y_label="petal length",
-    )
+    vis = pt.models.VisGLVQ2D(data=train_ds)
 
     # Setup trainer
     trainer = pl.Trainer.from_argparse_args(

examples/gmlvq_spiral.py

@@ -1,4 +1,4 @@
-"""GLVQ example using the spiral dataset."""
+"""GMLVQ example using the spiral dataset."""
 
 import argparse
 

examples/gtlvq_mnist.py

@@ -0,0 +1,104 @@
+"""GTLVQ example using the MNIST dataset."""
+
+import argparse
+
+import prototorch as pt
+import pytorch_lightning as pl
+import torch
+from torchvision import transforms
+from torchvision.datasets import MNIST
+
+if __name__ == "__main__":
+    # Command-line arguments
+    parser = argparse.ArgumentParser()
+    parser = pl.Trainer.add_argparse_args(parser)
+    args = parser.parse_args()
+
+    # Dataset
+    train_ds = MNIST(
+        "~/datasets",
+        train=True,
+        download=True,
+        transform=transforms.Compose([
+            transforms.ToTensor(),
+        ]),
+    )
+    test_ds = MNIST(
+        "~/datasets",
+        train=False,
+        download=True,
+        transform=transforms.Compose([
+            transforms.ToTensor(),
+        ]),
+    )
+
+    # Dataloaders
+    train_loader = torch.utils.data.DataLoader(train_ds,
+                                               num_workers=0,
+                                               batch_size=256)
+    test_loader = torch.utils.data.DataLoader(test_ds,
+                                              num_workers=0,
+                                              batch_size=256)
+
+    # Hyperparameters
+    num_classes = 10
+    prototypes_per_class = 1
+    hparams = dict(
+        input_dim=28 * 28,
+        latent_dim=28,
+        distribution=(num_classes, prototypes_per_class),
+        proto_lr=0.01,
+        bb_lr=0.01,
+    )
+
+    # Initialize the model
+    model = pt.models.ImageGTLVQ(
+        hparams,
+        optimizer=torch.optim.Adam,
+        prototypes_initializer=pt.initializers.SMCI(train_ds),
+        #Use one batch of data for subspace initiator.
+        omega_initializer=pt.initializers.PCALinearTransformInitializer(
+            next(iter(train_loader))[0].reshape(256, 28 * 28)))
+
+    # Callbacks
+    vis = pt.models.VisImgComp(
+        data=train_ds,
+        num_columns=10,
+        show=False,
+        tensorboard=True,
+        random_data=100,
+        add_embedding=True,
+        embedding_data=200,
+        flatten_data=False,
+    )
+    pruning = pt.models.PruneLoserPrototypes(
+        threshold=0.01,
+        idle_epochs=1,
+        prune_quota_per_epoch=10,
+        frequency=1,
+        verbose=True,
+    )
+    es = pl.callbacks.EarlyStopping(
+        monitor="train_loss",
+        min_delta=0.001,
+        patience=15,
+        mode="min",
+        check_on_train_epoch_end=True,
+    )
+
+    # Setup trainer
+    # using GPUs here is strongly recommended!
+    trainer = pl.Trainer.from_argparse_args(
+        args,
+        callbacks=[
+            vis,
+            pruning,
+            # es,
+        ],
+        terminate_on_nan=True,
+        weights_summary=None,
+        accelerator="ddp",
+    )
+
+    # Training loop
+    trainer.fit(model, train_loader)

examples/gtlvq_moons.py

@@ -0,0 +1,63 @@
+"""Localized-GTLVQ example using the Moons dataset."""
+
+import argparse
+
+import prototorch as pt
+import pytorch_lightning as pl
+import torch
+
+if __name__ == "__main__":
+    # Command-line arguments
+    parser = argparse.ArgumentParser()
+    parser = pl.Trainer.add_argparse_args(parser)
+    args = parser.parse_args()
+
+    # Reproducibility
+    pl.utilities.seed.seed_everything(seed=2)
+
+    # Dataset
+    train_ds = pt.datasets.Moons(num_samples=300, noise=0.2, seed=42)
+
+    # Dataloaders
+    train_loader = torch.utils.data.DataLoader(train_ds,
+                                               batch_size=256,
+                                               shuffle=True)
+
+    # Hyperparameters
+    # Latent_dim should be lower than input dim.
+    hparams = dict(distribution=[1, 3], input_dim=2, latent_dim=1)
+
+    # Initialize the model
+    model = pt.models.GTLVQ(
+        hparams, prototypes_initializer=pt.initializers.SMCI(train_ds))
+
+    # Compute intermediate input and output sizes
+    model.example_input_array = torch.zeros(4, 2)
+
+    # Summary
+    print(model)
+
+    # Callbacks
+    vis = pt.models.VisGLVQ2D(data=train_ds)
+    es = pl.callbacks.EarlyStopping(
+        monitor="train_acc",
+        min_delta=0.001,
+        patience=20,
+        mode="max",
+        verbose=False,
+        check_on_train_epoch_end=True,
+    )
+
+    # Setup trainer
+    trainer = pl.Trainer.from_argparse_args(
+        args,
+        callbacks=[
+            vis,
+            es,
+        ],
+        weights_summary="full",
+        accelerator="ddp",
+    )
+
+    # Training loop
+    trainer.fit(model, train_loader)

examples/ksom_colors.py

@@ -10,6 +10,7 @@ from prototorch.utils.colors import hex_to_rgb
 
 
 class Vis2DColorSOM(pl.Callback):
+
     def __init__(self, data, title="ColorSOMe", pause_time=0.1):
         super().__init__()
         self.title = title

examples/lvqmln_iris.py

@@ -8,6 +8,7 @@ import torch
 
 
 class Backbone(torch.nn.Module):
+
     def __init__(self, input_size=4, hidden_size=10, latent_size=2):
         super().__init__()
         self.input_size = input_size

examples/siamese_glvq_iris.py

@@ -8,6 +8,7 @@ import torch
 
 
 class Backbone(torch.nn.Module):
+
     def __init__(self, input_size=4, hidden_size=10, latent_size=2):
         super().__init__()
         self.input_size = input_size

examples/siamese_gtlvq_iris.py

@@ -0,0 +1,73 @@
+"""Siamese GTLVQ example using all four dimensions of the Iris dataset."""
+
+import argparse
+
+import prototorch as pt
+import pytorch_lightning as pl
+import torch
+
+
+class Backbone(torch.nn.Module):
+
+    def __init__(self, input_size=4, hidden_size=10, latent_size=2):
+        super().__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.latent_size = latent_size
+        self.dense1 = torch.nn.Linear(self.input_size, self.hidden_size)
+        self.dense2 = torch.nn.Linear(self.hidden_size, self.latent_size)
+        self.activation = torch.nn.Sigmoid()
+
+    def forward(self, x):
+        x = self.activation(self.dense1(x))
+        out = self.activation(self.dense2(x))
+        return out
+
+
+if __name__ == "__main__":
+    # Command-line arguments
+    parser = argparse.ArgumentParser()
+    parser = pl.Trainer.add_argparse_args(parser)
+    args = parser.parse_args()
+
+    # Dataset
+    train_ds = pt.datasets.Iris()
+
+    # Reproducibility
+    pl.utilities.seed.seed_everything(seed=2)
+
+    # Dataloaders
+    train_loader = torch.utils.data.DataLoader(train_ds, batch_size=150)
+
+    # Hyperparameters
+    hparams = dict(distribution=[1, 2, 3],
+                   proto_lr=0.01,
+                   bb_lr=0.01,
+                   input_dim=2,
+                   latent_dim=1)
+
+    # Initialize the backbone
+    backbone = Backbone(latent_size=hparams["input_dim"])
+
+    # Initialize the model
+    model = pt.models.SiameseGTLVQ(
+        hparams,
+        prototypes_initializer=pt.initializers.SMCI(train_ds),
+        backbone=backbone,
+        both_path_gradients=False,
+    )
+
+    # Model summary
+    print(model)
+
+    # Callbacks
+    vis = pt.models.VisSiameseGLVQ2D(data=train_ds, border=0.1)
+
+    # Setup trainer
+    trainer = pl.Trainer.from_argparse_args(
+        args,
+        callbacks=[vis],
+    )
+
+    # Training loop
+    trainer.fit(model, train_loader)

prototorch/models/__init__.py

@@ -8,17 +8,34 @@ from .glvq import (
     GLVQ21,
     GMLVQ,
     GRLVQ,
+    GTLVQ,
     LGMLVQ,
     LVQMLN,
     ImageGLVQ,
     ImageGMLVQ,
+    ImageGTLVQ,
     SiameseGLVQ,
     SiameseGMLVQ,
+    SiameseGTLVQ,
 )
 from .knn import KNN
-from .lvq import LVQ1, LVQ21, MedianLVQ
-from .probabilistic import CELVQ, PLVQ, RSLVQ, SLVQ
-from .unsupervised import GrowingNeuralGas, HeskesSOM, KohonenSOM, NeuralGas
+from .lvq import (
+    LVQ1,
+    LVQ21,
+    MedianLVQ,
+)
+from .probabilistic import (
+    CELVQ,
+    PLVQ,
+    RSLVQ,
+    SLVQ,
+)
+from .unsupervised import (
+    GrowingNeuralGas,
+    HeskesSOM,
+    KohonenSOM,
+    NeuralGas,
+)
 from .vis import *
 
-__version__ = "0.3.0"
+__version__ = "0.4.1"

prototorch/models/abstract.py

@@ -3,16 +3,18 @@
 import pytorch_lightning as pl
 import torch
 import torchmetrics
-from prototorch.core.competitions import WTAC
-from prototorch.core.components import Components, LabeledComponents
-from prototorch.core.distances import euclidean_distance
-from prototorch.core.initializers import LabelsInitializer
-from prototorch.core.pooling import stratified_min_pooling
-from prototorch.nn.wrappers import LambdaLayer
+
+from ..core.competitions import WTAC
+from ..core.components import Components, LabeledComponents
+from ..core.distances import euclidean_distance
+from ..core.initializers import LabelsInitializer
+from ..core.pooling import stratified_min_pooling
+from ..nn.wrappers import LambdaLayer
 
 
 class ProtoTorchBolt(pl.LightningModule):
     """All ProtoTorch models are ProtoTorch Bolts."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__()
 
@@ -51,6 +53,7 @@ class ProtoTorchBolt(pl.LightningModule):
 
 
 class PrototypeModel(ProtoTorchBolt):
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -80,6 +83,7 @@ class PrototypeModel(ProtoTorchBolt):
 
 
 class UnsupervisedPrototypeModel(PrototypeModel):
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -102,6 +106,7 @@ class UnsupervisedPrototypeModel(PrototypeModel):
 
 
 class SupervisedPrototypeModel(PrototypeModel):
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -134,7 +139,7 @@ class SupervisedPrototypeModel(PrototypeModel):
         distances = self.compute_distances(x)
         _, plabels = self.proto_layer()
         winning = stratified_min_pooling(distances, plabels)
-        y_pred = torch.nn.functional.softmin(winning)
+        y_pred = torch.nn.functional.softmin(winning, dim=1)
         return y_pred
 
     def predict_from_distances(self, distances):
@@ -168,3 +173,34 @@ class SupervisedPrototypeModel(PrototypeModel):
         accuracy = torchmetrics.functional.accuracy(preds.int(), targets.int())
 
         self.log("test_acc", accuracy)
+
+
+class ProtoTorchMixin(object):
+    """All mixins are ProtoTorchMixins."""
+    pass
+
+
+class NonGradientMixin(ProtoTorchMixin):
+    """Mixin for custom non-gradient optimization."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.automatic_optimization = False
+
+    def training_step(self, train_batch, batch_idx, optimizer_idx=None):
+        raise NotImplementedError
+
+
+class ImagePrototypesMixin(ProtoTorchMixin):
+    """Mixin for models with image prototypes."""
+
+    def on_train_batch_end(self, outputs, batch, batch_idx, dataloader_idx):
+        """Constrain the components to the range [0, 1] by clamping after updates."""
+        self.proto_layer.components.data.clamp_(0.0, 1.0)
+
+    def get_prototype_grid(self, num_columns=2, return_channels_last=True):
+        from torchvision.utils import make_grid
+        grid = make_grid(self.components, nrow=num_columns)
+        if return_channels_last:
+            grid = grid.permute((1, 2, 0))
+        return grid.cpu()

prototorch/models/callbacks.py

@@ -4,13 +4,14 @@ import logging
 
 import pytorch_lightning as pl
 import torch
-from prototorch.core.components import Components
-from prototorch.core.initializers import LiteralCompInitializer
 
+from ..core.components import Components
+from ..core.initializers import LiteralCompInitializer
 from .extras import ConnectionTopology
 
 
 class PruneLoserPrototypes(pl.Callback):
+
     def __init__(self,
                  threshold=0.01,
                  idle_epochs=10,
@@ -67,6 +68,7 @@ class PruneLoserPrototypes(pl.Callback):
 
 
 class PrototypeConvergence(pl.Callback):
+
     def __init__(self, min_delta=0.01, idle_epochs=10, verbose=False):
         self.min_delta = min_delta
         self.idle_epochs = idle_epochs  # epochs to wait
@@ -89,6 +91,7 @@ class GNGCallback(pl.Callback):
     Based on "A Growing Neural Gas Network Learns Topologies" by Bernd Fritzke.
 
     """
+
     def __init__(self, reduction=0.1, freq=10):
         self.reduction = reduction
         self.freq = freq

prototorch/models/cbc.py

@@ -1,18 +1,19 @@
 import torch
 import torchmetrics
-from prototorch.core.competitions import CBCC
-from prototorch.core.components import ReasoningComponents
-from prototorch.core.initializers import RandomReasoningsInitializer
-from prototorch.core.losses import MarginLoss
-from prototorch.core.similarities import euclidean_similarity
-from prototorch.nn.wrappers import LambdaLayer
 
+from ..core.competitions import CBCC
+from ..core.components import ReasoningComponents
+from ..core.initializers import RandomReasoningsInitializer
+from ..core.losses import MarginLoss
+from ..core.similarities import euclidean_similarity
+from ..nn.wrappers import LambdaLayer
+from .abstract import ImagePrototypesMixin
 from .glvq import SiameseGLVQ
-from .mixin import ImagePrototypesMixin
 
 
 class CBC(SiameseGLVQ):
     """Classification-By-Components."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 

prototorch/models/clcc/clcc_glvq.py

@@ -1,86 +0,0 @@
-from dataclasses import dataclass
-from typing import Callable
-
-import torch
-from prototorch.core.competitions import WTAC
-from prototorch.core.components import LabeledComponents
-from prototorch.core.distances import euclidean_distance
-from prototorch.core.initializers import AbstractComponentsInitializer, LabelsInitializer
-from prototorch.core.losses import GLVQLoss
-from prototorch.models.clcc.clcc_scheme import CLCCScheme
-from prototorch.nn.wrappers import LambdaLayer
-
-
-@dataclass
-class GLVQhparams:
-    distribution: dict
-    component_initializer: AbstractComponentsInitializer
-    distance_fn: Callable = euclidean_distance
-    lr: float = 0.01
-    margin: float = 0.0
-    # TODO: make nicer
-    transfer_fn: str = "identity"
-    transfer_beta: float = 10.0
-    optimizer: torch.optim.Optimizer = torch.optim.Adam
-
-
-class GLVQ(CLCCScheme):
-    def __init__(self, hparams: GLVQhparams) -> None:
-        super().__init__(hparams)
-        self.lr = hparams.lr
-        self.optimizer = hparams.optimizer
-
-    # Initializers
-    def init_components(self, hparams):
-        # initialize Component Layer
-        self.components_layer = LabeledComponents(
-            distribution=hparams.distribution,
-            components_initializer=hparams.component_initializer,
-            labels_initializer=LabelsInitializer(),
-        )
-
-    def init_comparison(self, hparams):
-        # initialize Distance Layer
-        self.comparison_layer = LambdaLayer(hparams.distance_fn)
-
-    def init_inference(self, hparams):
-        self.competition_layer = WTAC()
-
-    def init_loss(self, hparams):
-        self.loss_layer = GLVQLoss(
-            margin=hparams.margin,
-            transfer_fn=hparams.transfer_fn,
-            beta=hparams.transfer_beta,
-        )
-
-    # Steps
-    def comparison(self, batch, components):
-        comp_tensor, _ = components
-        batch_tensor, _ = batch
-
-        comp_tensor = comp_tensor.unsqueeze(1)
-
-        distances = self.comparison_layer(batch_tensor, comp_tensor)
-
-        return distances
-
-    def inference(self, comparisonmeasures, components):
-        comp_labels = components[1]
-        return self.competition_layer(comparisonmeasures, comp_labels)
-
-    def loss(self, comparisonmeasures, batch, components):
-        target = batch[1]
-        comp_labels = components[1]
-        return self.loss_layer(comparisonmeasures, target, comp_labels)
-
-    def configure_optimizers(self):
-        return self.optimizer(self.parameters(), lr=self.lr)
-
-    # Properties
-    @property
-    def prototypes(self):
-        return self.components_layer.components.detach().cpu()
-
-    @property
-    def prototype_labels(self):
-        return self.components_layer.labels.detach().cpu()

prototorch/models/clcc/clcc_scheme.py

@@ -1,192 +0,0 @@
-"""
-CLCC Scheme
-
-CLCC is a LVQ scheme containing 4 steps
-- Components
-- Latent Space
-- Comparison
-- Competition
-
-"""
-from typing import Dict, Set, Type
-
-import pytorch_lightning as pl
-import torch
-import torchmetrics
-
-
-class CLCCScheme(pl.LightningModule):
-    registered_metrics: Dict[Type[torchmetrics.Metric],
-                             torchmetrics.Metric] = {}
-    registered_metric_names: Dict[Type[torchmetrics.Metric], Set[str]] = {}
-
-    def __init__(self, hparams) -> None:
-        super().__init__()
-
-        # Common Steps
-        self.init_components(hparams)
-        self.init_latent(hparams)
-        self.init_comparison(hparams)
-        self.init_competition(hparams)
-
-        # Train Steps
-        self.init_loss(hparams)
-
-        # Inference Steps
-        self.init_inference(hparams)
-
-        # Initialize Model Metrics
-        self.init_model_metrics()
-
-    # internal API, called by models and callbacks
-    def register_torchmetric(self, name: str, metric: torchmetrics.Metric):
-        if metric not in self.registered_metrics:
-            self.registered_metrics[metric] = metric()
-            self.registered_metric_names[metric] = {name}
-        else:
-            self.registered_metric_names[metric].add(name)
-
-    # external API
-    def get_competion(self, batch, components):
-        latent_batch, latent_components = self.latent(batch, components)
-        # TODO: => Latent Hook
-        comparison_tensor = self.comparison(latent_batch, latent_components)
-        # TODO: => Comparison Hook
-        return comparison_tensor
-
-    def forward(self, batch):
-        if isinstance(batch, torch.Tensor):
-            batch = (batch, None)
-        # TODO: manage different datatypes?
-        components = self.components_layer()
-        # TODO: => Component Hook
-        comparison_tensor = self.get_competion(batch, components)
-        # TODO: => Competition Hook
-        return self.inference(comparison_tensor, components)
-
-    def predict(self, batch):
-        """
-        Alias for forward
-        """
-        return self.forward(batch)
-
-    def loss_forward(self, batch):
-        # TODO: manage different datatypes?
-        components = self.components_layer()
-        # TODO: => Component Hook
-        comparison_tensor = self.get_competion(batch, components)
-        # TODO: => Competition Hook
-        return self.loss(comparison_tensor, batch, components)
-
-    # Empty Initialization
-    # TODO: Type hints
-    # TODO: Docs
-    def init_components(self, hparams):
-        ...
-
-    def init_latent(self, hparams):
-        ...
-
-    def init_comparison(self, hparams):
-        ...
-
-    def init_competition(self, hparams):
-        ...
-
-    def init_loss(self, hparams):
-        ...
-
-    def init_inference(self, hparams):
-        ...
-
-    def init_model_metrics(self):
-        self.register_torchmetric('train_accuracy', torchmetrics.Accuracy)
-
-    # Empty Steps
-    # TODO: Type hints
-    def components(self):
-        """
-        This step has no input.
-
-        It returns the components.
-        """
-        raise NotImplementedError(
-            "The components step has no reasonable default.")
-
-    def latent(self, batch, components):
-        """
-        The latent step receives the data batch and the components.
-        It can transform both by an arbitrary function.
-
-        It returns the transformed batch and components, each of the same length as the original input.
-        """
-        return batch, components
-
-    def comparison(self, batch, components):
-        """
-        Takes a batch of size N and the componentsset of size M.
-
-        It returns an NxMxD tensor containing D (usually 1) pairwise comparison measures.
-        """
-        raise NotImplementedError(
-            "The comparison step has no reasonable default.")
-
-    def competition(self, comparisonmeasures, components):
-        """
-        Takes the tensor of comparison measures.
-
-        Assigns a competition vector to each class.
-        """
-        raise NotImplementedError(
-            "The competition step has no reasonable default.")
-
-    def loss(self, comparisonmeasures, batch, components):
-        """
-        Takes the tensor of competition measures.
-
-        Calculates a single loss value
-        """
-        raise NotImplementedError("The loss step has no reasonable default.")
-
-    def inference(self, comparisonmeasures, components):
-        """
-        Takes the tensor of competition measures.
-
-        Returns the inferred vector.
-        """
-        raise NotImplementedError(
-            "The inference step has no reasonable default.")
-
-    def update_metrics_step(self, batch):
-        x, y = batch
-        preds = self(x)
-
-        for metric in self.registered_metrics:
-            instance = self.registered_metrics[metric].to(self.device)
-            value = instance(y, preds)
-
-            for name in self.registered_metric_names[metric]:
-                self.log(name, value)
-
-    def update_metrics_epoch(self):
-        for metric in self.registered_metrics:
-            instance = self.registered_metrics[metric].to(self.device)
-            value = instance.compute()
-
-            for name in self.registered_metric_names[metric]:
-                self.log(name, value)
-
-    # Lightning Hooks
-    def training_step(self, batch, batch_idx, optimizer_idx=None):
-        self.update_metrics_step(batch)
-
-        return self.loss_forward(batch)
-
-    def train_epoch_end(self, outs) -> None:
-        self.update_metrics_epoch()
-
-    def validation_step(self, batch, batch_idx):
-        return self.loss_forward(batch)
-
-    def test_step(self, batch, batch_idx):
-        return self.loss_forward(batch)

prototorch/models/clcc/test_clcc.py

@@ -1,76 +0,0 @@
-from typing import Optional
-
-import matplotlib.pyplot as plt
-import prototorch as pt
-import pytorch_lightning as pl
-import torch
-import torchmetrics
-from prototorch.core.initializers import SMCI, RandomNormalCompInitializer
-from prototorch.models.clcc.clcc_glvq import GLVQ, GLVQhparams
-from prototorch.models.clcc.clcc_scheme import CLCCScheme
-from prototorch.models.vis import Visualize2DVoronoiCallback
-
-# NEW STUFF
-# ##############################################################################
-
-
-# TODO: Metrics
-class MetricsTestCallback(pl.Callback):
-    metric_name = "test_cb_acc"
-
-    def setup(self,
-              trainer: pl.Trainer,
-              pl_module: CLCCScheme,
-              stage: Optional[str] = None) -> None:
-        pl_module.register_torchmetric(self.metric_name, torchmetrics.Accuracy)
-
-    def on_epoch_end(self, trainer: pl.Trainer,
-                     pl_module: pl.LightningModule) -> None:
-        metric = trainer.logged_metrics[self.metric_name]
-        if metric > 0.95:
-            trainer.should_stop = True
-
-
-# TODO: Pruning
-
-# ##############################################################################
-
-if __name__ == "__main__":
-    # Dataset
-    train_ds = pt.datasets.Iris(dims=[0, 2])
-    # Dataloaders
-    train_loader = torch.utils.data.DataLoader(train_ds,
-                                               batch_size=64,
-                                               num_workers=8)
-
-    components_initializer = SMCI(train_ds)
-
-    hparams = GLVQhparams(
-        distribution=dict(
-            num_classes=3,
-            per_class=2,
-        ),
-        component_initializer=components_initializer,
-    )
-    model = GLVQ(hparams)
-
-    print(model)
-    # Callbacks
-    vis = Visualize2DVoronoiCallback(
-        data=train_ds,
-        resolution=500,
-    )
-    metrics = MetricsTestCallback()
-
-    # Train
-    trainer = pl.Trainer(
-        callbacks=[
-            #vis,
-            metrics,
-        ],
-        gpus=1,
-        max_epochs=100,
-        weights_summary=None,
-        log_every_n_steps=1,
-    )
-    trainer.fit(model, train_loader)

prototorch/models/extras.py

@@ -5,7 +5,8 @@ Modules not yet available in prototorch go here temporarily.
 """
 
 import torch
-from prototorch.core.similarities import gaussian
+
+from ..core.similarities import gaussian
 
 
 def rank_scaled_gaussian(distances, lambd):
@@ -14,7 +15,46 @@ def rank_scaled_gaussian(distances, lambd):
     return torch.exp(-torch.exp(-ranks / lambd) * distances)
 
 
+def orthogonalization(tensors):
+    """Orthogonalization via polar decomposition """
+    u, _, v = torch.svd(tensors, compute_uv=True)
+    u_shape = tuple(list(u.shape))
+    v_shape = tuple(list(v.shape))
+
+    # reshape to (num x N x M)
+    u = torch.reshape(u, (-1, u_shape[-2], u_shape[-1]))
+    v = torch.reshape(v, (-1, v_shape[-2], v_shape[-1]))
+
+    out = u @ v.permute([0, 2, 1])
+
+    out = torch.reshape(out, u_shape[:-1] + (v_shape[-2], ))
+
+    return out
+
+
+def ltangent_distance(x, y, omegas):
+    r"""Localized Tangent distance.
+    Compute Orthogonal Complement: math:`\bm P_k = \bm I - \Omega_k \Omega_k^T`
+    Compute Tangent Distance: math:`{\| \bm P \bm x - \bm P_k \bm y_k \|}_2`
+
+    :param `torch.tensor` omegas: Three dimensional matrix
+    :rtype: `torch.tensor`
+    """
+    x, y = [arr.view(arr.size(0), -1) for arr in (x, y)]
+    p = torch.eye(omegas.shape[-2], device=omegas.device) - torch.bmm(
+        omegas, omegas.permute([0, 2, 1]))
+    projected_x = x @ p
+    projected_y = torch.diagonal(y @ p).T
+    expanded_y = torch.unsqueeze(projected_y, dim=1)
+    batchwise_difference = expanded_y - projected_x
+    differences_squared = batchwise_difference**2
+    distances = torch.sqrt(torch.sum(differences_squared, dim=2))
+    distances = distances.permute(1, 0)
+    return distances
+
+
 class GaussianPrior(torch.nn.Module):
+
     def __init__(self, variance):
         super().__init__()
         self.variance = variance
@@ -24,6 +64,7 @@ class GaussianPrior(torch.nn.Module):
 
 
 class RankScaledGaussianPrior(torch.nn.Module):
+
     def __init__(self, lambd):
         super().__init__()
         self.lambd = lambd
@@ -33,6 +74,7 @@ class RankScaledGaussianPrior(torch.nn.Module):
 
 
 class ConnectionTopology(torch.nn.Module):
+
     def __init__(self, agelimit, num_prototypes):
         super().__init__()
         self.agelimit = agelimit

prototorch/models/glvq.py

@@ -1,20 +1,29 @@
 """Models based on the GLVQ framework."""
 
 import torch
-from prototorch.core.competitions import wtac
-from prototorch.core.distances import lomega_distance, omega_distance, squared_euclidean_distance
-from prototorch.core.initializers import EyeTransformInitializer
-from prototorch.core.losses import GLVQLoss, lvq1_loss, lvq21_loss
-from prototorch.core.transforms import LinearTransform
-from prototorch.nn.wrappers import LambdaLayer, LossLayer
 from torch.nn.parameter import Parameter
 
-from .abstract import SupervisedPrototypeModel
-from .mixin import ImagePrototypesMixin
+from ..core.competitions import wtac
+from ..core.distances import (
+    lomega_distance,
+    omega_distance,
+    squared_euclidean_distance,
+)
+from ..core.initializers import EyeTransformInitializer
+from ..core.losses import (
+    GLVQLoss,
+    lvq1_loss,
+    lvq21_loss,
+)
+from ..core.transforms import LinearTransform
+from ..nn.wrappers import LambdaLayer, LossLayer
+from .abstract import ImagePrototypesMixin, SupervisedPrototypeModel
+from .extras import ltangent_distance, orthogonalization
 
 
 class GLVQ(SupervisedPrototypeModel):
     """Generalized Learning Vector Quantization."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -99,6 +108,7 @@ class SiameseGLVQ(GLVQ):
     transformation pipeline are only learned from the inputs.
 
     """
+
     def __init__(self,
                  hparams,
                  backbone=torch.nn.Identity(),
@@ -131,7 +141,7 @@ class SiameseGLVQ(GLVQ):
 
     def compute_distances(self, x):
         protos, _ = self.proto_layer()
-        x, protos = (arr.view(arr.size(0), -1) for arr in (x, protos))
+        x, protos = [arr.view(arr.size(0), -1) for arr in (x, protos)]
         latent_x = self.backbone(x)
         self.backbone.requires_grad_(self.both_path_gradients)
         latent_protos = self.backbone(protos)
@@ -165,6 +175,7 @@ class LVQMLN(SiameseGLVQ):
     rather in the embedding space.
 
     """
+
     def compute_distances(self, x):
         latent_protos, _ = self.proto_layer()
         latent_x = self.backbone(x)
@@ -180,6 +191,7 @@ class GRLVQ(SiameseGLVQ):
     TODO Make a RelevanceLayer. `bb_lr` is ignored otherwise.
 
     """
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -205,6 +217,7 @@ class SiameseGMLVQ(SiameseGLVQ):
     Implemented as a Siamese network with a linear transformation backbone.
 
     """
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -235,6 +248,7 @@ class GMLVQ(GLVQ):
     function. This makes it easier to implement a localized variant.
 
     """
+
     def __init__(self, hparams, **kwargs):
         distance_fn = kwargs.pop("distance_fn", omega_distance)
         super().__init__(hparams, distance_fn=distance_fn, **kwargs)
@@ -269,6 +283,7 @@ class GMLVQ(GLVQ):
 
 class LGMLVQ(GMLVQ):
     """Localized and Generalized Matrix Learning Vector Quantization."""
+
     def __init__(self, hparams, **kwargs):
         distance_fn = kwargs.pop("distance_fn", lomega_distance)
         super().__init__(hparams, distance_fn=distance_fn, **kwargs)
@@ -283,8 +298,48 @@ class LGMLVQ(GMLVQ):
         self.register_parameter("_omega", Parameter(omega))
 
 
+class GTLVQ(LGMLVQ):
+    """Localized and Generalized Tangent Learning Vector Quantization."""
+
+    def __init__(self, hparams, **kwargs):
+        distance_fn = kwargs.pop("distance_fn", ltangent_distance)
+        super().__init__(hparams, distance_fn=distance_fn, **kwargs)
+
+        omega_initializer = kwargs.get("omega_initializer")
+
+        if omega_initializer is not None:
+            subspace = omega_initializer.generate(self.hparams.input_dim,
+                                                  self.hparams.latent_dim)
+            omega = torch.repeat_interleave(subspace.unsqueeze(0),
+                                            self.num_prototypes,
+                                            dim=0)
+        else:
+            omega = torch.rand(
+                self.num_prototypes,
+                self.hparams.input_dim,
+                self.hparams.latent_dim,
+                device=self.device,
+            )
+
+        # Re-register `_omega` to override the one from the super class.
+        self.register_parameter("_omega", Parameter(omega))
+
+    def on_train_batch_end(self, outputs, batch, batch_idx, dataloader_idx):
+        with torch.no_grad():
+            self._omega.copy_(orthogonalization(self._omega))
+
+
+class SiameseGTLVQ(SiameseGLVQ, GTLVQ):
+    """Generalized Tangent Learning Vector Quantization.
+
+    Implemented as a Siamese network with a linear transformation backbone.
+
+    """
+
+
 class GLVQ1(GLVQ):
     """Generalized Learning Vector Quantization 1."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
         self.loss = LossLayer(lvq1_loss)
@@ -293,6 +348,7 @@ class GLVQ1(GLVQ):
 
 class GLVQ21(GLVQ):
     """Generalized Learning Vector Quantization 2.1."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
         self.loss = LossLayer(lvq21_loss)
@@ -315,3 +371,18 @@ class ImageGMLVQ(ImagePrototypesMixin, GMLVQ):
     after updates.
 
     """
+
+
+class ImageGTLVQ(ImagePrototypesMixin, GTLVQ):
+    """GTLVQ for training on image data.
+
+    GTLVQ model that constrains the prototypes to the range [0, 1] by clamping
+    after updates.
+
+    """
+
+    def on_train_batch_end(self, outputs, batch, batch_idx, dataloader_idx):
+        """Constrain the components to the range [0, 1] by clamping after updates."""
+        self.proto_layer.components.data.clamp_(0.0, 1.0)
+        with torch.no_grad():
+            self._omega.copy_(orthogonalization(self._omega))

prototorch/models/knn.py

@@ -2,16 +2,19 @@
 
 import warnings
 
-from prototorch.core.competitions import KNNC
-from prototorch.core.components import LabeledComponents
-from prototorch.core.initializers import LiteralCompInitializer, LiteralLabelsInitializer
-from prototorch.utils.utils import parse_data_arg
-
+from ..core.competitions import KNNC
+from ..core.components import LabeledComponents
+from ..core.initializers import (
+    LiteralCompInitializer,
+    LiteralLabelsInitializer,
+)
+from ..utils.utils import parse_data_arg
 from .abstract import SupervisedPrototypeModel
 
 
 class KNN(SupervisedPrototypeModel):
     """K-Nearest-Neighbors classification algorithm."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 

prototorch/models/lvq.py

@@ -1,15 +1,15 @@
 """LVQ models that are optimized using non-gradient methods."""
 
-from prototorch.core.losses import _get_dp_dm
-from prototorch.nn.activations import get_activation
-from prototorch.nn.wrappers import LambdaLayer
-
+from ..core.losses import _get_dp_dm
+from ..nn.activations import get_activation
+from ..nn.wrappers import LambdaLayer
+from .abstract import NonGradientMixin
 from .glvq import GLVQ
-from .mixin import NonGradientMixin
 
 
 class LVQ1(NonGradientMixin, GLVQ):
     """Learning Vector Quantization 1."""
+
     def training_step(self, train_batch, batch_idx, optimizer_idx=None):
         protos, plables = self.proto_layer()
         x, y = train_batch
@@ -39,6 +39,7 @@ class LVQ1(NonGradientMixin, GLVQ):
 
 class LVQ21(NonGradientMixin, GLVQ):
     """Learning Vector Quantization 2.1."""
+
     def training_step(self, train_batch, batch_idx, optimizer_idx=None):
         protos, plabels = self.proto_layer()
 
@@ -71,6 +72,7 @@ class MedianLVQ(NonGradientMixin, GLVQ):
     # TODO Avoid computing distances over and over
 
     """
+
     def __init__(self, hparams, verbose=True, **kwargs):
         self.verbose = verbose
         super().__init__(hparams, **kwargs)

prototorch/models/mixin.py

@@ -1,27 +0,0 @@
-class ProtoTorchMixin:
-    """All mixins are ProtoTorchMixins."""
-    pass
-
-
-class NonGradientMixin(ProtoTorchMixin):
-    """Mixin for custom non-gradient optimization."""
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.automatic_optimization = False
-
-    def training_step(self, train_batch, batch_idx, optimizer_idx=None):
-        raise NotImplementedError
-
-
-class ImagePrototypesMixin(ProtoTorchMixin):
-    """Mixin for models with image prototypes."""
-    def on_train_batch_end(self, outputs, batch, batch_idx, dataloader_idx):
-        """Constrain the components to the range [0, 1] by clamping after updates."""
-        self.proto_layer.components.data.clamp_(0.0, 1.0)
-
-    def get_prototype_grid(self, num_columns=2, return_channels_last=True):
-        from torchvision.utils import make_grid
-        grid = make_grid(self.components, nrow=num_columns)
-        if return_channels_last:
-            grid = grid.permute((1, 2, 0))
-        return grid.cpu()

prototorch/models/probabilistic.py

@@ -1,16 +1,17 @@
 """Probabilistic GLVQ methods"""
 
 import torch
-from prototorch.core.losses import nllr_loss, rslvq_loss
-from prototorch.core.pooling import stratified_min_pooling, stratified_sum_pooling
-from prototorch.nn.wrappers import LambdaLayer, LossLayer
 
+from ..core.losses import nllr_loss, rslvq_loss
+from ..core.pooling import stratified_min_pooling, stratified_sum_pooling
+from ..nn.wrappers import LambdaLayer, LossLayer
 from .extras import GaussianPrior, RankScaledGaussianPrior
 from .glvq import GLVQ, SiameseGMLVQ
 
 
 class CELVQ(GLVQ):
     """Cross-Entropy Learning Vector Quantization."""
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -29,6 +30,7 @@ class CELVQ(GLVQ):
 
 
 class ProbabilisticLVQ(GLVQ):
+
     def __init__(self, hparams, rejection_confidence=0.0, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -62,6 +64,7 @@ class ProbabilisticLVQ(GLVQ):
 
 class SLVQ(ProbabilisticLVQ):
     """Soft Learning Vector Quantization."""
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.loss = LossLayer(nllr_loss)
@@ -70,6 +73,7 @@ class SLVQ(ProbabilisticLVQ):
 
 class RSLVQ(ProbabilisticLVQ):
     """Robust Soft Learning Vector Quantization."""
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.loss = LossLayer(rslvq_loss)
@@ -81,6 +85,7 @@ class PLVQ(ProbabilisticLVQ, SiameseGMLVQ):
 
     TODO: Use Backbone LVQ instead
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.conditional_distribution = RankScaledGaussianPrior(

prototorch/models/unsupervised.py

@@ -2,15 +2,14 @@
 
 import numpy as np
 import torch
-from prototorch.core.competitions import wtac
-from prototorch.core.distances import squared_euclidean_distance
-from prototorch.core.losses import NeuralGasEnergy
-from prototorch.nn.wrappers import LambdaLayer
 
-from .abstract import UnsupervisedPrototypeModel
+from ..core.competitions import wtac
+from ..core.distances import squared_euclidean_distance
+from ..core.losses import NeuralGasEnergy
+from ..nn.wrappers import LambdaLayer
+from .abstract import NonGradientMixin, UnsupervisedPrototypeModel
 from .callbacks import GNGCallback
 from .extras import ConnectionTopology
-from .mixin import NonGradientMixin
 
 
 class KohonenSOM(NonGradientMixin, UnsupervisedPrototypeModel):
@@ -19,6 +18,7 @@ class KohonenSOM(NonGradientMixin, UnsupervisedPrototypeModel):
     TODO Allow non-2D grids
 
     """
+
     def __init__(self, hparams, **kwargs):
         h, w = hparams.get("shape")
         # Ignore `num_prototypes`
@@ -70,6 +70,7 @@ class KohonenSOM(NonGradientMixin, UnsupervisedPrototypeModel):
 
 
 class HeskesSOM(UnsupervisedPrototypeModel):
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -79,6 +80,7 @@ class HeskesSOM(UnsupervisedPrototypeModel):
 
 
 class NeuralGas(UnsupervisedPrototypeModel):
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 
@@ -111,6 +113,7 @@ class NeuralGas(UnsupervisedPrototypeModel):
 
 
 class GrowingNeuralGas(NeuralGas):
+
     def __init__(self, hparams, **kwargs):
         super().__init__(hparams, **kwargs)
 

prototorch/models/vis.py

@@ -5,18 +5,16 @@ import pytorch_lightning as pl
 import torch
 import torchvision
 from matplotlib import pyplot as plt
-from prototorch.utils.utils import generate_mesh, mesh2d
 from torch.utils.data import DataLoader, Dataset
 
-COLOR_UNLABELED = 'w'
+from ..utils.utils import mesh2d
 
 
 class Vis2DAbstract(pl.Callback):
+
     def __init__(self,
                  data,
-                 title=None,
-                 x_label=None,
-                 y_label=None,
+                 title="Prototype Visualization",
                  cmap="viridis",
                  border=0.1,
                  resolution=100,
@@ -48,8 +46,6 @@ class Vis2DAbstract(pl.Callback):
         self.y_train = y
 
         self.title = title
-        self.x_label = x_label
-        self.y_label = y_label
         self.fig = plt.figure(self.title)
         self.cmap = cmap
         self.border = border
@@ -62,19 +58,20 @@ class Vis2DAbstract(pl.Callback):
         self.pause_time = pause_time
         self.block = block
 
-    def show_on_current_epoch(self, trainer):
-        if self.show_last_only and trainer.current_epoch != trainer.max_epochs - 1:
-            return False
+    def precheck(self, trainer):
+        if self.show_last_only:
+            if trainer.current_epoch != trainer.max_epochs - 1:
+                return False
         return True
 
-    def setup_ax(self):
+    def setup_ax(self, xlabel=None, ylabel=None):
         ax = self.fig.gca()
         ax.cla()
         ax.set_title(self.title)
-        if self.x_label:
-            ax.set_xlabel(self.x_label)
-        if self.x_label:
-            ax.set_ylabel(self.y_label)
+        if xlabel:
+            ax.set_xlabel("Data dimension 1")
+        if ylabel:
+            ax.set_ylabel("Data dimension 2")
         if self.axis_off:
             ax.axis("off")
         return ax
@@ -121,75 +118,38 @@ class Vis2DAbstract(pl.Callback):
         plt.close()
 
 
-class Visualize2DVoronoiCallback(Vis2DAbstract):
-    def __init__(self, data, **kwargs):
-        super().__init__(data, **kwargs)
-
-        self.data_min = torch.min(self.x_train, axis=0).values
-        self.data_max = torch.max(self.x_train, axis=0).values
-
-    def current_span(self, proto_values):
-        proto_min = torch.min(proto_values, axis=0).values
-        proto_max = torch.max(proto_values, axis=0).values
-
-        overall_min = torch.minimum(proto_min, self.data_min)
-        overall_max = torch.maximum(proto_max, self.data_max)
-
-        return overall_min, overall_max
-
-    def get_voronoi_diagram(self, min, max, model):
-        mesh_input, (xx, yy) = generate_mesh(
-            min,
-            max,
-            border=self.border,
-            resolution=self.resolution,
-            device=model.device,
-        )
-
-        y_pred = model.predict(mesh_input)
-        return xx, yy, y_pred.reshape(xx.shape)
+class VisGLVQ2D(Vis2DAbstract):
 
     def on_epoch_end(self, trainer, pl_module):
-        if not self.show_on_current_epoch(trainer):
+        if not self.precheck(trainer):
             return True
 
-        # Extract Prototypes
-        proto_values = pl_module.prototypes
-        if hasattr(pl_module, "prototype_labels"):
-            proto_labels = pl_module.prototype_labels
-        else:
-            proto_labels = COLOR_UNLABELED
-
-        # Calculate Voronoi Diagram
-        overall_min, overall_max = self.current_span(proto_values)
-        xx, yy, y_pred = self.get_voronoi_diagram(
-            overall_min,
-            overall_max,
-            pl_module,
-        )
-
-        ax = self.setup_ax()
-        ax.contourf(
-            xx.cpu(),
-            yy.cpu(),
-            y_pred.cpu(),
-            cmap=self.cmap,
-            alpha=0.35,
-        )
-
-        self.plot_data(ax, self.x_train, self.y_train)
-        self.plot_protos(ax, proto_values, proto_labels)
+        protos = pl_module.prototypes
+        plabels = pl_module.prototype_labels
+        x_train, y_train = self.x_train, self.y_train
+        ax = self.setup_ax(xlabel="Data dimension 1",
+                           ylabel="Data dimension 2")
+        self.plot_data(ax, x_train, y_train)
+        self.plot_protos(ax, protos, plabels)
+        x = np.vstack((x_train, protos))
+        mesh_input, xx, yy = mesh2d(x, self.border, self.resolution)
+        _components = pl_module.proto_layer._components
+        mesh_input = torch.from_numpy(mesh_input).type_as(_components)
+        y_pred = pl_module.predict(mesh_input)
+        y_pred = y_pred.cpu().reshape(xx.shape)
+        ax.contourf(xx, yy, y_pred, cmap=self.cmap, alpha=0.35)
 
         self.log_and_display(trainer, pl_module)
 
 
 class VisSiameseGLVQ2D(Vis2DAbstract):
+
     def __init__(self, *args, map_protos=True, **kwargs):
         super().__init__(*args, **kwargs)
         self.map_protos = map_protos
 
     def on_epoch_end(self, trainer, pl_module):
-        if not self.show_on_current_epoch(trainer):
+        if not self.precheck(trainer):
             return True
 
         protos = pl_module.prototypes
@@ -222,12 +182,13 @@ class VisSiameseGLVQ2D(Vis2DAbstract):
 
 
 class VisGMLVQ2D(Vis2DAbstract):
+
     def __init__(self, *args, ev_proj=True, **kwargs):
         super().__init__(*args, **kwargs)
         self.ev_proj = ev_proj
 
     def on_epoch_end(self, trainer, pl_module):
-        if not self.show_on_current_epoch(trainer):
+        if not self.precheck(trainer):
             return True
 
         protos = pl_module.prototypes
@@ -254,16 +215,42 @@ class VisGMLVQ2D(Vis2DAbstract):
         self.log_and_display(trainer, pl_module)
 
 
-class VisNG2D(Vis2DAbstract):
+class VisCBC2D(Vis2DAbstract):
+
     def on_epoch_end(self, trainer, pl_module):
-        if not self.show_on_current_epoch(trainer):
+        if not self.precheck(trainer):
+            return True
+
+        x_train, y_train = self.x_train, self.y_train
+        protos = pl_module.components
+        ax = self.setup_ax(xlabel="Data dimension 1",
+                           ylabel="Data dimension 2")
+        self.plot_data(ax, x_train, y_train)
+        self.plot_protos(ax, protos, "w")
+        x = np.vstack((x_train, protos))
+        mesh_input, xx, yy = mesh2d(x, self.border, self.resolution)
+        _components = pl_module.components_layer._components
+        y_pred = pl_module.predict(
+            torch.Tensor(mesh_input).type_as(_components))
+        y_pred = y_pred.cpu().reshape(xx.shape)
+
+        ax.contourf(xx, yy, y_pred, cmap=self.cmap, alpha=0.35)
+
+        self.log_and_display(trainer, pl_module)
+
+
+class VisNG2D(Vis2DAbstract):
+
+    def on_epoch_end(self, trainer, pl_module):
+        if not self.precheck(trainer):
             return True
 
         x_train, y_train = self.x_train, self.y_train
         protos = pl_module.prototypes
         cmat = pl_module.topology_layer.cmat.cpu().numpy()
 
-        ax = self.setup_ax()
+        ax = self.setup_ax(xlabel="Data dimension 1",
+                           ylabel="Data dimension 2")
         self.plot_data(ax, x_train, y_train)
         self.plot_protos(ax, protos, "w")
 
@@ -281,6 +268,7 @@ class VisNG2D(Vis2DAbstract):
 
 
 class VisImgComp(Vis2DAbstract):
+
     def __init__(self,
                  *args,
                  random_data=0,
@@ -334,7 +322,7 @@ class VisImgComp(Vis2DAbstract):
         )
 
     def on_epoch_end(self, trainer, pl_module):
-        if not self.show_on_current_epoch(trainer):
+        if not self.precheck(trainer):
             return True
 
         if self.show:

setup.cfg

@@ -1,8 +1,23 @@
-[isort]
-profile = hug
-src_paths = isort, test
-
 [yapf]
 based_on_style = pep8
 spaces_before_comment = 2
 split_before_logical_operator = true
+
+[pylint]
+disable =
+	too-many-arguments,
+	too-few-public-methods,
+	fixme,
+
+
+[pycodestyle]
+max-line-length = 79
+
+[isort]
+profile = hug
+src_paths = isort, test
+multi_line_output = 3
+include_trailing_comma = True
+force_grid_wrap = 3
+use_parentheses = True
+line_length = 79

setup.py

@@ -18,7 +18,7 @@ PLUGIN_NAME = "models"
 PROJECT_URL = "https://github.com/si-cim/prototorch_models"
 DOWNLOAD_URL = "https://github.com/si-cim/prototorch_models.git"
 
-with open("README.md") as fh:
+with open("README.md", "r") as fh:
     long_description = fh.read()
 
 INSTALL_REQUIRES = [
@@ -54,7 +54,7 @@ ALL = CLI + DEV + DOCS + EXAMPLES + TESTS
 
 setup(
     name=safe_name("prototorch_" + PLUGIN_NAME),
-    version="0.3.0",
+    version="0.4.1",
     description="Pre-packaged prototype-based "
     "machine learning models using ProtoTorch and PyTorch-Lightning.",
     long_description=long_description,

tests/test_.py

@@ -4,6 +4,7 @@ import unittest
 
 
 class TestDummy(unittest.TestCase):
+
     def setUp(self):
         pass