Bump version: 0.4.5 → 0.5.0

Update Iris example to new component API
Update Tecator example to new component API
Update LGMLVQ example to new component API
Update GTLVQ to new component API

.bumpversion.cfg

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

RELEASE.md

@@ -1,5 +1,10 @@
 # ProtoTorch Releases
 
+## Release 0.5.0
+
+- Breaking: Removed deprecated `prototorch.modules.Prototypes1D`
+  - Use `prototorch.components.LabeledComponents` instead
+
 ## Release 0.2.0
 
 ### Includes

docs/source/conf.py

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

examples/glvq_iris.py

@@ -3,10 +3,10 @@
 import numpy as np
 import torch
 from matplotlib import pyplot as plt
+from prototorch.components import LabeledComponents, StratifiedMeanInitializer
 from prototorch.functions.competitions import wtac
 from prototorch.functions.distances import euclidean_distance
 from prototorch.modules.losses import GLVQLoss
-from prototorch.modules.prototypes import Prototypes1D
 from sklearn.datasets import load_iris
 from sklearn.preprocessing import StandardScaler
 from torchinfo import summary
@@ -24,19 +24,17 @@ class Model(torch.nn.Module):
     def __init__(self):
         """GLVQ model for training on 2D Iris data."""
         super().__init__()
-        self.proto_layer = Prototypes1D(
+        prototype_initializer = StratifiedMeanInitializer([x_train, y_train])
-            input_dim=2,
+        prototype_distribution = {"num_classes": 3, "prototypes_per_class": 3}
-            prototypes_per_class=3,
+        self.proto_layer = LabeledComponents(
-            num_classes=3,
+            prototype_distribution,
-            prototype_initializer="stratified_random",
+            prototype_initializer,
-            data=[x_train, y_train],
         )
 
     def forward(self, x):
-        protos = self.proto_layer.prototypes
+        prototypes, prototype_labels = self.proto_layer()
-        plabels = self.proto_layer.prototype_labels
+        distances = euclidean_distance(x, prototypes)
-        dis = euclidean_distance(x, protos)
+        return distances, prototype_labels
-        return dis, plabels
 
 
 # Build the GLVQ model
@@ -53,43 +51,46 @@ x_in = torch.Tensor(x_train)
 y_in = torch.Tensor(y_train)
 
 # Training loop
-title = "Prototype Visualization"
+TITLE = "Prototype Visualization"
-fig = plt.figure(title)
+fig = plt.figure(TITLE)
 for epoch in range(70):
     # Compute loss
-    dis, plabels = model(x_in)
+    distances, prototype_labels = model(x_in)
-    loss = criterion([dis, plabels], y_in)
+    loss = criterion([distances, prototype_labels], y_in)
+
+    # Compute Accuracy
     with torch.no_grad():
-        pred = wtac(dis, plabels)
+        predictions = wtac(distances, prototype_labels)
-        correct = pred.eq(y_in.view_as(pred)).sum().item()
+        correct = predictions.eq(y_in.view_as(predictions)).sum().item()
     acc = 100.0 * correct / len(x_train)
+
     print(
         f"Epoch: {epoch + 1:03d} Loss: {loss.item():05.02f} Acc: {acc:05.02f}%"
     )
 
-    # Take a gradient descent step
+    # Optimizer step
     optimizer.zero_grad()
     loss.backward()
     optimizer.step()
 
     # Get the prototypes form the model
-    protos = model.proto_layer.prototypes.data.numpy()
+    prototypes = model.proto_layer.components.numpy()
-    if np.isnan(np.sum(protos)):
+    if np.isnan(np.sum(prototypes)):
         print("Stopping training because of `nan` in prototypes.")
         break
 
     # Visualize the data and the prototypes
     ax = fig.gca()
     ax.cla()
-    ax.set_title(title)
+    ax.set_title(TITLE)
     ax.set_xlabel("Data dimension 1")
     ax.set_ylabel("Data dimension 2")
     cmap = "viridis"
     ax.scatter(x_train[:, 0], x_train[:, 1], c=y_train, edgecolor="k")
     ax.scatter(
-        protos[:, 0],
+        prototypes[:, 0],
-        protos[:, 1],
+        prototypes[:, 1],
-        c=plabels,
+        c=prototype_labels,
         cmap=cmap,
         edgecolor="k",
         marker="D",
@@ -97,7 +98,7 @@ for epoch in range(70):
     )
 
     # Paint decision regions
-    x = np.vstack((x_train, protos))
+    x = np.vstack((x_train, prototypes))
     x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
     y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
     xx, yy = np.meshgrid(np.arange(x_min, x_max, 1 / 50),
@@ -107,7 +108,7 @@ for epoch in range(70):
     torch_input = torch.Tensor(mesh_input)
     d = model(torch_input)[0]
     w_indices = torch.argmin(d, dim=1)
-    y_pred = torch.index_select(plabels, 0, w_indices)
+    y_pred = torch.index_select(prototype_labels, 0, w_indices)
     y_pred = y_pred.reshape(xx.shape)
 
     # Plot voronoi regions

examples/gmlvq_tecator.py

@@ -2,9 +2,9 @@
 
 import matplotlib.pyplot as plt
 import torch
+from prototorch.components import LabeledComponents, StratifiedMeanInitializer
 from prototorch.datasets.tecator import Tecator
 from prototorch.functions.distances import sed
-from prototorch.modules import Prototypes1D
 from prototorch.modules.losses import GLVQLoss
 from prototorch.utils.colors import get_legend_handles
 from torch.utils.data import DataLoader
@@ -18,22 +18,22 @@ class Model(torch.nn.Module):
     def __init__(self, **kwargs):
         """GMLVQ model as a siamese network."""
         super().__init__()
-        x, y = train_data.data, train_data.targets
+        prototype_initializer = StratifiedMeanInitializer(train_loader)
-        self.p1 = Prototypes1D(
+        prototype_distribution = {"num_classes": 2, "prototypes_per_class": 2}
-            input_dim=100,
+
-            prototypes_per_class=2,
+        self.proto_layer = LabeledComponents(
-            num_classes=2,
+            prototype_distribution,
-            prototype_initializer="stratified_random",
+            prototype_initializer,
-            data=[x, y],
         )
+
         self.omega = torch.nn.Linear(in_features=100,
                                      out_features=100,
                                      bias=False)
         torch.nn.init.eye_(self.omega.weight)
 
     def forward(self, x):
-        protos = self.p1.prototypes
+        protos = self.proto_layer.components
-        plabels = self.p1.prototype_labels
+        plabels = self.proto_layer.component_labels
 
         # Process `x` and `protos` through `omega`
         x_map = self.omega(x)
@@ -85,8 +85,8 @@ im = ax.imshow(omega.dot(omega.T), cmap="viridis")
 plt.show()
 
 # Get the prototypes form the model
-protos = model.p1.prototypes.data.numpy()
+protos = model.proto_layer.components.numpy()
-plabels = model.p1.prototype_labels
+plabels = model.proto_layer.component_labels.numpy()
 
 # Visualize the prototypes
 title = "Tecator Prototypes"

examples/gtlvq_mnist.py

@@ -24,7 +24,7 @@ batch_size_test = 1000
 learning_rate = 0.1
 momentum = 0.5
 log_interval = 10
-cuda = "cuda:1"
+cuda = "cuda:0"
 random_seed = 1
 device = torch.device(cuda if torch.cuda.is_available() else "cpu")
 
@@ -147,7 +147,7 @@ for epoch in range(num_epochs):
         optimizer.zero_grad()
 
         distances = model(x_train)
-        plabels = model.gtlvq.cls.prototype_labels.to(device)
+        plabels = model.gtlvq.cls.component_labels.to(device)
 
         # Compute loss.
         loss = criterion([distances, plabels], y_train)

examples/lgmlvq_iris.py

@@ -3,14 +3,12 @@
 import numpy as np
 import torch
 from matplotlib import pyplot as plt
-from sklearn.datasets import load_iris
+from prototorch.components import LabeledComponents, StratifiedMeanInitializer
-from sklearn.metrics import accuracy_score
-
 from prototorch.functions.competitions import stratified_min
 from prototorch.functions.distances import lomega_distance
-from prototorch.functions.init import eye_
 from prototorch.modules.losses import GLVQLoss
-from prototorch.modules.prototypes import Prototypes1D
+from sklearn.datasets import load_iris
+from sklearn.metrics import accuracy_score
 
 # Prepare training data
 x_train, y_train = load_iris(True)
@@ -22,19 +20,19 @@ class Model(torch.nn.Module):
     def __init__(self):
         """Local-GMLVQ model."""
         super().__init__()
-        self.p1 = Prototypes1D(
+
-            input_dim=2,
+        prototype_initializer = StratifiedMeanInitializer([x_train, y_train])
-            prototype_distribution=[1, 2, 2],
+        prototype_distribution = [1, 2, 2]
-            prototype_initializer="stratified_random",
+        self.proto_layer = LabeledComponents(
-            data=[x_train, y_train],
+            prototype_distribution,
+            prototype_initializer,
         )
-        omegas = torch.zeros(5, 2, 2)
+
+        omegas = torch.eye(2, 2).repeat(5, 1, 1)
         self.omegas = torch.nn.Parameter(omegas)
-        eye_(self.omegas)
 
     def forward(self, x):
-        protos = self.p1.prototypes
+        protos, plabels = self.proto_layer()
-        plabels = self.p1.prototype_labels
         omegas = self.omegas
         dis = lomega_distance(x, protos, omegas)
         return dis, plabels
@@ -69,7 +67,7 @@ for epoch in range(100):
     optimizer.step()
 
     # Get the prototypes form the model
-    protos = model.p1.prototypes.data.numpy()
+    protos = model.proto_layer.components.numpy()
 
     # Visualize the data and the prototypes
     ax = fig.gca()

prototorch/__init__.py

@@ -8,7 +8,7 @@ from . import components, datasets, functions, modules, utils
 from .datasets import *
 
 # Core Setup
-__version__ = "0.4.5"
+__version__ = "0.5.0"
 
 __all_core__ = [
     "datasets",

prototorch/modules/__init__.py

@@ -1,7 +1 @@
 """ProtoTorch modules."""
-
-from .prototypes import Prototypes1D
-
-__all__ = [
-    "Prototypes1D",
-]

prototorch/modules/models.py

@@ -1,9 +1,10 @@
 import torch
+from prototorch.components import LabeledComponents, StratifiedMeanInitializer
 from prototorch.functions.distances import euclidean_distance_matrix
 from prototorch.functions.normalization import orthogonalization
-from prototorch.modules.prototypes import Prototypes1D
 from torch import nn
 
+
 class GTLVQ(nn.Module):
     r""" Generalized Tangent Learning Vector Quantization
 
@@ -81,13 +82,13 @@ class GTLVQ(nn.Module):
         self.feature_dim = feature_dim
         self.num_classes = num_classes
 
-        self.cls = Prototypes1D(
+        cls_initializer = StratifiedMeanInitializer(prototype_data)
-            input_dim=feature_dim,
+        cls_distribution = {
-            prototypes_per_class=prototypes_per_class,
+            "num_classes": num_classes,
-            nclasses=num_classes,
+            "prototypes_per_class": prototypes_per_class,
-            prototype_initializer="stratified_mean",
+        }
-            data=prototype_data,
+
-        )
+        self.cls = LabeledComponents(cls_distribution, cls_initializer)
 
         if subspace_data is None:
             raise ValueError("Init Data must be specified!")
@@ -119,12 +120,12 @@ class GTLVQ(nn.Module):
         subspaces = subspace[:, :num_subspaces]
         self.subspaces = nn.Parameter(subspaces, requires_grad=True)
 
-    def init_local_subspace(self, data,num_subspaces,num_protos):
+    def init_local_subspace(self, data, num_subspaces, num_protos):
-        data = data -  torch.mean(data,dim=0)
+        data = data - torch.mean(data, dim=0)
-        _,_,v = torch.svd(data,some=False)
+        _, _, v = torch.svd(data, some=False)
-        v = v[:,:num_subspaces]
+        v = v[:, :num_subspaces]
-        subspaces = v.unsqueeze(0).repeat_interleave(num_protos,0)
+        subspaces = v.unsqueeze(0).repeat_interleave(num_protos, 0)
-        self.subspaces = nn.Parameter(subspaces,requires_grad=True)
+        self.subspaces = nn.Parameter(subspaces, requires_grad=True)
 
     def global_tangent_distances(self, x):
         # Tangent Projection
@@ -138,22 +139,23 @@ class GTLVQ(nn.Module):
     def local_tangent_distances(self, x):
 
         # Tangent Distance
-        x = x.unsqueeze(1).expand(x.size(0), self.cls.prototypes.size(0),
+        x = x.unsqueeze(1).expand(x.size(0), self.cls.num_components,
                                   x.size(-1))
-        protos = self.cls.prototypes.unsqueeze(0).expand(
+        protos = self.cls()[0].unsqueeze(0).expand(x.size(0),
-            x.size(0), self.cls.prototypes.size(0), x.size(-1))
+                                                   self.cls.num_components,
+                                                   x.size(-1))
         projectors = torch.eye(
             self.subspaces.shape[-2], device=x.device) - torch.bmm(
                 self.subspaces, self.subspaces.permute([0, 2, 1]))
         diff = (x - protos)
         diff = diff.permute([1, 0, 2])
         diff = torch.bmm(diff, projectors)
-        diff = torch.norm(diff,2,dim=-1).T
+        diff = torch.norm(diff, 2, dim=-1).T
         return diff
 
     def get_parameters(self):
         return {
-            "params": self.cls.prototypes,
+            "params": self.cls.components,
         }, {
             "params": self.subspaces
         }

prototorch/modules/prototypes.py

@@ -1,137 +0,0 @@
-"""ProtoTorch prototype modules."""
-
-import warnings
-
-import torch
-from prototorch.functions.initializers import get_initializer
-
-
-class _Prototypes(torch.nn.Module):
-    """Abstract prototypes class."""
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def _validate_prototype_distribution(self):
-        if 0 in self.prototype_distribution:
-            warnings.warn("Are you sure about the `0` in "
-                          "`prototype_distribution`?")
-
-    def extra_repr(self):
-        return f"prototypes.shape: {tuple(self.prototypes.shape)}"
-
-    def forward(self):
-        return self.prototypes, self.prototype_labels
-
-
-class Prototypes1D(_Prototypes):
-    """Create a learnable set of one-dimensional prototypes.
-
-    TODO Complete this doc-string.
-    """
-    def __init__(
-        self,
-        prototypes_per_class=1,
-        prototype_initializer="ones",
-        prototype_distribution=None,
-        data=None,
-        dtype=torch.float32,
-        one_hot_labels=False,
-        **kwargs,
-    ):
-        warnings.warn(
-            PendingDeprecationWarning(
-                "Prototypes1D will be replaced in future versions."))
-
-        # Convert tensors to python lists before processing
-        if prototype_distribution is not None:
-            if not isinstance(prototype_distribution, list):
-                prototype_distribution = prototype_distribution.tolist()
-
-        if data is None:
-            if "input_dim" not in kwargs:
-                raise NameError("`input_dim` required if "
-                                "no `data` is provided.")
-            if prototype_distribution:
-                kwargs_num_classes = sum(prototype_distribution)
-            else:
-                if "num_classes" not in kwargs:
-                    raise NameError("`prototype_distribution` required if "
-                                    "both `data` and `num_classes` are not "
-                                    "provided.")
-                kwargs_num_classes = kwargs.pop("num_classes")
-            input_dim = kwargs.pop("input_dim")
-            if prototype_initializer in [
-                    "stratified_mean", "stratified_random"
-            ]:
-                warnings.warn(
-                    f"`prototype_initializer`: `{prototype_initializer}` "
-                    "requires `data`, but `data` is not provided. "
-                    "Using randomly generated data instead.")
-            x_train = torch.rand(kwargs_num_classes, input_dim)
-            y_train = torch.arange(kwargs_num_classes)
-            if one_hot_labels:
-                y_train = torch.eye(kwargs_num_classes)[y_train]
-            data = [x_train, y_train]
-
-        x_train, y_train = data
-        x_train = torch.as_tensor(x_train).type(dtype)
-        y_train = torch.as_tensor(y_train).type(torch.int)
-        num_classes = torch.unique(y_train, dim=-1).shape[-1]
-
-        if num_classes == 1:
-            warnings.warn("Are you sure about having one class only?")
-
-        if x_train.ndim != 2:
-            raise ValueError("`data[0].ndim != 2`.")
-
-        if y_train.ndim == 2:
-            if y_train.shape[1] == 1 and one_hot_labels:
-                raise ValueError("`one_hot_labels` is set to `True` "
-                                 "but target labels are not one-hot-encoded.")
-            if y_train.shape[1] != 1 and not one_hot_labels:
-                raise ValueError("`one_hot_labels` is set to `False` "
-                                 "but target labels in `data` "
-                                 "are one-hot-encoded.")
-        if y_train.ndim == 1 and one_hot_labels:
-            raise ValueError("`one_hot_labels` is set to `True` "
-                             "but target labels are not one-hot-encoded.")
-
-        # Verify input dimension if `input_dim` is provided
-        if "input_dim" in kwargs:
-            input_dim = kwargs.pop("input_dim")
-            if input_dim != x_train.shape[1]:
-                raise ValueError(f"Provided `input_dim`={input_dim} does "
-                                 "not match data dimension "
-                                 f"`data[0].shape[1]`={x_train.shape[1]}")
-
-        # Verify the number of classes if `num_classes` is provided
-        if "num_classes" in kwargs:
-            kwargs_num_classes = kwargs.pop("num_classes")
-            if kwargs_num_classes != num_classes:
-                raise ValueError(
-                    f"Provided `num_classes={kwargs_num_classes}` does "
-                    "not match data labels "
-                    "`torch.unique(data[1]).shape[0]`"
-                    f"={num_classes}")
-
-        super().__init__(**kwargs)
-
-        if not prototype_distribution:
-            prototype_distribution = [prototypes_per_class] * num_classes
-        with torch.no_grad():
-            self.prototype_distribution = torch.tensor(prototype_distribution)
-
-        self._validate_prototype_distribution()
-
-        self.prototype_initializer = get_initializer(prototype_initializer)
-        prototypes, prototype_labels = self.prototype_initializer(
-            x_train,
-            y_train,
-            prototype_distribution=self.prototype_distribution,
-            one_hot=one_hot_labels,
-        )
-
-        # Register module parameters
-        self.prototypes = torch.nn.Parameter(prototypes)
-        self.prototype_labels = torch.nn.Parameter(
-            prototype_labels.type(dtype)).requires_grad_(False)

setup.py

@@ -43,7 +43,7 @@ ALL = DATASETS + DEV + DOCS + EXAMPLES + TESTS
 
 setup(
     name="prototorch",
-    version="0.4.5",
+    version="0.5.0",
     description="Highly extensible, GPU-supported "
     "Learning Vector Quantization (LVQ) toolbox "
     "built using PyTorch and its nn API.",

tests/test_modules.py

@@ -1,297 +0,0 @@
-"""ProtoTorch modules test suite."""
-
-import unittest
-
-import numpy as np
-import torch
-from prototorch.modules import losses, prototypes
-
-
-class TestPrototypes(unittest.TestCase):
-    def setUp(self):
-        self.x = torch.tensor(
-            [[0, -1, -2], [10, 11, 12], [0, 0, 0], [2, 2, 2]],
-            dtype=torch.float32)
-        self.y = torch.tensor([0, 0, 1, 1])
-        self.gen = torch.manual_seed(42)
-
-    def test_prototypes1d_init_without_input_dim(self):
-        with self.assertRaises(NameError):
-            _ = prototypes.Prototypes1D(num_classes=2)
-
-    def test_prototypes1d_init_without_num_classes(self):
-        with self.assertRaises(NameError):
-            _ = prototypes.Prototypes1D(input_dim=1)
-
-    def test_prototypes1d_init_with_num_classes_1(self):
-        with self.assertWarns(UserWarning):
-            _ = prototypes.Prototypes1D(num_classes=1, input_dim=1)
-
-    def test_prototypes1d_init_without_pdist(self):
-        p1 = prototypes.Prototypes1D(
-            input_dim=6,
-            num_classes=2,
-            prototypes_per_class=4,
-            prototype_initializer="ones",
-        )
-        protos = p1.prototypes
-        actual = protos.detach().numpy()
-        desired = torch.ones(8, 6)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_init_without_data(self):
-        pdist = [2, 2]
-        p1 = prototypes.Prototypes1D(input_dim=3,
-                                     prototype_distribution=pdist,
-                                     prototype_initializer="zeros")
-        protos = p1.prototypes
-        actual = protos.detach().numpy()
-        desired = torch.zeros(4, 3)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_proto_init_without_data(self):
-        with self.assertWarns(UserWarning):
-            _ = prototypes.Prototypes1D(
-                input_dim=3,
-                num_classes=2,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=None,
-            )
-
-    def test_prototypes1d_init_torch_pdist(self):
-        pdist = torch.tensor([2, 2])
-        p1 = prototypes.Prototypes1D(input_dim=3,
-                                     prototype_distribution=pdist,
-                                     prototype_initializer="zeros")
-        protos = p1.prototypes
-        actual = protos.detach().numpy()
-        desired = torch.zeros(4, 3)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_init_without_inputdim_with_data(self):
-        _ = prototypes.Prototypes1D(
-            num_classes=2,
-            prototypes_per_class=1,
-            prototype_initializer="stratified_mean",
-            data=[[[1.0], [0.0]], [1, 0]],
-        )
-
-    def test_prototypes1d_init_with_int_data(self):
-        _ = prototypes.Prototypes1D(
-            num_classes=2,
-            prototypes_per_class=1,
-            prototype_initializer="stratified_mean",
-            data=[[[1], [0]], [1, 0]],
-        )
-
-    def test_prototypes1d_init_one_hot_without_data(self):
-        _ = prototypes.Prototypes1D(
-            input_dim=1,
-            num_classes=2,
-            prototypes_per_class=1,
-            prototype_initializer="stratified_mean",
-            data=None,
-            one_hot_labels=True,
-        )
-
-    def test_prototypes1d_init_one_hot_labels_false(self):
-        """Test if ValueError is raised when `one_hot_labels` is set to `False`
-        but the provided `data` has one-hot encoded labels.
-        """
-        with self.assertRaises(ValueError):
-            _ = prototypes.Prototypes1D(
-                input_dim=1,
-                num_classes=2,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=([[0.0], [1.0]], [[0, 1], [1, 0]]),
-                one_hot_labels=False,
-            )
-
-    def test_prototypes1d_init_1d_y_data_one_hot_labels_true(self):
-        """Test if ValueError is raised when `one_hot_labels` is set to `True`
-        but the provided `data` does not contain one-hot encoded labels.
-        """
-        with self.assertRaises(ValueError):
-            _ = prototypes.Prototypes1D(
-                input_dim=1,
-                num_classes=2,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=([[0.0], [1.0]], [0, 1]),
-                one_hot_labels=True,
-            )
-
-    def test_prototypes1d_init_one_hot_labels_true(self):
-        """Test if ValueError is raised when `one_hot_labels` is set to `True`
-        but the provided `data` contains 2D targets but
-        does not contain one-hot encoded labels.
-        """
-        with self.assertRaises(ValueError):
-            _ = prototypes.Prototypes1D(
-                input_dim=1,
-                num_classes=2,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=([[0.0], [1.0]], [[0], [1]]),
-                one_hot_labels=True,
-            )
-
-    def test_prototypes1d_init_with_int_dtype(self):
-        with self.assertRaises(RuntimeError):
-            _ = prototypes.Prototypes1D(
-                num_classes=2,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=[[[1], [0]], [1, 0]],
-                dtype=torch.int32,
-            )
-
-    def test_prototypes1d_inputndim_with_data(self):
-        with self.assertRaises(ValueError):
-            _ = prototypes.Prototypes1D(input_dim=1,
-                                        num_classes=1,
-                                        prototypes_per_class=1,
-                                        data=[[1.0], [1]])
-
-    def test_prototypes1d_inputdim_with_data(self):
-        with self.assertRaises(ValueError):
-            _ = prototypes.Prototypes1D(
-                input_dim=2,
-                num_classes=2,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=[[[1.0], [0.0]], [1, 0]],
-            )
-
-    def test_prototypes1d_num_classes_with_data(self):
-        """Test ValueError raise if provided `num_classes` is not the same
-        as the one computed from the provided `data`.
-        """
-        with self.assertRaises(ValueError):
-            _ = prototypes.Prototypes1D(
-                input_dim=1,
-                num_classes=1,
-                prototypes_per_class=1,
-                prototype_initializer="stratified_mean",
-                data=[[[1.0], [2.0]], [1, 2]],
-            )
-
-    def test_prototypes1d_init_with_ppc(self):
-        p1 = prototypes.Prototypes1D(data=[self.x, self.y],
-                                     prototypes_per_class=2,
-                                     prototype_initializer="zeros")
-        protos = p1.prototypes
-        actual = protos.detach().numpy()
-        desired = torch.zeros(4, 3)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_init_with_pdist(self):
-        p1 = prototypes.Prototypes1D(
-            data=[self.x, self.y],
-            prototype_distribution=[6, 9],
-            prototype_initializer="zeros",
-        )
-        protos = p1.prototypes
-        actual = protos.detach().numpy()
-        desired = torch.zeros(15, 3)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_func_initializer(self):
-        def my_initializer(*args, **kwargs):
-            return torch.full((2, 99), 99.0), torch.tensor([0, 1])
-
-        p1 = prototypes.Prototypes1D(
-            input_dim=99,
-            num_classes=2,
-            prototypes_per_class=1,
-            prototype_initializer=my_initializer,
-        )
-        protos = p1.prototypes
-        actual = protos.detach().numpy()
-        desired = 99 * torch.ones(2, 99)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_forward(self):
-        p1 = prototypes.Prototypes1D(data=[self.x, self.y])
-        protos, _ = p1()
-        actual = protos.detach().numpy()
-        desired = torch.ones(2, 3)
-        mismatch = np.testing.assert_array_almost_equal(actual,
-                                                        desired,
-                                                        decimal=5)
-        self.assertIsNone(mismatch)
-
-    def test_prototypes1d_dist_validate(self):
-        p1 = prototypes.Prototypes1D(input_dim=0, prototype_distribution=[0])
-        with self.assertWarns(UserWarning):
-            _ = p1._validate_prototype_distribution()
-
-    def test_prototypes1d_validate_extra_repr_not_empty(self):
-        p1 = prototypes.Prototypes1D(input_dim=0, prototype_distribution=[0])
-        rep = p1.extra_repr()
-        self.assertNotEqual(rep, "")
-
-    def tearDown(self):
-        del self.x, self.y, self.gen
-        _ = torch.seed()
-
-
-class TestLosses(unittest.TestCase):
-    def setUp(self):
-        pass
-
-    def test_glvqloss_init(self):
-        _ = losses.GLVQLoss(0, "swish_beta", beta=20)
-
-    def test_glvqloss_forward_1ppc(self):
-        criterion = losses.GLVQLoss(margin=0,
-                                    squashing="sigmoid_beta",
-                                    beta=100)
-        d = torch.stack([torch.ones(100), torch.zeros(100)], dim=1)
-        labels = torch.tensor([0, 1])
-        targets = torch.ones(100)
-        outputs = [d, labels]
-        loss = criterion(outputs, targets)
-        loss_value = loss.item()
-        self.assertAlmostEqual(loss_value, 0.0)
-
-    def test_glvqloss_forward_2ppc(self):
-        criterion = losses.GLVQLoss(margin=0,
-                                    squashing="sigmoid_beta",
-                                    beta=100)
-        d = torch.stack([
-            torch.ones(100),
-            torch.ones(100),
-            torch.zeros(100),
-            torch.ones(100)
-        ],
-                        dim=1)
-        labels = torch.tensor([0, 0, 1, 1])
-        targets = torch.ones(100)
-        outputs = [d, labels]
-        loss = criterion(outputs, targets)
-        loss_value = loss.item()
-        self.assertAlmostEqual(loss_value, 0.0)
-
-    def tearDown(self):
-        pass