Bump version: 0.4.2 → 0.4.3

.bumpversion.cfg

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

docs/source/conf.py

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

prototorch/__init__.py

@@ -1,7 +1,7 @@
 """ProtoTorch package."""
 
 # Core Setup
-__version__ = "0.4.2"
+__version__ = "0.4.3"
 
 __all_core__ = [
     "datasets",

prototorch/components/components.py

@@ -67,8 +67,9 @@ class LabeledComponents(Components):
                  *,
                  initialized_components=None):
         if initialized_components is not None:
-            super().__init__(initialized_components=initialized_components[0])
-            self._labels = initialized_components[1]
+            components, component_labels = initialized_components
+            super().__init__(initialized_components=components)
+            self._labels = component_labels
         else:
             self._initialize_labels(distribution)
             super().__init__(number_of_components=len(self._labels),

prototorch/datasets/__init__.py

@@ -1,11 +1,6 @@
 """ProtoTorch datasets."""
 
 from .abstract import NumpyDataset
+from .iris import Iris
 from .spiral import Spiral
 from .tecator import Tecator
-
-__all__ = [
-    "NumpyDataset",
-    "Spiral",
-    "Tecator",
-]

prototorch/functions/competitions.py

@@ -3,7 +3,6 @@
 import torch
 
 
-# @torch.jit.script
 def stratified_min(distances, labels):
     clabels = torch.unique(labels, dim=0)
     nclasses = clabels.size()[0]
@@ -31,15 +30,14 @@ def stratified_min(distances, labels):
     return winning_distances.T  # return with `batch_size` first
 
 
-# @torch.jit.script
 def wtac(distances, labels):
     winning_indices = torch.min(distances, dim=1).indices
     winning_labels = labels[winning_indices].squeeze()
     return winning_labels
 
 
-# @torch.jit.script
-def knnc(distances, labels, k):
-    winning_indices = torch.topk(-distances, k=k.item(), dim=1).indices
-    winning_labels = labels[winning_indices].squeeze()
+def knnc(distances, labels, k=1):
+    winning_indices = torch.topk(-distances, k=k, dim=1).indices
+    winning_labels = torch.mode(labels[winning_indices].squeeze(),
+                                dim=1).values
     return winning_labels

prototorch/functions/distances.py

@@ -3,11 +3,8 @@
 import numpy as np
 import torch
 
-from prototorch.functions.helper import (
-    _check_shapes,
-    _int_and_mixed_shape,
-    equal_int_shape,
-)
+from prototorch.functions.helper import (_check_shapes, _int_and_mixed_shape,
+                                         equal_int_shape)
 
 
 def squared_euclidean_distance(x, y):
@@ -264,86 +261,5 @@ def tangent_distance(signals, protos, subspaces, squared=False, epsilon=1e-10):
             return diss.permute([1, 0, 2]).squeeze(-1)
 
 
-class KernelDistance:
-    r"""Kernel Distance
-
-    Distance based on a kernel function.
-    """
-    def __init__(self, kernel_fn):
-        self.kernel_fn = kernel_fn
-
-    def __call__(self, x_batch: torch.Tensor, y_batch: torch.Tensor):
-        return self._single_call(x_batch, y_batch)
-
-    def _single_call(self, x, y):
-        remove_dims = []
-        if len(x.shape) == 1:
-            x = x.unsqueeze(0)
-            remove_dims.append(0)
-        if len(y.shape) == 1:
-            y = y.unsqueeze(0)
-            remove_dims.append(-1)
-
-        output = self.kernel_fn(x, x).diag().unsqueeze(1) - 2 * self.kernel_fn(
-            x, y) + self.kernel_fn(y, y).diag()
-
-        for dim in remove_dims:
-            output.squeeze_(dim)
-
-        return torch.sqrt(output)
-
-
-class BatchKernelDistance:
-    r"""Kernel Distance
-
-    Distance based on a kernel function.
-    """
-    def __init__(self, kernel_fn):
-        self.kernel_fn = kernel_fn
-
-    def __call__(self, x_batch: torch.Tensor, y_batch: torch.Tensor):
-        remove_dims = 0
-        # Extend Single inputs
-        if len(x_batch.shape) == 1:
-            x_batch = x_batch.unsqueeze(0)
-            remove_dims += 1
-        if len(y_batch.shape) == 1:
-            y_batch = y_batch.unsqueeze(0)
-            remove_dims += 1
-
-        # Loop over batches
-        output = torch.FloatTensor(len(x_batch), len(y_batch))
-        for i, x in enumerate(x_batch):
-            for j, y in enumerate(y_batch):
-                output[i][j] = self._single_call(x, y)
-
-        for _ in range(remove_dims):
-            output.squeeze_(0)
-
-        return output
-
-    def _single_call(self, x, y):
-        kappa_xx = self.kernel_fn(x, x)
-        kappa_xy = self.kernel_fn(x, y)
-        kappa_yy = self.kernel_fn(y, y)
-
-        squared_distance = kappa_xx - 2 * kappa_xy + kappa_yy
-
-        return torch.sqrt(squared_distance)
-
-
-class SquaredKernelDistance(KernelDistance):
-    r"""Squared Kernel Distance
-
-    Kernel distance without final squareroot.
-    """
-    def single_call(self, x, y):
-        kappa_xx = self.kernel_fn(x, x)
-        kappa_xy = self.kernel_fn(x, y)
-        kappa_yy = self.kernel_fn(y, y)
-
-        return kappa_xx - 2 * kappa_xy + kappa_yy
-
-
 # Aliases
-sed = squared_euclidean_distance
+sed = squared_euclidean_distance

prototorch/functions/kernels.py

@@ -1,28 +0,0 @@
-"""
-Experimental Kernels
-"""
-
-import torch
-
-
-class ExplicitKernel:
-    def __init__(self, projection=torch.nn.Identity()):
-        self.projection = projection
-
-    def __call__(self, x, y):
-        return self.projection(x) @ self.projection(y).T
-
-
-class RadialBasisFunctionKernel:
-    def __init__(self, sigma) -> None:
-        self.s2 = sigma * sigma
-
-    def __call__(self, x, y):
-        remove_dim = False
-        if len(x.shape) > 1:
-            x = x.unsqueeze(1)
-            remove_dim = True
-        output = torch.exp(-torch.sum((x - y)**2, dim=-1) / (2 * self.s2))
-        if remove_dim:
-            output = output.squeeze(1)
-        return output

prototorch/modules/models.py

@@ -1,7 +1,8 @@
 import torch
 from torch import nn
 
-from prototorch.functions.distances import euclidean_distance_matrix, tangent_distance
+from prototorch.functions.distances import (euclidean_distance_matrix,
+                                            tangent_distance)
 from prototorch.functions.helper import _check_shapes, _int_and_mixed_shape
 from prototorch.functions.normalization import orthogonalization
 from prototorch.modules.prototypes import Prototypes1D

setup.py

@@ -23,6 +23,7 @@ INSTALL_REQUIRES = [
 ]
 DATASETS = [
     "requests",
+    "sklearn",
     "tqdm",
 ]
 DEV = ["bumpversion"]
@@ -42,7 +43,7 @@ ALL = DATASETS + DEV + DOCS + EXAMPLES + TESTS
 
 setup(
     name="prototorch",
-    version="0.4.2",
+    version="0.4.3",
     description="Highly extensible, GPU-supported "
     "Learning Vector Quantization (LVQ) toolbox "
     "built using PyTorch and its nn API.",

tests/test_functions.py

@@ -5,13 +5,8 @@ import unittest
 import numpy as np
 import torch
 
-from prototorch.functions import (
-    activations,
-    competitions,
-    distances,
-    initializers,
-    losses,
-)
+from prototorch.functions import (activations, competitions, distances,
+                                  initializers, losses)
 
 
 class TestActivations(unittest.TestCase):

tests/test_kernels.py

@@ -1,98 +0,0 @@
-"""ProtoTorch kernels test suite."""
-
-import unittest
-
-import numpy as np
-import torch
-
-from prototorch.functions.distances import KernelDistance
-from prototorch.functions.kernels import ExplicitKernel, RadialBasisFunctionKernel
-
-
-class TestExplicitKernel(unittest.TestCase):
-    def setUp(self):
-        self.single_x = torch.randn(1024)
-        self.single_y = torch.randn(1024)
-
-        self.batch_x = torch.randn(32, 1024)
-        self.batch_y = torch.randn(32, 1024)
-
-    def test_single_values(self):
-        kernel = ExplicitKernel()
-        self.assertEqual(
-            kernel(self.single_x, self.single_y).shape, torch.Size([]))
-
-    def test_single_batch(self):
-        kernel = ExplicitKernel()
-        self.assertEqual(
-            kernel(self.single_x, self.batch_y).shape, torch.Size([32]))
-
-    def test_batch_single(self):
-        kernel = ExplicitKernel()
-        self.assertEqual(
-            kernel(self.batch_x, self.single_y).shape, torch.Size([32]))
-
-    def test_batch_values(self):
-        kernel = ExplicitKernel()
-        self.assertEqual(
-            kernel(self.batch_x, self.batch_y).shape, torch.Size([32, 32]))
-
-
-class TestRadialBasisFunctionKernel(unittest.TestCase):
-    def setUp(self):
-        self.single_x = torch.randn(1024)
-        self.single_y = torch.randn(1024)
-
-        self.batch_x = torch.randn(32, 1024)
-        self.batch_y = torch.randn(32, 1024)
-
-    def test_single_values(self):
-        kernel = RadialBasisFunctionKernel(1)
-        self.assertEqual(
-            kernel(self.single_x, self.single_y).shape, torch.Size([]))
-
-    def test_single_batch(self):
-        kernel = RadialBasisFunctionKernel(1)
-        self.assertEqual(
-            kernel(self.single_x, self.batch_y).shape, torch.Size([32]))
-
-    def test_batch_single(self):
-        kernel = RadialBasisFunctionKernel(1)
-        self.assertEqual(
-            kernel(self.batch_x, self.single_y).shape, torch.Size([32]))
-
-    def test_batch_values(self):
-        kernel = RadialBasisFunctionKernel(1)
-        self.assertEqual(
-            kernel(self.batch_x, self.batch_y).shape, torch.Size([32, 32]))
-
-
-class TestKernelDistance(unittest.TestCase):
-    def setUp(self):
-        self.single_x = torch.randn(1024)
-        self.single_y = torch.randn(1024)
-
-        self.batch_x = torch.randn(32, 1024)
-        self.batch_y = torch.randn(32, 1024)
-
-        self.kernel = ExplicitKernel()
-
-    def test_single_values(self):
-        distance = KernelDistance(self.kernel)
-        self.assertEqual(
-            distance(self.single_x, self.single_y).shape, torch.Size([]))
-
-    def test_single_batch(self):
-        distance = KernelDistance(self.kernel)
-        self.assertEqual(
-            distance(self.single_x, self.batch_y).shape, torch.Size([32]))
-
-    def test_batch_single(self):
-        distance = KernelDistance(self.kernel)
-        self.assertEqual(
-            distance(self.batch_x, self.single_y).shape, torch.Size([32]))
-
-    def test_batch_values(self):
-        distance = KernelDistance(self.kernel)
-        self.assertEqual(
-            distance(self.batch_x, self.batch_y).shape, torch.Size([32, 32]))