chore: merge dev into master

prototorch/core/initializers.py

@@ -32,6 +32,12 @@ class LiteralCompInitializer(AbstractComponentsInitializer):
 
     def generate(self, num_components: int = 0):
         """Ignore `num_components` and simply return `self.components`."""
+        provided_num_components = len(self.components)
+        if provided_num_components != num_components:
+            wmsg = f"The number of components ({provided_num_components}) " \
+                f"provided to {self.__class__.__name__} " \
+                f"does not match the expected number ({num_components})."
+            warnings.warn(wmsg)
         if not isinstance(self.components, torch.Tensor):
             wmsg = f"Converting components to {torch.Tensor}..."
             warnings.warn(wmsg)
@@ -231,6 +237,8 @@ class AbstractStratifiedCompInitializer(AbstractClassAwareCompInitializer):
         components = torch.tensor([])
         for k, v in distribution.items():
             stratified_data = self.data[self.targets == k]
+            if len(stratified_data) == 0:
+                raise ValueError(f"No data available for class {k}.")
             initializer = self.subinit_type(
                 stratified_data,
                 noise=self.noise,
@@ -457,7 +465,15 @@ class OnesLinearTransformInitializer(AbstractLinearTransformInitializer):
         return self.generate_end_hook(weights)
 
 
-class EyeTransformInitializer(AbstractLinearTransformInitializer):
+class RandomLinearTransformInitializer(AbstractLinearTransformInitializer):
+    """Initialize a matrix with random values."""
+
+    def generate(self, in_dim: int, out_dim: int):
+        weights = torch.rand(in_dim, out_dim)
+        return self.generate_end_hook(weights)
+
+
+class EyeLinearTransformInitializer(AbstractLinearTransformInitializer):
     """Initialize a matrix with the largest possible identity matrix."""
 
     def generate(self, in_dim: int, out_dim: int):
@@ -496,6 +512,13 @@ class PCALinearTransformInitializer(AbstractDataAwareLTInitializer):
         return self.generate_end_hook(weights)
 
 
+class LiteralLinearTransformInitializer(AbstractDataAwareLTInitializer):
+    """'Generate' the provided weights."""
+
+    def generate(self, in_dim: int, out_dim: int):
+        return self.generate_end_hook(self.data)
+
+
 # Aliases - Components
 CACI = ClassAwareCompInitializer
 DACI = DataAwareCompInitializer
@@ -524,7 +547,9 @@ RRI = RandomReasoningsInitializer
 ZRI = ZerosReasoningsInitializer
 
 # Aliases - Transforms
-Eye = EyeTransformInitializer
+ELTI = Eye = EyeLinearTransformInitializer
 OLTI = OnesLinearTransformInitializer
+RLTI = RandomLinearTransformInitializer
 ZLTI = ZerosLinearTransformInitializer
 PCALTI = PCALinearTransformInitializer
+LLTI = LiteralLinearTransformInitializer

prototorch/core/losses.py

@@ -107,14 +107,24 @@ def margin_loss(y_pred, y_true, margin=0.3):
 
 class GLVQLoss(torch.nn.Module):
 
-    def __init__(self, margin=0.0, transfer_fn="identity", beta=10, **kwargs):
+    def __init__(self,
+                 margin=0.0,
+                 transfer_fn="identity",
+                 beta=10,
+                 add_dp=False,
+                 **kwargs):
         super().__init__(**kwargs)
         self.margin = margin
         self.transfer_fn = get_activation(transfer_fn)
         self.beta = torch.tensor(beta)
+        self.add_dp = add_dp
 
     def forward(self, outputs, targets, plabels):
-        mu = glvq_loss(outputs, targets, prototype_labels=plabels)
+        # mu = glvq_loss(outputs, targets, plabels)
+        dp, dm = _get_dp_dm(outputs, targets, plabels)
+        mu = (dp - dm) / (dp + dm)
+        if self.add_dp:
+            mu = mu + dp
         batch_loss = self.transfer_fn(mu + self.margin, beta=self.beta)
         return batch_loss.sum()
 

prototorch/core/transforms.py

@@ -5,7 +5,7 @@ from torch.nn.parameter import Parameter
 
 from .initializers import (
     AbstractLinearTransformInitializer,
-    EyeTransformInitializer,
+    EyeLinearTransformInitializer,
 )
 
 
@@ -16,7 +16,7 @@ class LinearTransform(torch.nn.Module):
         in_dim: int,
         out_dim: int,
         initializer:
-        AbstractLinearTransformInitializer = EyeTransformInitializer()):
+        AbstractLinearTransformInitializer = EyeLinearTransformInitializer()):
         super().__init__()
         self.set_weights(in_dim, out_dim, initializer)
 
@@ -32,12 +32,15 @@ class LinearTransform(torch.nn.Module):
         in_dim: int,
         out_dim: int,
         initializer:
-        AbstractLinearTransformInitializer = EyeTransformInitializer()):
+        AbstractLinearTransformInitializer = EyeLinearTransformInitializer()):
         weights = initializer.generate(in_dim, out_dim)
         self._register_weights(weights)
 
     def forward(self, x):
-        return x @ self.weights
+        return x @ self._weights
+
+    def extra_repr(self):
+        return f"weights: (shape: {tuple(self._weights.shape)})"
 
 
 # Aliases