Automatic Formatting.

docs/source/conf.py

@@ -12,9 +12,8 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath("../../"))
 
-import sphinx_rtd_theme
+sys.path.insert(0, os.path.abspath("../../"))
 
 # -- Project information -----------------------------------------------------
 
@@ -128,15 +127,12 @@ latex_elements = {
     # The paper size ("letterpaper" or "a4paper").
     #
     # "papersize": "letterpaper",
-
     # The font size ("10pt", "11pt" or "12pt").
     #
     # "pointsize": "10pt",
-
     # Additional stuff for the LaTeX preamble.
     #
     # "preamble": "",
-
     # Latex figure (float) alignment
     #
     # "figure_align": "htbp",
@@ -146,15 +142,21 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "prototorch.tex", "ProtoTorch Documentation",
+    (
-     "Jensun Ravichandran", "manual"),
+        master_doc,
+        "prototorch.tex",
+        "ProtoTorch Documentation",
+        "Jensun Ravichandran",
+        "manual",
+    ),
 ]
 
 # -- Options for manual page output ---------------------------------------
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "ProtoTorch", "ProtoTorch Documentation", [author], 1)]
+man_pages = [(master_doc, "ProtoTorch", "ProtoTorch Documentation", [author],
+              1)]
 
 # -- Options for Texinfo output -------------------------------------------
 
@@ -162,9 +164,15 @@ man_pages = [(master_doc, "ProtoTorch", "ProtoTorch Documentation", [author], 1)
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, "prototorch", "ProtoTorch Documentation", author, "prototorch",
+    (
+        master_doc,
+        "prototorch",
+        "ProtoTorch Documentation",
+        author,
+        "prototorch",
         "Prototype-based machine learning in PyTorch.",
-     "Miscellaneous"),
+        "Miscellaneous",
+    ),
 ]
 
 # Example configuration for intersphinx: refer to the Python standard library.

examples/glvq_iris.py

@@ -3,13 +3,14 @@
 import numpy as np
 import torch
 from matplotlib import pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.preprocessing import StandardScaler
+from torchinfo import summary
+
 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
 
 # Prepare and preprocess the data
 scaler = StandardScaler()
@@ -29,7 +30,8 @@ class Model(torch.nn.Module):
             prototypes_per_class=3,
             nclasses=3,
             prototype_initializer="stratified_random",
-            data=[x_train, y_train])
+            data=[x_train, y_train],
+        )
 
     def forward(self, x):
         protos = self.proto_layer.prototypes
@@ -61,8 +63,10 @@ for epoch in range(70):
     with torch.no_grad():
         pred = wtac(dis, plabels)
         correct = pred.eq(y_in.view_as(pred)).sum().item()
-    acc = 100. * correct / len(x_train)
+    acc = 100.0 * correct / len(x_train)
-    print(f"Epoch: {epoch + 1:03d} Loss: {loss.item():05.02f} Acc: {acc:05.02f}%")
+    print(
+        f"Epoch: {epoch + 1:03d} Loss: {loss.item():05.02f} Acc: {acc:05.02f}%"
+    )
 
     # Take a gradient descent step
     optimizer.zero_grad()
@@ -83,13 +87,15 @@ for epoch in range(70):
     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],
+    ax.scatter(
+        protos[:, 0],
         protos[:, 1],
         c=plabels,
         cmap=cmap,
         edgecolor="k",
         marker="D",
-               s=50)
+        s=50,
+    )
 
     # Paint decision regions
     x = np.vstack((x_train, protos))

examples/gmlvq_tecator.py

@@ -20,11 +20,13 @@ class Model(torch.nn.Module):
         """GMLVQ model as a siamese network."""
         super().__init__()
         x, y = train_data.data, train_data.targets
-        self.p1 = Prototypes1D(input_dim=100,
+        self.p1 = Prototypes1D(
+            input_dim=100,
             prototypes_per_class=2,
             nclasses=2,
             prototype_initializer="stratified_random",
-                               data=[x, y])
+            data=[x, y],
+        )
         self.omega = torch.nn.Linear(in_features=100,
                                      out_features=100,
                                      bias=False)

examples/gtlvq_mnist.py

@@ -13,8 +13,9 @@ import torch
 import torch.nn as nn
 import torchvision
 from torchvision import transforms
-from prototorch.modules.losses import GLVQLoss
+
 from prototorch.functions.helper import calculate_prototype_accuracy
+from prototorch.modules.losses import GLVQLoss
 from prototorch.modules.models import GTLVQ
 
 # Parameters and options
@@ -26,32 +27,40 @@ momentum = 0.5
 log_interval = 10
 cuda = "cuda:1"
 random_seed = 1
-device = torch.device(cuda if torch.cuda.is_available() else 'cpu')
+device = torch.device(cuda if torch.cuda.is_available() else "cpu")
 
 # Configures reproducability
 torch.manual_seed(random_seed)
 np.random.seed(random_seed)
 
 # Prepare and preprocess the data
-train_loader = torch.utils.data.DataLoader(torchvision.datasets.MNIST(
+train_loader = torch.utils.data.DataLoader(
-    './files/',
+    torchvision.datasets.MNIST(
+        "./files/",
         train=True,
         download=True,
-    transform=torchvision.transforms.Compose(
+        transform=torchvision.transforms.Compose([
-        [transforms.ToTensor(),
+            transforms.ToTensor(),
-         transforms.Normalize((0.1307, ), (0.3081, ))])),
+            transforms.Normalize((0.1307, ), (0.3081, ))
+        ]),
+    ),
     batch_size=batch_size_train,
-                                           shuffle=True)
+    shuffle=True,
+)
 
-test_loader = torch.utils.data.DataLoader(torchvision.datasets.MNIST(
+test_loader = torch.utils.data.DataLoader(
-    './files/',
+    torchvision.datasets.MNIST(
+        "./files/",
         train=False,
         download=True,
-    transform=torchvision.transforms.Compose(
+        transform=torchvision.transforms.Compose([
-        [transforms.ToTensor(),
+            transforms.ToTensor(),
-         transforms.Normalize((0.1307, ), (0.3081, ))])),
+            transforms.Normalize((0.1307, ), (0.3081, ))
+        ]),
+    ),
     batch_size=batch_size_test,
-                                          shuffle=True)
+    shuffle=True,
+)
 
 
 # Define the GLVQ model plus appropriate feature extractor
@@ -68,24 +77,33 @@ class CNNGTLVQ(torch.nn.Module):
         super(CNNGTLVQ, self).__init__()
 
         # Feature Extractor - Simple CNN
-        self.fe = nn.Sequential(nn.Conv2d(1, 32, 3, 1), nn.ReLU(),
+        self.fe = nn.Sequential(
-                                nn.Conv2d(32, 64, 3, 1), nn.ReLU(),
+            nn.Conv2d(1, 32, 3, 1),
-                                nn.MaxPool2d(2), nn.Dropout(0.25),
+            nn.ReLU(),
-                                nn.Flatten(), nn.Linear(9216, bottleneck_dim),
+            nn.Conv2d(32, 64, 3, 1),
-                                nn.Dropout(0.5), nn.LeakyReLU(),
+            nn.ReLU(),
-                                nn.LayerNorm(bottleneck_dim))
+            nn.MaxPool2d(2),
+            nn.Dropout(0.25),
+            nn.Flatten(),
+            nn.Linear(9216, bottleneck_dim),
+            nn.Dropout(0.5),
+            nn.LeakyReLU(),
+            nn.LayerNorm(bottleneck_dim),
+        )
 
         # Forward pass of subspace and prototype initialization data through feature extractor
         subspace_data = self.fe(subspace_data)
         prototype_data[0] = self.fe(prototype_data[0])
 
         # Initialization of GTLVQ
-        self.gtlvq = GTLVQ(num_classes,
+        self.gtlvq = GTLVQ(
+            num_classes,
             subspace_data,
             prototype_data,
             tangent_projection_type=tangent_projection_type,
             feature_dim=bottleneck_dim,
-                           prototypes_per_class=prototypes_per_class)
+            prototypes_per_class=prototypes_per_class,
+        )
 
     def forward(self, x):
         # Feature Extraction
@@ -103,20 +121,24 @@ subspace_data = torch.cat(
 prototype_data = next(iter(train_loader))
 
 # Build the CNN GTLVQ  model
-model = CNNGTLVQ(10,
+model = CNNGTLVQ(
+    10,
     subspace_data,
     prototype_data,
     tangent_projection_type="local",
-                 bottleneck_dim=128).to(device)
+    bottleneck_dim=128,
+).to(device)
 
 # Optimize using SGD optimizer from `torch.optim`
-optimizer = torch.optim.Adam([{
+optimizer = torch.optim.Adam(
-    'params': model.fe.parameters()
+    [{
+        "params": model.fe.parameters()
     }, {
-    'params': model.gtlvq.parameters()
+        "params": model.gtlvq.parameters()
     }],
-                             lr=learning_rate)
+    lr=learning_rate,
-criterion = GLVQLoss(squashing='sigmoid_beta', beta=10)
+)
+criterion = GLVQLoss(squashing="sigmoid_beta", beta=10)
 
 # Training loop
 for epoch in range(n_epochs):
@@ -139,8 +161,8 @@ for epoch in range(n_epochs):
         if batch_idx % log_interval == 0:
             acc = calculate_prototype_accuracy(distances, y_train, plabels)
             print(
-                f'Epoch: {epoch + 1:02d}/{n_epochs:02d} Epoch Progress: {100. * batch_idx / len(train_loader):02.02f} % Loss: {loss.item():02.02f} \
+                f"Epoch: {epoch + 1:02d}/{n_epochs:02d} Epoch Progress: {100. * batch_idx / len(train_loader):02.02f} % Loss: {loss.item():02.02f} \
-              Train Acc: {acc.item():02.02f}')
+              Train Acc: {acc.item():02.02f}")
 
     # Test
     with torch.no_grad():
@@ -154,9 +176,9 @@ for epoch in range(n_epochs):
             i = torch.argmin(test_distances, 1)
             correct += torch.sum(y_test == test_plabels[i])
             total += y_test.size(0)
-        print('Accuracy of the network on the test images: %d %%' %
+        print("Accuracy of the network on the test images: %d %%" %
               (torch.true_divide(correct, total) * 100))
 
 # Save the model
-PATH = './glvq_mnist_model.pth'
+PATH = "./glvq_mnist_model.pth"
 torch.save(model.state_dict(), PATH)

examples/lgmlvq_iris.py

@@ -22,10 +22,12 @@ class Model(torch.nn.Module):
     def __init__(self):
         """Local-GMLVQ model."""
         super().__init__()
-        self.p1 = Prototypes1D(input_dim=2,
+        self.p1 = Prototypes1D(
+            input_dim=2,
             prototype_distribution=[1, 2, 2],
             prototype_initializer="stratified_random",
-                               data=[x_train, y_train])
+            data=[x_train, y_train],
+        )
         omegas = torch.zeros(5, 2, 2)
         self.omegas = torch.nn.Parameter(omegas)
         eye_(self.omegas)
@@ -76,14 +78,16 @@ for epoch in range(100):
     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(x_train[:, 0], x_train[:, 1], c=y_train, edgecolor="k")
-    ax.scatter(protos[:, 0],
+    ax.scatter(
+        protos[:, 0],
         protos[:, 1],
         c=plabels,
         cmap=cmap,
-               edgecolor='k',
+        edgecolor="k",
-               marker='D',
+        marker="D",
-               s=50)
+        s=50,
+    )
 
     # Paint decision regions
     x = np.vstack((x_train, protos))

prototorch/__init__.py

@@ -5,8 +5,6 @@
 # #############################################
 __version__ = "0.3.0-dev0"
 
-from prototorch import datasets, functions, modules
-
 __all_core__ = [
     "datasets",
     "functions",
@@ -17,6 +15,7 @@ __all_core__ = [
 # Plugin Loader
 # #############################################
 import pkgutil
+
 import pkg_resources
 
 __path__ = pkgutil.extend_path(__path__, __name__)
@@ -25,7 +24,8 @@ __path__ = pkgutil.extend_path(__path__, __name__)
 def discover_plugins():
     return {
         entry_point.name: entry_point.load()
-        for entry_point in pkg_resources.iter_entry_points("prototorch.plugins")
+        for entry_point in pkg_resources.iter_entry_points(
+            "prototorch.plugins")
     }
 
 
@@ -33,12 +33,10 @@ discovered_plugins = discover_plugins()
 locals().update(discovered_plugins)
 
 # Generate combines __version__ and __all__
-version_plugins = "\n".join(
+version_plugins = "\n".join([
-    [
     "- " + name + ": v" + plugin.__version__
     for name, plugin in discovered_plugins.items()
-    ]
+])
-)
 if version_plugins != "":
     version_plugins = "\nPlugins: \n" + version_plugins
 

prototorch/datasets/__init__.py

@@ -3,5 +3,5 @@
 from .tecator import Tecator
 
 __all__ = [
-    'Tecator',
+    "Tecator",
 ]

prototorch/datasets/tecator.py

@@ -52,7 +52,8 @@ class Tecator(ProtoDataset):
     """
 
     _resources = [
-        ("1MMuUK8V41IgNpnPDbg3E-QAL6wlErTk0", "ba5607c580d0f91bb27dc29d13c2f8df"),
+        ("1MMuUK8V41IgNpnPDbg3E-QAL6wlErTk0",
+         "ba5607c580d0f91bb27dc29d13c2f8df"),
     ]  # (google_storage_id, md5hash)
     classes = ["0 - low_fat", "1 - high_fat"]
 
@@ -74,15 +75,15 @@ class Tecator(ProtoDataset):
             print("Downloading...")
         for fileid, md5 in self._resources:
             filename = "tecator.npz"
-            download_file_from_google_drive(
+            download_file_from_google_drive(fileid,
-                fileid, root=self.raw_folder, filename=filename, md5=md5
+                                            root=self.raw_folder,
-            )
+                                            filename=filename,
+                                            md5=md5)
 
         if self.verbose:
             print("Processing...")
-        with np.load(
+        with np.load(os.path.join(self.raw_folder, "tecator.npz"),
-            os.path.join(self.raw_folder, "tecator.npz"), allow_pickle=False
+                     allow_pickle=False) as f:
-        ) as f:
             x_train, y_train = f["x_train"], f["y_train"]
             x_test, y_test = f["x_test"], f["y_test"]
         training_set = [
@@ -94,9 +95,11 @@ class Tecator(ProtoDataset):
             torch.tensor(y_test),
         ]
 
-        with open(os.path.join(self.processed_folder, self.training_file), "wb") as f:
+        with open(os.path.join(self.processed_folder, self.training_file),
+                  "wb") as f:
             torch.save(training_set, f)
-        with open(os.path.join(self.processed_folder, self.test_file), "wb") as f:
+        with open(os.path.join(self.processed_folder, self.test_file),
+                  "wb") as f:
             torch.save(test_set, f)
 
         if self.verbose:

prototorch/functions/__init__.py

@@ -4,9 +4,9 @@ from .activations import identity, sigmoid_beta, swish_beta
 from .competitions import knnc, wtac
 
 __all__ = [
-    'identity',
+    "identity",
-    'sigmoid_beta',
+    "sigmoid_beta",
-    'swish_beta',
+    "swish_beta",
-    'knnc',
+    "knnc",
-    'wtac',
+    "wtac",
 ]

prototorch/functions/activations.py

@@ -61,4 +61,4 @@ def get_activation(funcname):
         return funcname
     if funcname in ACTIVATIONS:
         return ACTIVATIONS.get(funcname)
-    raise NameError(f'Activation {funcname} was not found.')
+    raise NameError(f"Activation {funcname} was not found.")

prototorch/functions/competitions.py

@@ -12,7 +12,7 @@ def stratified_min(distances, labels):
         return distances
     batch_size = distances.size()[0]
     winning_distances = torch.zeros(nclasses, batch_size)
-    inf = torch.full_like(distances.T, fill_value=float('inf'))
+    inf = torch.full_like(distances.T, fill_value=float("inf"))
     # distances_to_wpluses = torch.where(matcher, distances, inf)
     for i, cl in enumerate(clabels):
         # cdists = distances.T[labels == cl]

prototorch/functions/distances.py

@@ -1,12 +1,10 @@
 """ProtoTorch distance functions."""
 
-import torch
-from prototorch.functions.helper import (
-    equal_int_shape,
-    _int_and_mixed_shape,
-    _check_shapes,
-)
 import numpy as np
+import torch
+
+from prototorch.functions.helper import (_check_shapes, _int_and_mixed_shape,
+                                         equal_int_shape)
 
 
 def squared_euclidean_distance(x, y):

prototorch/functions/helper.py

@@ -23,7 +23,7 @@ def predict_label(y_pred, plabels):
 
 def mixed_shape(inputs):
     if not torch.is_tensor(inputs):
-        raise ValueError('Input must be a tensor.')
+        raise ValueError("Input must be a tensor.")
     else:
         int_shape = list(inputs.shape)
         # sometimes int_shape returns mixed integer types
@@ -39,11 +39,11 @@ def mixed_shape(inputs):
 def equal_int_shape(shape_1, shape_2):
     if not isinstance(shape_1,
                       (tuple, list)) or not isinstance(shape_2, (tuple, list)):
-        raise ValueError('Input shapes must list or tuple.')
+        raise ValueError("Input shapes must list or tuple.")
     for shape in [shape_1, shape_2]:
         if not all([isinstance(x, int) or x is None for x in shape]):
             raise ValueError(
-                'Input shapes must be list or tuple of int and None values.')
+                "Input shapes must be list or tuple of int and None values.")
 
     if len(shape_1) != len(shape_2):
         return False

prototorch/functions/initializers.py

@@ -104,4 +104,4 @@ def get_initializer(funcname):
         return funcname
     if funcname in INITIALIZERS:
         return INITIALIZERS.get(funcname)
-    raise NameError(f'Initializer {funcname} was not found.')
+    raise NameError(f"Initializer {funcname} was not found.")

prototorch/functions/losses.py

@@ -11,7 +11,7 @@ def _get_dp_dm(distances, targets, plabels):
         matcher = torch.eq(torch.sum(matcher, dim=-1), nclasses)
     not_matcher = torch.bitwise_not(matcher)
 
-    inf = torch.full_like(distances, fill_value=float('inf'))
+    inf = torch.full_like(distances, fill_value=float("inf"))
     d_matching = torch.where(matcher, distances, inf)
     d_unmatching = torch.where(not_matcher, distances, inf)
     dp = torch.min(d_matching, dim=1, keepdim=True).values

prototorch/functions/normalization.py

@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
-from __future__ import print_function
+from __future__ import absolute_import, division, print_function
-from __future__ import absolute_import
-from __future__ import division
 
 import torch
 

prototorch/modules/__init__.py

@@ -3,5 +3,5 @@
 from .prototypes import Prototypes1D
 
 __all__ = [
-    'Prototypes1D',
+    "Prototypes1D",
 ]

prototorch/modules/losses.py

@@ -7,7 +7,7 @@ from prototorch.functions.losses import glvq_loss
 
 
 class GLVQLoss(torch.nn.Module):
-    def __init__(self, margin=0.0, squashing='identity', beta=10, **kwargs):
+    def __init__(self, margin=0.0, squashing="identity", beta=10, **kwargs):
         super().__init__(**kwargs)
         self.margin = margin
         self.squashing = get_activation(squashing)

prototorch/modules/models.py

@@ -1,9 +1,11 @@
-from torch import nn
 import torch
-from prototorch.modules.prototypes import Prototypes1D
+from torch import nn
-from prototorch.functions.distances import tangent_distance, euclidean_distance_matrix
+
-from prototorch.functions.normalization import orthogonalization
+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
 
 
 class GTLVQ(nn.Module):
@@ -71,7 +73,7 @@ class GTLVQ(nn.Module):
         subspace_data=None,
         prototype_data=None,
         subspace_size=256,
-        tangent_projection_type='local',
+        tangent_projection_type="local",
         prototypes_per_class=2,
         feature_dim=256,
     ):
@@ -82,37 +84,39 @@ class GTLVQ(nn.Module):
         self.feature_dim = feature_dim
 
         if subspace_data is None:
-            raise ValueError('Init Data must be specified!')
+            raise ValueError("Init Data must be specified!")
 
         self.tpt = tangent_projection_type
         with torch.no_grad():
-            if self.tpt == 'local' or self.tpt == 'local_proj':
+            if self.tpt == "local" or self.tpt == "local_proj":
                 self.init_local_subspace(subspace_data)
-            elif self.tpt == 'global':
+            elif self.tpt == "global":
                 self.init_gobal_subspace(subspace_data, subspace_size)
             else:
                 self.subspaces = None
 
         # Hypothesis-Margin-Classifier
-        self.cls = Prototypes1D(input_dim=feature_dim,
+        self.cls = Prototypes1D(
+            input_dim=feature_dim,
             prototypes_per_class=prototypes_per_class,
             nclasses=num_classes,
-                                prototype_initializer='stratified_mean',
+            prototype_initializer="stratified_mean",
-                                data=prototype_data)
+            data=prototype_data,
+        )
 
     def forward(self, x):
         # Tangent Projection
-        if self.tpt == 'local_proj':
+        if self.tpt == "local_proj":
-            x_conform = x.unsqueeze(1).repeat_interleave(self.num_protos,
+            x_conform = (x.unsqueeze(1).repeat_interleave(self.num_protos,
-                                                         1).unsqueeze(2)
+                                                          1).unsqueeze(2))
             dis, proj_x = self.local_tangent_projection(x_conform)
 
             proj_x = proj_x.reshape(x.shape[0] * self.num_protos,
                                     self.feature_dim)
             return proj_x, dis
         elif self.tpt == "local":
-            x_conform = x.unsqueeze(1).repeat_interleave(self.num_protos,
+            x_conform = (x.unsqueeze(1).repeat_interleave(self.num_protos,
-                                                         1).unsqueeze(2)
+                                                          1).unsqueeze(2))
             dis = tangent_distance(x_conform, self.cls.prototypes,
                                    self.subspaces)
         elif self.tpt == "gloabl":
@@ -127,25 +131,27 @@ class GTLVQ(nn.Module):
         _, _, v = torch.svd(data)
         subspace = (torch.eye(v.shape[0]) - (v @ v.T)).T
         subspaces = subspace[:, :num_subspaces]
-        self.subspaces = torch.nn.Parameter(
+        self.subspaces = (torch.nn.Parameter(
-            subspaces).clone().detach().requires_grad_(True)
+            subspaces).clone().detach().requires_grad_(True))
 
     def init_local_subspace(self, data):
         _, _, v = torch.svd(data)
         inital_projector = (torch.eye(v.shape[0]) - (v @ v.T)).T
         subspaces = inital_projector.unsqueeze(0).repeat_interleave(
             self.num_protos, 0)
-        self.subspaces = torch.nn.Parameter(
+        self.subspaces = (torch.nn.Parameter(
-            subspaces).clone().detach().requires_grad_(True)
+            subspaces).clone().detach().requires_grad_(True))
 
     def global_tangent_distances(self, x):
         # Tangent Projection
-        x, projected_prototypes = x @ self.subspaces, self.cls.prototypes @ self.subspaces
+        x, projected_prototypes = (
+            x @ self.subspaces,
+            self.cls.prototypes @ self.subspaces,
+        )
         # Euclidean Distance
         return euclidean_distance_matrix(x, projected_prototypes)
 
-    def local_tangent_projection(self,
+    def local_tangent_projection(self, signals):
-                                 signals):
         # Note: subspaces is always assumed as transposed and must be orthogonal!
         # shape(signals): batch x proto_number x channels x dim1 x dim2 x ... x dimN
         # shape(protos): proto_number x dim1 x dim2 x ... x dimN
@@ -183,8 +189,7 @@ class GTLVQ(nn.Module):
     def orthogonalize_subspace(self):
         if self.subspaces is not None:
             with torch.no_grad():
-                ortho_subpsaces = orthogonalization(
+                ortho_subpsaces = (orthogonalization(self.subspaces)
-                    self.subspaces
+                                   if self.tpt == "global" else
-                ) if self.tpt == 'global' else torch.nn.init.orthogonal_(
+                                   torch.nn.init.orthogonal_(self.subspaces))
-                    self.subspaces)
                 self.subspaces.copy_(ortho_subpsaces)

prototorch/modules/prototypes.py

@@ -29,14 +29,16 @@ class Prototypes1D(_Prototypes):
 
     TODO Complete this doc-string.
     """
-    def __init__(self,
+    def __init__(
+        self,
         prototypes_per_class=1,
         prototype_initializer="ones",
         prototype_distribution=None,
         data=None,
         dtype=torch.float32,
         one_hot_labels=False,
-                 **kwargs):
+        **kwargs,
+    ):
 
         # Convert tensors to python lists before processing
         if prototype_distribution is not None:

prototorch/utils/__init__.py

@@ -1 +0,0 @@
-from .colors import color_scheme, get_legend_handles

prototorch/utils/celluloid.py

@@ -1,13 +1,13 @@
 """Easy matplotlib animation. From https://github.com/jwkvam/celluloid."""
 
-from typing import Dict, List
 from collections import defaultdict
+from typing import Dict, List
 
-from matplotlib.figure import Figure
-from matplotlib.artist import Artist
 from matplotlib.animation import ArtistAnimation
+from matplotlib.artist import Artist
+from matplotlib.figure import Figure
 
-__version__ = '0.2.0'
+__version__ = "0.2.0"
 
 
 class Camera:
@@ -19,7 +19,7 @@ class Camera:
         self._offsets: Dict[str, Dict[int, int]] = {
             k: defaultdict(int)
             for k in
-            ['collections', 'patches', 'lines', 'texts', 'artists', 'images']
+            ["collections", "patches", "lines", "texts", "artists", "images"]
         }
         self._photos: List[List[Artist]] = []
 

prototorch/utils/colors.py

@@ -1,13 +1,14 @@
 """ProtoFlow color utilities."""
 
-from matplotlib import cm
-from matplotlib.colors import Normalize
-from matplotlib.colors import to_hex
-from matplotlib.colors import to_rgb
 import matplotlib.lines as mlines
+from matplotlib import cm
+from matplotlib.colors import Normalize, to_hex, to_rgb
 
 
-def color_scheme(n, cmap="viridis", form="hex", tikz=False,
+def color_scheme(n,
+                 cmap="viridis",
+                 form="hex",
+                 tikz=False,
                  zero_indexed=False):
     """Return *n* colors from the color scheme.
 
@@ -57,13 +58,16 @@ def get_legend_handles(labels, marker="dots", zero_indexed=False):
                           zero_indexed=zero_indexed)
     for label, color in zip(labels, colors.values()):
         if marker == "dots":
-            handle = mlines.Line2D([], [],
+            handle = mlines.Line2D(
+                [],
+                [],
                 color="white",
                 markerfacecolor=color,
                 marker="o",
                 markersize=10,
                 markeredgecolor="k",
-                                   label=label)
+                label=label,
+            )
         else:
             handle = mlines.Line2D([], [],
                                    color=color,

prototorch/utils/utils.py

@@ -11,17 +11,17 @@ import numpy as np
 
 def progressbar(title, value, end, bar_width=20):
     percent = float(value) / end
-    arrow = '=' * int(round(percent * bar_width) - 1) + '>'
+    arrow = "=" * int(round(percent * bar_width) - 1) + ">"
-    spaces = '.' * (bar_width - len(arrow))
+    spaces = "." * (bar_width - len(arrow))
-    sys.stdout.write('\r{}: [{}] {}%'.format(title, arrow + spaces,
+    sys.stdout.write("\r{}: [{}] {}%".format(title, arrow + spaces,
                                              int(round(percent * 100))))
     sys.stdout.flush()
     if percent == 1.0:
         print()
 
 
-def prettify_string(inputs, start='', sep=' ', end='\n'):
+def prettify_string(inputs, start="", sep=" ", end="\n"):
-    outputs = start + ' '.join(inputs.split()) + end
+    outputs = start + " ".join(inputs.split()) + end
     return outputs
 
 
@@ -29,22 +29,22 @@ def pretty_print(inputs):
     print(prettify_string(inputs))
 
 
-def writelog(self, *logs, logdir='./logs', logfile='run.txt'):
+def writelog(self, *logs, logdir="./logs", logfile="run.txt"):
     f = os.path.join(logdir, logfile)
-    with open(f, 'a+') as fh:
+    with open(f, "a+") as fh:
         for log in logs:
             fh.write(log)
-            fh.write('\n')
+            fh.write("\n")
 
 
-def start_tensorboard(self, logdir='./logs'):
+def start_tensorboard(self, logdir="./logs"):
-    cmd = f'tensorboard --logdir={logdir} --port=6006'
+    cmd = f"tensorboard --logdir={logdir} --port=6006"
     os.system(cmd)
 
 
 def make_directory(save_dir):
     if not os.path.exists(save_dir):
-        print(f'Making directory {save_dir}.')
+        print(f"Making directory {save_dir}.")
         os.mkdir(save_dir)
 
 
@@ -52,36 +52,36 @@ def make_gif(filenames, duration, output_file=None):
     try:
         import imageio
     except ModuleNotFoundError as e:
-        print('Please install Protoflow with [other] extra requirements.')
+        print("Please install Protoflow with [other] extra requirements.")
         raise (e)
 
     images = list()
     for filename in filenames:
         images.append(imageio.imread(filename))
     if not output_file:
-        output_file = f'makegif.gif'
+        output_file = f"makegif.gif"
     if images:
         imageio.mimwrite(output_file, images, duration=duration)
 
 
 def gif_from_dir(directory,
                  duration,
-                 prefix='',
+                 prefix="",
                  output_file=None,
                  verbose=True):
     images = os.listdir(directory)
     if verbose:
-        print(f'Making gif from {len(images)} images under {directory}.')
+        print(f"Making gif from {len(images)} images under {directory}.")
     filenames = list()
     # Sort images
     images = sorted(
         images,
-        key=lambda img: int(os.path.splitext(img)[0].replace(prefix, '')))
+        key=lambda img: int(os.path.splitext(img)[0].replace(prefix, "")))
     for image in images:
         fname = os.path.join(directory, image)
         filenames.append(fname)
     if not output_file:
-        output_file = os.path.join(directory, 'makegif.gif')
+        output_file = os.path.join(directory, "makegif.gif")
     make_gif(filenames=filenames, duration=duration, output_file=output_file)
 
 
@@ -95,12 +95,12 @@ def predict_and_score(clf,
                       x_test,
                       y_test,
                       verbose=False,
-                      title='Test accuracy'):
+                      title="Test accuracy"):
     y_pred = clf.predict(x_test)
     accuracy = np.sum(y_test == y_pred)
     normalized_acc = accuracy / float(len(y_test))
     if verbose:
-        print(f'{title}: {normalized_acc * 100:06.04f}%')
+        print(f"{title}: {normalized_acc * 100:06.04f}%")
     return normalized_acc
 
 
@@ -124,6 +124,7 @@ def replace_in(arr, replacement_dict, inplace=False):
         new_arr = arr
     else:
         import copy
+
         new_arr = copy.deepcopy(arr)
     for k, v in replacement_dict.items():
         new_arr[arr == k] = v
@@ -135,7 +136,7 @@ def train_test_split(data, train=0.7, val=0.15, shuffle=None, return_xy=False):
     preserve the class distribution in subsamples of the dataset.
     """
     if train + val > 1.0:
-        raise ValueError('Invalid split values for train and val.')
+        raise ValueError("Invalid split values for train and val.")
     Y = data[:, -1]
     labels = set(Y)
     hist = dict()
@@ -183,20 +184,20 @@ def train_test_split(data, train=0.7, val=0.15, shuffle=None, return_xy=False):
     return train_data, val_data, test_data
 
 
-def class_histogram(data, title='Untitled'):
+def class_histogram(data, title="Untitled"):
     plt.figure(title)
     plt.clf()
     plt.title(title)
     dist, counts = np.unique(data[:, -1], return_counts=True)
     plt.bar(dist, counts)
     plt.xticks(dist)
-    print('Call matplotlib.pyplot.show() to see the plot.')
+    print("Call matplotlib.pyplot.show() to see the plot.")
 
 
 def ntimer(n=10):
     """Wraps a function which wraps another function to time it."""
     if n < 1:
-        raise (Exception(f'Invalid n = {n} given.'))
+        raise (Exception(f"Invalid n = {n} given."))
 
     def timer(func):
         """Wraps `func` with a timer and returns the wrapped `func`."""
@@ -207,7 +208,7 @@ def ntimer(n=10):
                 rv = func(*args, **kwargs)
             after = time()
             elapsed = after - before
-            print(f'Elapsed: {elapsed*1e3:02.02f} ms')
+            print(f"Elapsed: {elapsed*1e3:02.02f} ms")
             return rv
 
         return wrapper
@@ -228,13 +229,13 @@ def memoize(verbose=True):
             t = (pickle.dumps(args), pickle.dumps(kwargs))
             if t not in cache:
                 if verbose:
-                    print(f'Adding NEW rv {func.__name__}{args}{kwargs} '
+                    print(f"Adding NEW rv {func.__name__}{args}{kwargs} "
-                          'to cache.')
+                          "to cache.")
                 cache[t] = func(*args, **kwargs)
             else:
                 if verbose:
-                    print(f'Using OLD rv {func.__name__}{args}{kwargs} '
+                    print(f"Using OLD rv {func.__name__}{args}{kwargs} "
-                          'from cache.')
+                          "from cache.")
             return cache[t]
 
         return wrapper

setup.py

@@ -8,8 +8,7 @@
 
 ProtoTorch Core Package
 """
-from setuptools import setup
+from setuptools import find_packages, setup
-from setuptools import find_packages
 
 PROJECT_URL = "https://github.com/si-cim/prototorch"
 DOWNLOAD_URL = "https://github.com/si-cim/prototorch.git"

tests/test_datasets.py

@@ -12,26 +12,26 @@ from prototorch.datasets import abstract, tecator
 class TestAbstract(unittest.TestCase):
     def test_getitem(self):
         with self.assertRaises(NotImplementedError):
-            abstract.Dataset('./artifacts')[0]
+            abstract.Dataset("./artifacts")[0]
 
     def test_len(self):
         with self.assertRaises(NotImplementedError):
-            len(abstract.Dataset('./artifacts'))
+            len(abstract.Dataset("./artifacts"))
 
 
 class TestProtoDataset(unittest.TestCase):
     def test_getitem(self):
         with self.assertRaises(NotImplementedError):
-            abstract.ProtoDataset('./artifacts')[0]
+            abstract.ProtoDataset("./artifacts")[0]
 
     def test_download(self):
         with self.assertRaises(NotImplementedError):
-            abstract.ProtoDataset('./artifacts').download()
+            abstract.ProtoDataset("./artifacts").download()
 
 
 class TestTecator(unittest.TestCase):
     def setUp(self):
-        self.artifacts_dir = './artifacts/Tecator'
+        self.artifacts_dir = "./artifacts/Tecator"
         self._remove_artifacts()
 
     def _remove_artifacts(self):
@@ -39,23 +39,23 @@ class TestTecator(unittest.TestCase):
             shutil.rmtree(self.artifacts_dir)
 
     def test_download_false(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         self._remove_artifacts()
         with self.assertRaises(RuntimeError):
             _ = tecator.Tecator(rootdir, download=False)
 
     def test_download_caching(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         _ = tecator.Tecator(rootdir, download=True, verbose=False)
         _ = tecator.Tecator(rootdir, download=False, verbose=False)
 
     def test_repr(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         train = tecator.Tecator(rootdir, download=True, verbose=True)
-        self.assertTrue('Split: Train' in train.__repr__())
+        self.assertTrue("Split: Train" in train.__repr__())
 
     def test_download_train(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         train = tecator.Tecator(root=rootdir,
                                 train=True,
                                 download=True,
@@ -67,7 +67,7 @@ class TestTecator(unittest.TestCase):
         self.assertEqual(x_train.shape[1], 100)
 
     def test_download_test(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         test = tecator.Tecator(root=rootdir, train=False, verbose=False)
         x_test, y_test = test.data, test.targets
         self.assertEqual(x_test.shape[0], 71)
@@ -75,19 +75,19 @@ class TestTecator(unittest.TestCase):
         self.assertEqual(x_test.shape[1], 100)
 
     def test_class_to_idx(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         test = tecator.Tecator(root=rootdir, train=False, verbose=False)
         _ = test.class_to_idx
 
     def test_getitem(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         test = tecator.Tecator(root=rootdir, train=False, verbose=False)
         x, y = test[0]
         self.assertEqual(x.shape[0], 100)
         self.assertIsInstance(y, int)
 
     def test_loadable_with_dataloader(self):
-        rootdir = self.artifacts_dir.rpartition('/')[0]
+        rootdir = self.artifacts_dir.rpartition("/")[0]
         test = tecator.Tecator(root=rootdir, train=False, verbose=False)
         _ = torch.utils.data.DataLoader(test, batch_size=64, shuffle=True)
 

tests/test_functions.py

@@ -11,7 +11,7 @@ from prototorch.functions import (activations, competitions, distances,
 
 class TestActivations(unittest.TestCase):
     def setUp(self):
-        self.flist = ['identity', 'sigmoid_beta', 'swish_beta']
+        self.flist = ["identity", "sigmoid_beta", "swish_beta"]
         self.x = torch.randn(1024, 1)
 
     def test_registry(self):
@@ -39,7 +39,7 @@ class TestActivations(unittest.TestCase):
             self.assertEqual(1, f(1))
 
     def test_unknown_deserialization(self):
-        for funcname in ['blubb', 'foobar']:
+        for funcname in ["blubb", "foobar"]:
             with self.assertRaises(NameError):
                 _ = activations.get_activation(funcname)
 
@@ -76,7 +76,7 @@ class TestCompetitions(unittest.TestCase):
         pass
 
     def test_wtac(self):
-        d = torch.tensor([[2., 3., 1.99, 3.01], [2., 3., 2.01, 3.]])
+        d = torch.tensor([[2.0, 3.0, 1.99, 3.01], [2.0, 3.0, 2.01, 3.0]])
         labels = torch.tensor([0, 1, 2, 3])
         actual = competitions.wtac(d, labels)
         desired = torch.tensor([2, 0])
@@ -86,7 +86,7 @@ class TestCompetitions(unittest.TestCase):
         self.assertIsNone(mismatch)
 
     def test_wtac_unequal_dist(self):
-        d = torch.tensor([[2., 3., 4.], [2., 3., 1.]])
+        d = torch.tensor([[2.0, 3.0, 4.0], [2.0, 3.0, 1.0]])
         labels = torch.tensor([0, 1, 1])
         actual = competitions.wtac(d, labels)
         desired = torch.tensor([0, 1])
@@ -96,7 +96,7 @@ class TestCompetitions(unittest.TestCase):
         self.assertIsNone(mismatch)
 
     def test_wtac_one_hot(self):
-        d = torch.tensor([[1.99, 3.01], [3., 2.01]])
+        d = torch.tensor([[1.99, 3.01], [3.0, 2.01]])
         labels = torch.tensor([[0, 1], [1, 0]])
         actual = competitions.wtac(d, labels)
         desired = torch.tensor([[0, 1], [1, 0]])
@@ -106,38 +106,38 @@ class TestCompetitions(unittest.TestCase):
         self.assertIsNone(mismatch)
 
     def test_stratified_min(self):
-        d = torch.tensor([[1., 0., 2., 3.], [9., 8., 0, 1]])
+        d = torch.tensor([[1.0, 0.0, 2.0, 3.0], [9.0, 8.0, 0, 1]])
         labels = torch.tensor([0, 0, 1, 2])
         actual = competitions.stratified_min(d, labels)
-        desired = torch.tensor([[0., 2., 3.], [8., 0., 1.]])
+        desired = torch.tensor([[0.0, 2.0, 3.0], [8.0, 0.0, 1.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
         self.assertIsNone(mismatch)
 
     def test_stratified_min_one_hot(self):
-        d = torch.tensor([[1., 0., 2., 3.], [9., 8., 0, 1]])
+        d = torch.tensor([[1.0, 0.0, 2.0, 3.0], [9.0, 8.0, 0, 1]])
         labels = torch.tensor([0, 0, 1, 2])
         labels = torch.eye(3)[labels]
         actual = competitions.stratified_min(d, labels)
-        desired = torch.tensor([[0., 2., 3.], [8., 0., 1.]])
+        desired = torch.tensor([[0.0, 2.0, 3.0], [8.0, 0.0, 1.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
         self.assertIsNone(mismatch)
 
     def test_stratified_min_simple(self):
-        d = torch.tensor([[0., 2., 3.], [8., 0, 1]])
+        d = torch.tensor([[0.0, 2.0, 3.0], [8.0, 0, 1]])
         labels = torch.tensor([0, 1, 2])
         actual = competitions.stratified_min(d, labels)
-        desired = torch.tensor([[0., 2., 3.], [8., 0., 1.]])
+        desired = torch.tensor([[0.0, 2.0, 3.0], [8.0, 0.0, 1.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
         self.assertIsNone(mismatch)
 
     def test_knnc_k1(self):
-        d = torch.tensor([[2., 3., 1.99, 3.01], [2., 3., 2.01, 3.]])
+        d = torch.tensor([[2.0, 3.0, 1.99, 3.01], [2.0, 3.0, 2.01, 3.0]])
         labels = torch.tensor([0, 1, 2, 3])
         actual = competitions.knnc(d, labels, k=torch.tensor([1]))
         desired = torch.tensor([2, 0])
@@ -194,12 +194,12 @@ class TestDistances(unittest.TestCase):
         desired = torch.empty(self.nx, self.ny)
         for i in range(self.nx):
             for j in range(self.ny):
-                desired[i][j] = torch.nn.functional.pairwise_distance(
+                desired[i][j] = (torch.nn.functional.pairwise_distance(
                     self.x[i].reshape(1, -1),
                     self.y[j].reshape(1, -1),
                     p=2,
                     keepdim=False,
-                )**2
+                )**2)
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=2)
@@ -254,14 +254,14 @@ class TestDistances(unittest.TestCase):
         self.assertIsNone(mismatch)
 
     def test_lpnorm_pinf(self):
-        actual = distances.lpnorm_distance(self.x, self.y, p=float('inf'))
+        actual = distances.lpnorm_distance(self.x, self.y, p=float("inf"))
         desired = torch.empty(self.nx, self.ny)
         for i in range(self.nx):
             for j in range(self.ny):
                 desired[i][j] = torch.nn.functional.pairwise_distance(
                     self.x[i].reshape(1, -1),
                     self.y[j].reshape(1, -1),
-                    p=float('inf'),
+                    p=float("inf"),
                     keepdim=False,
                 )
         mismatch = np.testing.assert_array_almost_equal(actual,
@@ -275,12 +275,12 @@ class TestDistances(unittest.TestCase):
         desired = torch.empty(self.nx, self.ny)
         for i in range(self.nx):
             for j in range(self.ny):
-                desired[i][j] = torch.nn.functional.pairwise_distance(
+                desired[i][j] = (torch.nn.functional.pairwise_distance(
                     self.x[i].reshape(1, -1),
                     self.y[j].reshape(1, -1),
                     p=2,
                     keepdim=False,
-                )**2
+                )**2)
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=2)
@@ -293,12 +293,12 @@ class TestDistances(unittest.TestCase):
         desired = torch.empty(self.nx, self.ny)
         for i in range(self.nx):
             for j in range(self.ny):
-                desired[i][j] = torch.nn.functional.pairwise_distance(
+                desired[i][j] = (torch.nn.functional.pairwise_distance(
                     self.x[i].reshape(1, -1),
                     self.y[j].reshape(1, -1),
                     p=2,
                     keepdim=False,
-                )**2
+                )**2)
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=2)
@@ -311,8 +311,12 @@ class TestDistances(unittest.TestCase):
 class TestInitializers(unittest.TestCase):
     def setUp(self):
         self.flist = [
-            'zeros', 'ones', 'rand', 'randn', 'stratified_mean',
+            "zeros",
-            'stratified_random'
+            "ones",
+            "rand",
+            "randn",
+            "stratified_mean",
+            "stratified_random",
         ]
         self.x = torch.tensor(
             [[0, -1, -2], [10, 11, 12], [0, 0, 0], [2, 2, 2]],
@@ -340,7 +344,7 @@ class TestInitializers(unittest.TestCase):
             self.assertEqual(1, f(1))
 
     def test_unknown_deserialization(self):
-        for funcname in ['blubb', 'foobar']:
+        for funcname in ["blubb", "foobar"]:
             with self.assertRaises(NameError):
                 _ = initializers.get_initializer(funcname)
 
@@ -383,7 +387,7 @@ class TestInitializers(unittest.TestCase):
     def test_stratified_mean_equal1(self):
         pdist = torch.tensor([1, 1])
         actual, _ = initializers.stratified_mean(self.x, self.y, pdist, False)
-        desired = torch.tensor([[5., 5., 5.], [1., 1., 1.]])
+        desired = torch.tensor([[5.0, 5.0, 5.0], [1.0, 1.0, 1.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
@@ -393,7 +397,7 @@ class TestInitializers(unittest.TestCase):
         pdist = torch.tensor([1, 1])
         actual, _ = initializers.stratified_random(self.x, self.y, pdist,
                                                    False)
-        desired = torch.tensor([[0., -1., -2.], [0., 0., 0.]])
+        desired = torch.tensor([[0.0, -1.0, -2.0], [0.0, 0.0, 0.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
@@ -402,8 +406,8 @@ class TestInitializers(unittest.TestCase):
     def test_stratified_mean_equal2(self):
         pdist = torch.tensor([2, 2])
         actual, _ = initializers.stratified_mean(self.x, self.y, pdist, False)
-        desired = torch.tensor([[5., 5., 5.], [5., 5., 5.], [1., 1., 1.],
+        desired = torch.tensor([[5.0, 5.0, 5.0], [5.0, 5.0, 5.0],
-                                [1., 1., 1.]])
+                                [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
@@ -413,8 +417,8 @@ class TestInitializers(unittest.TestCase):
         pdist = torch.tensor([2, 2])
         actual, _ = initializers.stratified_random(self.x, self.y, pdist,
                                                    False)
-        desired = torch.tensor([[0., -1., -2.], [0., -1., -2.], [0., 0., 0.],
+        desired = torch.tensor([[0.0, -1.0, -2.0], [0.0, -1.0, -2.0],
-                                [0., 0., 0.]])
+                                [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
@@ -423,8 +427,8 @@ class TestInitializers(unittest.TestCase):
     def test_stratified_mean_unequal(self):
         pdist = torch.tensor([1, 3])
         actual, _ = initializers.stratified_mean(self.x, self.y, pdist, False)
-        desired = torch.tensor([[5., 5., 5.], [1., 1., 1.], [1., 1., 1.],
+        desired = torch.tensor([[5.0, 5.0, 5.0], [1.0, 1.0, 1.0],
-                                [1., 1., 1.]])
+                                [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
@@ -434,8 +438,8 @@ class TestInitializers(unittest.TestCase):
         pdist = torch.tensor([1, 3])
         actual, _ = initializers.stratified_random(self.x, self.y, pdist,
                                                    False)
-        desired = torch.tensor([[0., -1., -2.], [0., 0., 0.], [0., 0., 0.],
+        desired = torch.tensor([[0.0, -1.0, -2.0], [0.0, 0.0, 0.0],
-                                [0., 0., 0.]])
+                                [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
         mismatch = np.testing.assert_array_almost_equal(actual,
                                                         desired,
                                                         decimal=5)
@@ -444,8 +448,8 @@ class TestInitializers(unittest.TestCase):
     def test_stratified_mean_unequal_one_hot(self):
         pdist = torch.tensor([1, 3])
         y = torch.eye(2)[self.y]
-        desired1 = torch.tensor([[5., 5., 5.], [1., 1., 1.], [1., 1., 1.],
+        desired1 = torch.tensor([[5.0, 5.0, 5.0], [1.0, 1.0, 1.0],
-                                 [1., 1., 1.]])
+                                 [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
         actual1, actual2 = initializers.stratified_mean(self.x, y, pdist)
         desired2 = torch.tensor([[1, 0], [0, 1], [0, 1], [0, 1]])
         mismatch = np.testing.assert_array_almost_equal(actual1,
@@ -460,8 +464,8 @@ class TestInitializers(unittest.TestCase):
         pdist = torch.tensor([1, 3])
         y = torch.eye(2)[self.y]
         actual1, actual2 = initializers.stratified_random(self.x, y, pdist)
-        desired1 = torch.tensor([[0., -1., -2.], [0., 0., 0.], [0., 0., 0.],
+        desired1 = torch.tensor([[0.0, -1.0, -2.0], [0.0, 0.0, 0.0],
-                                 [0., 0., 0.]])
+                                 [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
         desired2 = torch.tensor([[1, 0], [0, 1], [0, 1], [0, 1]])
         mismatch = np.testing.assert_array_almost_equal(actual1,
                                                         desired1,

tests/test_modules.py

@@ -29,10 +29,12 @@ class TestPrototypes(unittest.TestCase):
             _ = prototypes.Prototypes1D(nclasses=1, input_dim=1)
 
     def test_prototypes1d_init_without_pdist(self):
-        p1 = prototypes.Prototypes1D(input_dim=6,
+        p1 = prototypes.Prototypes1D(
+            input_dim=6,
             nclasses=2,
             prototypes_per_class=4,
-                                     prototype_initializer='ones')
+            prototype_initializer="ones",
+        )
         protos = p1.prototypes
         actual = protos.detach().numpy()
         desired = torch.ones(8, 6)
@@ -45,7 +47,7 @@ class TestPrototypes(unittest.TestCase):
         pdist = [2, 2]
         p1 = prototypes.Prototypes1D(input_dim=3,
                                      prototype_distribution=pdist,
-                                     prototype_initializer='zeros')
+                                     prototype_initializer="zeros")
         protos = p1.prototypes
         actual = protos.detach().numpy()
         desired = torch.zeros(4, 3)
@@ -60,14 +62,15 @@ class TestPrototypes(unittest.TestCase):
                 input_dim=3,
                 nclasses=2,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
-                data=None)
+                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')
+                                     prototype_initializer="zeros")
         protos = p1.prototypes
         actual = protos.detach().numpy()
         desired = torch.zeros(4, 3)
@@ -77,24 +80,30 @@ class TestPrototypes(unittest.TestCase):
         self.assertIsNone(mismatch)
 
     def test_prototypes1d_init_without_inputdim_with_data(self):
-        _ = prototypes.Prototypes1D(nclasses=2,
+        _ = prototypes.Prototypes1D(
-                                    prototypes_per_class=1,
-                                    prototype_initializer='stratified_mean',
-                                    data=[[[1.], [0.]], [1, 0]])
-
-    def test_prototypes1d_init_with_int_data(self):
-        _ = prototypes.Prototypes1D(nclasses=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,
             nclasses=2,
             prototypes_per_class=1,
-                                    prototype_initializer='stratified_mean',
+            prototype_initializer="stratified_mean",
+            data=[[[1.0], [0.0]], [1, 0]],
+        )
+
+    def test_prototypes1d_init_with_int_data(self):
+        _ = prototypes.Prototypes1D(
+            nclasses=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,
+            nclasses=2,
+            prototypes_per_class=1,
+            prototype_initializer="stratified_mean",
             data=None,
-                                    one_hot_labels=True)
+            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`
@@ -105,9 +114,10 @@ class TestPrototypes(unittest.TestCase):
                 input_dim=1,
                 nclasses=2,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
-                data=([[0.], [1.]], [[0, 1], [1, 0]]),
+                data=([[0.0], [1.0]], [[0, 1], [1, 0]]),
-                one_hot_labels=False)
+                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`
@@ -118,9 +128,10 @@ class TestPrototypes(unittest.TestCase):
                 input_dim=1,
                 nclasses=2,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
-                data=([[0.], [1.]], [0, 1]),
+                data=([[0.0], [1.0]], [0, 1]),
-                one_hot_labels=True)
+                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`
@@ -132,25 +143,27 @@ class TestPrototypes(unittest.TestCase):
                 input_dim=1,
                 nclasses=2,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
-                data=([[0.], [1.]], [[0], [1]]),
+                data=([[0.0], [1.0]], [[0], [1]]),
-                one_hot_labels=True)
+                one_hot_labels=True,
+            )
 
     def test_prototypes1d_init_with_int_dtype(self):
         with self.assertRaises(RuntimeError):
             _ = prototypes.Prototypes1D(
                 nclasses=2,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
                 data=[[[1], [0]], [1, 0]],
-                dtype=torch.int32)
+                dtype=torch.int32,
+            )
 
     def test_prototypes1d_inputndim_with_data(self):
         with self.assertRaises(ValueError):
             _ = prototypes.Prototypes1D(input_dim=1,
                                         nclasses=1,
                                         prototypes_per_class=1,
-                                        data=[[1.], [1]])
+                                        data=[[1.0], [1]])
 
     def test_prototypes1d_inputdim_with_data(self):
         with self.assertRaises(ValueError):
@@ -158,8 +171,9 @@ class TestPrototypes(unittest.TestCase):
                 input_dim=2,
                 nclasses=2,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
-                data=[[[1.], [0.]], [1, 0]])
+                data=[[[1.0], [0.0]], [1, 0]],
+            )
 
     def test_prototypes1d_nclasses_with_data(self):
         """Test ValueError raise if provided `nclasses` is not the same
@@ -170,13 +184,14 @@ class TestPrototypes(unittest.TestCase):
                 input_dim=1,
                 nclasses=1,
                 prototypes_per_class=1,
-                prototype_initializer='stratified_mean',
+                prototype_initializer="stratified_mean",
-                data=[[[1.], [2.]], [1, 2]])
+                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')
+                                     prototype_initializer="zeros")
         protos = p1.prototypes
         actual = protos.detach().numpy()
         desired = torch.zeros(4, 3)
@@ -186,9 +201,11 @@ class TestPrototypes(unittest.TestCase):
         self.assertIsNone(mismatch)
 
     def test_prototypes1d_init_with_pdist(self):
-        p1 = prototypes.Prototypes1D(data=[self.x, self.y],
+        p1 = prototypes.Prototypes1D(
+            data=[self.x, self.y],
             prototype_distribution=[6, 9],
-                                     prototype_initializer='zeros')
+            prototype_initializer="zeros",
+        )
         protos = p1.prototypes
         actual = protos.detach().numpy()
         desired = torch.zeros(15, 3)
@@ -201,10 +218,12 @@ class TestPrototypes(unittest.TestCase):
         def my_initializer(*args, **kwargs):
             return torch.full((2, 99), 99.0), torch.tensor([0, 1])
 
-        p1 = prototypes.Prototypes1D(input_dim=99,
+        p1 = prototypes.Prototypes1D(
+            input_dim=99,
             nclasses=2,
             prototypes_per_class=1,
-                                     prototype_initializer=my_initializer)
+            prototype_initializer=my_initializer,
+        )
         protos = p1.prototypes
         actual = protos.detach().numpy()
         desired = 99 * torch.ones(2, 99)
@@ -231,7 +250,7 @@ class TestPrototypes(unittest.TestCase):
     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, '')
+        self.assertNotEqual(rep, "")
 
     def tearDown(self):
         del self.x, self.y, self.gen
@@ -243,11 +262,11 @@ class TestLosses(unittest.TestCase):
         pass
 
     def test_glvqloss_init(self):
-        _ = losses.GLVQLoss(0, 'swish_beta', beta=20)
+        _ = losses.GLVQLoss(0, "swish_beta", beta=20)
 
     def test_glvqloss_forward_1ppc(self):
         criterion = losses.GLVQLoss(margin=0,
-                                    squashing='sigmoid_beta',
+                                    squashing="sigmoid_beta",
                                     beta=100)
         d = torch.stack([torch.ones(100), torch.zeros(100)], dim=1)
         labels = torch.tensor([0, 1])
@@ -259,7 +278,7 @@ class TestLosses(unittest.TestCase):
 
     def test_glvqloss_forward_2ppc(self):
         criterion = losses.GLVQLoss(margin=0,
-                                    squashing='sigmoid_beta',
+                                    squashing="sigmoid_beta",
                                     beta=100)
         d = torch.stack([
             torch.ones(100),