python-som 0.0.1a1__py3-none-any.whl → 0.1.1__py3-none-any.whl

python_som/__init__.py

@@ -1,12 +1,47 @@
+"""This module contains the implementation of the 2D self-organizing map.
+
+Most features were implemented using NumPy, with Scikit-learn for standardization and PCA.
+
+Features:
+    - Stepwise and batch training
+    - Random weight initialization
+    - Random sampling weight initialization
+    - Linear weight initialization (with PCA)
+    - Automatic selection of map size ratio (with PCA)
+    - Support for cyclic arrays, for toroidal or spherical maps
+    - Gaussian and Bubble neighborhood functions
+    - Support for custom decay functions
+    - Support for visualization (U-matrix, activation matrix)
+    - Support for supervised learning (label map)
+    - Support for NumPy arrays, Pandas DataFrames and regular lists of values
+
+Reference:
+Teuvo Kohonen,
+Essentials of the self-organizing map,
+Neural Networks,
+Volume 37,
+2013,
+Pages 52-65,
+ISSN 0893-6080,
+https://doi.org/10.1016/j.neunet.2012.09.018.
+"""
+
 # %%
 from collections import Counter
-from typing import Union, Callable, Tuple, Iterable
+from typing import Callable
 
 import numpy as np
 import pandas as pd
-import sklearn
-import sklearn.decomposition
-import sklearn.preprocessing
+import sklearn  # type: ignore
+import sklearn.decomposition  # type: ignore
+import sklearn.preprocessing  # type: ignore
+
+try:
+    import tqdm
+
+    TQDM_AVAILABLE = True
+except ImportError:
+    TQDM_AVAILABLE = False
 
 
 # %%
@@ -59,13 +94,14 @@ def _inverse_decay(x: float, t: int, max_t: int) -> float:
     return (max_t / 100) * x / ((max_t / 100) + t)
 
 
-def _euclidean_distance(a: Union[float, np.ndarray], b: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
-    """
-    This function calculates the euclidean distances between the elements of the last dimension of a and b.
+def _euclidean_distance(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """This function calculates the euclidean distances between the elements of the last dimension
+         of a and b.
 
     The parameters a and b may be n-dimensional, but their shapes must be capable of broadcasting
 
-    The shape of the output complies to the first n-1 dimensions of the parameter with the highest dimensionality.
+    The shape of the output complies to the first n-1 dimensions of the parameter with the highest
+        dimensionality.
 
     :param a: array-like: list or numpy array of values. a must not be a scalar value.
     :param b: array-like: list or numpy array of values. b must not be a scalar value.
@@ -75,9 +111,11 @@ def _euclidean_distance(a: Union[float, np.ndarray], b: Union[float, np.ndarray]
 
 
 class SOM:
-    """
-    Implementation of the 2D self-organizing map, with support for NumPy arrays and Pandas DataFrames.
-    Most features were implemented using NumPy, with Scikit-learn for standardization and PCA operations.
+    """Implementation of the 2D self-organizing map, with support for NumPy arrays and
+        Pandas DataFrames.
+
+    Most features were implemented using NumPy, with Scikit-learn for standardization and
+        PCA operations.
 
     Features:
         - Stepwise and batch training
@@ -101,25 +139,28 @@ class SOM:
     Pages 52-65,
     ISSN 0893-6080,
     https://doi.org/10.1016/j.neunet.2012.09.018.
-
     """
 
     def __init__(
-            self,
-            x: Union[int, None],
-            y: Union[int, None],
-            input_len: int,
-            learning_rate: float = 0.5,
-            learning_rate_decay: Callable[[float, int, int], float] = _asymptotic_decay,
-            neighborhood_radius: float = 1.0,
-            neighborhood_radius_decay: Callable[[float, int, int], float] = _asymptotic_decay,
-            neighborhood_function: str = 'gaussian',
-            distance_function: Callable[
-                [Union[float, np.ndarray], Union[float, np.ndarray]], Union[float, np.ndarray]] = _euclidean_distance,
-            cyclic_x: bool = False,
-            cyclic_y: bool = False,
-            random_seed: Union[int, None] = None,
-            data: Union[np.ndarray, pd.DataFrame, list, None] = None,
+        self,
+        x: int | None,
+        y: int | None,
+        input_len: int,
+        learning_rate: float = 0.5,
+        learning_rate_decay: Callable[[float, int, int], float] = _asymptotic_decay,
+        neighborhood_radius: float = 1.0,
+        neighborhood_radius_decay: Callable[
+            [float, int, int], float
+        ] = _asymptotic_decay,
+        neighborhood_function: str = "gaussian",
+        distance_function: Callable[
+            [np.ndarray, np.ndarray],
+            np.ndarray,
+        ] = _euclidean_distance,
+        cyclic_x: bool = False,
+        cyclic_y: bool = False,
+        random_seed: int | None = None,
+        data: np.ndarray | pd.DataFrame | list | None = None,
     ) -> None:
         """
         Constructor for the self-organizing map class.
@@ -127,13 +168,13 @@ class SOM:
         :param x: int or NoneType: X dimension of the self-organizing map, i.e.,
             number of rows of the matrix of weights.
             x should be larger than 0.
-            If x is None and 'data' is provided in kwargs, its value will be automatically selected using PCA of 'data'.
-            Either x or y should be different than None.
+            If x is None and 'data' is provided in kwargs, its value will be automatically
+            selected using PCA of 'data'. Either x or y should be different than None.
         :param y: int or NoneType: Y dimension of the self-organizing map, i.e.,
             number of columns of the matrix of weights.
             y should be larger than 0.
-            If y is None and 'data' is provided in kwargs, its value will be automatically selected using PCA of 'data'.
-            Either x or y should be different than None.
+            If y is None and 'data' is provided in kwargs, its value will be automatically
+            selected using PCA of 'data'. Either x or y should be different than None.
         :param input_len: int: Number of features of the training dataset, i.e.,
             number of elements of each node of the network.
         :param learning_rate: float: Initial learning rate for the training process.
@@ -141,23 +182,24 @@ class SOM:
             Defaults to 0.5.
             Note: The value of the learning_rate is irrelevant for the 'batch' training mode.
         :param learning_rate_decay: function: Decay function for the learning_rate variable.
-            May be a predefined one from this package, or a custom function, with the same parameters and return type.
-            Defaults to _asymptotic_decay.
-        :param neighborhood_radius: float: Initial neighborhood radius for the training process. Defaults to 1.
-        :param neighborhood_radius_decay: function: Decay function for the neighborhood_radius variable.
-            May be a predefined one from this package, or a custom function, with the same parameters and return type.
-            Defaults to _asymptotic_decay
+            May be a predefined one from this package, or a custom function, with the same
+            parameters and return type. Defaults to _asymptotic_decay.
+        :param neighborhood_radius: float: Initial neighborhood radius for the training process.
+            Defaults to 1.
+        :param neighborhood_radius_decay: function: Decay function for the neighborhood_radius
+            variable. May be a predefined one from this package, or a custom function, with the
+            same parameters and return type. Defaults to _asymptotic_decay
         :param neighborhood_function: str: Neighborhood function name for the training process.
             May be either 'gaussian' or 'bubble'.
-        :param distance_function: function: Function for calculating distances/dissimilarities between models of the
-            network.
-            May be a predefined one from this package, or a custom function, with the same parameters and return type.
-            Defaults to _euclidean_distance.
-        :param cyclic_x: bool: Boolean value activate/deactivate cyclic arrays in the x direction, i.e,
-            between the first and last rows of the weight matrix.
+        :param distance_function: function: Function for calculating distances/dissimilarities
+            between models of the network.
+            May be a predefined one from this package, or a custom function, with the same
+            parameters and return type. Defaults to _euclidean_distance.
+        :param cyclic_x: bool: Boolean value activate/deactivate cyclic arrays in the x direction,
+            i.e, between the first and last rows of the weight matrix.
             Defaults to False.
-        :param cyclic_y: bool: Boolean value activate/deactivate cyclic arrays in the y direction, i.e,
-            between the first and last columns of the weight matrix.
+        :param cyclic_y: bool: Boolean value activate/deactivate cyclic arrays in the y direction,
+            i.e, between the first and last columns of the weight matrix.
             Defaults to False.
         :param random_seed: int or None: Seed for NumPy random value generator. Defaults to None.
         :param data: array-like: dataset for performing PCA.
@@ -165,21 +207,25 @@ class SOM:
         """
         # Verifying map dimensions (initializing automatically, if a dataset is provided)
         if (x, y) == (None, None):
-            raise ValueError('At least one of the dimensions (x, y) must be specified')
+            raise ValueError("At least one of the dimensions (x, y) must be specified")
         if x is None or y is None:
             # If a dataset was given through **kwargs, select missing dimension with PCA
-            # The ratio of the (x, y) sizes will comply roughly with the ratio of the two largest principal components
-            if 'data' is None:
+            # The ratio of the (x, y) sizes will comply roughly with the ratio of
+            # the two largest principal components
+            if data is None:
                 raise ValueError(
-                    "If one of the dimensions is not specified, a dataset must be provided for automatic size "
-                    "initialization.")
+                    "If one of the dimensions is not specified,"
+                    "a dataset must be provided for automatic size initialization."
+                )
             # Convert data to numpy array
             if isinstance(data, pd.DataFrame):
                 data_array = data.to_numpy()
             else:
                 data_array = np.array(data)
             # Perform PCA w/ sklearn
-            data_array = sklearn.preprocessing.StandardScaler().fit_transform(data_array)
+            data_array = sklearn.preprocessing.StandardScaler().fit_transform(
+                data_array
+            )
             pca = sklearn.decomposition.PCA(n_components=2)
             pca.fit(data_array)
             ratio = pca.explained_variance_[0] / pca.explained_variance_[1]
@@ -192,30 +238,31 @@ class SOM:
         # Initializing private variables
         self._shape = (np.uint(x), np.uint(y))
         self._input_len = np.uint(input_len)
-        self._learning_rate = np.float(learning_rate)
+        self._learning_rate = float(learning_rate)
         self._learning_rate_decay = learning_rate_decay
-        self._neighborhood_radius = np.float(neighborhood_radius)
+        self._neighborhood_radius = float(neighborhood_radius)
         self._neighborhood_radius_decay = neighborhood_radius_decay
         self._neighborhood_function = {
-            'gaussian': self._gaussian,
-            'bubble': self._bubble}[neighborhood_function]
+            "gaussian": self._gaussian,
+            "bubble": self._bubble,
+        }[neighborhood_function]
         self._distance_function = distance_function
-        self._cyclic = (np.bool(cyclic_x), np.bool(cyclic_y))
+        self._cyclic = (bool(cyclic_x), bool(cyclic_y))
         self._neigx, self._neigy = np.arange(self._shape[0]), np.arange(self._shape[1])
 
         # Seed numpy random generator
         if random_seed is None:
-            self._random_seed = np.random.randint(
-                np.random.randint(np.iinfo(np.int32).max))
+            self._random_seed = np.random.randint(np.iinfo(np.int32).max)
         else:
-            self._random_seed = np.int(random_seed)
+            self._random_seed = int(random_seed)
         np.random.seed(self._random_seed)
 
         # Random weight initialization
         self._weights = np.random.standard_normal(
-            size=(self._shape[0], self._shape[1], self._input_len))
+            size=(self._shape[0], self._shape[1], self._input_len)
+        )
 
-    def get_shape(self) -> Tuple[int, int]:
+    def get_shape(self) -> tuple[np.uint, np.uint]:
         """
         Gets the shape of the network.
 
@@ -237,17 +284,17 @@ class SOM:
 
         :param learning_rate: float: New value for learning_rate of an instance of the SOM.
         """
-        self._learning_rate = np.float(learning_rate)
+        self._learning_rate = float(learning_rate)
 
     def set_neighborhood_radius(self, neighborhood_radius: float) -> None:
         """
         Sets the neighborhood_radius member of the SOM.
 
-        :param neighborhood_radius: float: New value for neighborhood_radius of an instance of the SOM.
+        :param neighborhood_radius: float: New value for neighborhood_radius of a SOM instance.
         """
-        self._neighborhood_radius = np.float(neighborhood_radius)
+        self._neighborhood_radius = float(neighborhood_radius)
 
-    def activate(self, x: Union[np.ndarray, pd.DataFrame, list]) -> np.ndarray:
+    def activate(self, x: np.ndarray) -> np.ndarray:
         """
         Calculates distances between an instance x and the weights of the network.
 
@@ -256,7 +303,7 @@ class SOM:
         """
         return self._distance_function(x, self._weights)
 
-    def winner(self, x: Union[np.ndarray, pd.DataFrame, list]) -> Union[Iterable, Tuple[int, int]]:
+    def winner(self, x: np.ndarray) -> tuple[int, ...]:
         """
         Calculates the best-matching unit of the network for an instance x
 
@@ -264,26 +311,31 @@ class SOM:
         :return: (int, int): Index of the best-matching unit of x.
         """
         activation_map = self.activate(x)
-        return np.unravel_index(activation_map.argmin(), activation_map.shape)
+        min_index = tuple(
+            map(int, np.unravel_index(activation_map.argmin(), activation_map.shape))
+        )
+        return min_index
 
-    def quantization(self, data: Union[np.ndarray, pd.DataFrame, list]) -> np.ndarray:
+    def quantization(self, data: np.ndarray | pd.DataFrame | list) -> np.ndarray:
         """
         Calculates distances from each instance of 'data' to each of the weights of the network.
 
         :param data: array-like: Dataset to be compared with the weights of the network.
+            Expected shape is (n_samples, n_features).
         :return: np.ndarray: array of lists of distances from each instance of the dataset
             to each weight of the network.
         """
         # Convert data to numpy array
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
-        return np.array([(self._distance_function(i, self._weights[self.winner(i)])) for i in data_array])
-
-    def quantization_error(self, data: Union[np.ndarray, pd.DataFrame, list]) -> float:
-        """
-        Calculates average distance of the weights of the network to their assigned instances from data.
+        data_array = self._data_to_numpy(data)
+        return np.array(
+            [
+                (self._distance_function(i, self._weights[self.winner(i)]))
+                for i in data_array
+            ]
+        )
+
+    def quantization_error(self, data: np.ndarray | pd.DataFrame | list) -> float:
+        """Calculates average distance of the weights of the network to their assigned instances.
         This error is a quality measure for the training process.
 
         :param data: array-like: Dataset to be compared with the weights of the network.
@@ -292,43 +344,52 @@ class SOM:
         quantization = self.quantization(data)
         return quantization.mean()
 
-    def distance_matrix(self) -> np.ndarray:
+    def distance_matrix(self, normalize: bool = False) -> np.ndarray:
         """
-        Calculates U-matrix of the current state of the network, i.e., the matrix of distances between each node and its
-        neighbors. Has support for cyclic arrays
+        Calculates U-matrix of the current state of the network,
+        i.e., the matrix of distances between each node and its neighbors.
+        Has support for cyclic arrays
 
+        :param normalize: bool: Activate to normalize the U-matrix between 0 and 1.
+            Defaults to False.
         :return: np.ndarray: U-matrix of the current state of the network.
         """
         um = np.zeros(shape=self._shape)
-        it = np.nditer(um, flags=['multi_index'])
+        it = np.nditer(um, flags=["multi_index"])
+        distances = np.zeros(self._shape + self._shape)
+        for i in range(self._shape[0]):
+            for j in range(self._shape[1]):
+                distances[i, j] = self._distance_function(
+                    self._weights[i, j], self._weights
+                )
+
         while not it.finished:
             update_matrix = self._bubble(it.multi_index, 1)
-            um[it.multi_index] = np.sum(
-                update_matrix * self._distance_function(self._weights[it.multi_index], self._weights))
+            um[it.multi_index] = np.sum(update_matrix * distances[it.multi_index])
             it.iternext()
-        um /= um.max(initial=0.0)
+        if normalize:
+            # Normalize U-matrix between 0 and 1
+            um = (um - np.min(um)) / (np.max(um) - np.min(um))
         return um
 
-    def activation_matrix(self, data: Union[np.ndarray, pd.DataFrame, list]) -> np.ndarray:
-        """
-        Calculates the activation matrix of the network for a dataset, i.e., for each node, the count of instances that
-        have been assigned to it, in the current state.
+    def activation_matrix(self, data: np.ndarray | pd.DataFrame | list) -> np.ndarray:
+        """Calculates the activation matrix of the network for a dataset.
+
+        I.e., for each node, the count of instances that have been assigned to in,
+            in the current state.
 
         :param data: array-like: Dataset to be compared with the weights of the network.
         :return: np.ndarray: Activation matrix.
         """
         # Convert data to numpy array
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
+        data_array = self._data_to_numpy(data)
 
         activation_matrix = np.zeros(self._shape)
         for i in data_array:
             activation_matrix[self.winner(i)] += 1
         return activation_matrix
 
-    def winner_map(self, data: Union[np.ndarray, pd.DataFrame, list]) -> dict:
+    def winner_map(self, data: np.ndarray | pd.DataFrame | list) -> dict:
         """
         Calculates, for each node (i, j) of the network,
         the list of all instances from 'data' that has been assigned to it.
@@ -337,44 +398,55 @@ class SOM:
         :return: dict: Winner map.
         """
         # Convert data to numpy array
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
-        winner_map = {(i, j): [] for i in range(self._shape[0]) for j in range(self._shape[1])}
+        data_array = self._data_to_numpy(data)
+        winner_map: dict[tuple[int, ...], list] = {
+            tuple(index): [] for index in np.ndindex(self._shape)
+        }
         for i in data_array:
             winner_map[self.winner(i)].append(i)
         return winner_map
 
-    def label_map(self, data: Union[np.ndarray, pd.DataFrame, list],
-                  labels: Union[np.ndarray, pd.DataFrame, list]) -> dict:
-        """
-        Calculates, for each node (i, j) of the network, the frequency of each label from 'labels' corresponding to its
-        respective instance from 'data' that has been assigned to this node.
+    def label_map(
+        self,
+        data: np.ndarray | pd.DataFrame | list,
+        labels: np.ndarray | pd.DataFrame | list,
+    ) -> dict[tuple[int, ...], Counter]:
+        """Calculates, for each node (i, j) of the network, the frequency of each label...
+
+        from 'labels' corresponding to its respective instance from 'data' that has been assigned
+            to this node.
+
         :param data: array-like: Dataset to be compared with the weights of the network.
         :param labels: array-like: Labels corresponding to the indices of 'data'.
         :return: dict: Label map.
         """
         # Convert data to numpy array
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
+        data_array = self._data_to_numpy(data)
         # Convert labels to numpy array
         if isinstance(labels, pd.DataFrame):
             labels = labels.to_numpy()
         else:
             labels = np.array(labels)
 
-        winner_map = {(i, j): [] for i in range(self._shape[0]) for j in range(self._shape[1])}
-        for i in range(len(data_array)):
-            winner_map[self.winner(data_array[i])].append(labels[i])
-        for key in winner_map:
-            winner_map[key] = Counter(winner_map[key])
-        return winner_map
-
-    def train(self, data: Union[np.ndarray, pd.DataFrame, list], n_iteration: Union[int, None] = None,
-              mode: str = 'random', verbose: bool = False) -> float:
+        winner_map: dict[tuple[int, ...], list] = {
+            tuple(index): [] for index in np.ndindex(self._shape)
+        }
+        label_count_map: dict[tuple[int, ...], Counter] = {
+            tuple(index): Counter() for index in np.ndindex(self._shape)
+        }
+        for i, instance in enumerate(data_array):
+            winner = self.winner(instance)
+            winner_map[winner].append(labels[i])
+            label_count_map[winner].update([labels[i]])
+        return label_count_map
+
+    def train(
+        self,
+        data: np.ndarray | pd.DataFrame | list,
+        n_iteration: int | None = None,
+        mode: str = "random",
+        verbose: bool = False,
+    ) -> float:
         """
         Trains the self-organizing map, with the dataset 'data', and a certain number of iterations.
 
@@ -383,163 +455,268 @@ class SOM:
             If None, defaults to 1000 * len(data) for stepwise training modes,
             or 10 * len(data) for batch training mode.
         :param mode: str: Training mode name. May be either 'random', 'sequential', or 'batch'.
-            For 'batch' mode, a much smaller number of iterations is needed, but a higher computation power is required
-            for each individual iteration.
+            For 'batch' mode, a much smaller number of iterations is needed,
+            but a higher computation power is required for each individual iteration.
         :param verbose: bool: Activate to print useful information to the terminal/console, e.g.,
             the progress of the training process
         :return: float: Quantization error after training
         """
         # Convert data to numpy array for training
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
+        data_array = self._data_to_numpy(data)
 
         # If no number of iterations is given, select automatically
         if n_iteration is None:
-            n_iteration = {'random': 1000, 'sequential': 1000, 'batch': 10}[mode] * len(data_array)
+            n_iteration = {"random": 1000, "sequential": 1000, "batch": 10}[mode] * len(
+                data_array
+            )
 
         if verbose:
-            print("Training with", n_iteration,
-                  "iterations.\nTraining mode:", mode, sep=' ')
-        if mode == 'random':
-            # Random sampling from training dataset
-            for it, i in enumerate(
-                    np.random.choice(len(data_array), size=n_iteration, replace=(n_iteration > len(data)))):
-                # Calculating decaying alpha and sigma parameters for updating weights
-                alpha = self._learning_rate_decay(self._learning_rate, it, n_iteration)
-                sigma = self._neighborhood_radius_decay(
-                    self._neighborhood_radius, it, n_iteration)
-
-                # Finding winner node (best-matching unit)
-                winner = self.winner(data_array[i])
-
-                # Updating weights, based on current neighborhood function
-                self._weights += alpha * self._neighborhood_function(winner, sigma)[..., None] * (
-                        data_array[i] - self._weights)
-
-                # Print progress, if verbose is activated
-                if verbose:
-                    print("Iteration:", it, "/", n_iteration, sep=' ', end='\r', flush=True)
-        elif mode == 'sequential':
-            # Sequential sampling from training dataset
-            for it, i in enumerate(data_array):
-                # Calculating decaying alpha and sigma parameters for updating weights
-                alpha = self._learning_rate_decay(self._learning_rate, it, n_iteration)
-                sigma = self._neighborhood_radius_decay(
-                    self._neighborhood_radius, it, n_iteration)
-
-                # Finding winner node (best-matching unit)
-                winner = self.winner(i)
-
-                # Updating weights, based on current neighborhood function
-                self._weights += alpha * self._neighborhood_function(winner, sigma)[..., None] * (
-                        i - self._weights)
-
-                # Print progress, if verbose is activated
-                if verbose:
-                    print("Iteration:", it, "/", n_iteration, sep=' ', end='\r', flush=True)
-        elif mode == 'batch':
-            # Batch training
-            for it in range(n_iteration):
-                # Calculating decaying sigma
-                sigma = self._neighborhood_radius_decay(
-                    self._neighborhood_radius, it, n_iteration)
-
-                # For each node, create a list of instances associated to it
-                winner_map = self.winner_map(data_array)
-
-                # Calculate the weighted average of all instances in the neighborhood of each node
-                new_weights = np.zeros(self._weights.shape)
-                for i in winner_map.keys():
-                    neig = self._neighborhood_function(i, sigma)
-                    upper, bottom = np.zeros(self._input_len), 0.0
-                    for j in winner_map.keys():
-                        upper += neig[j] * np.sum(winner_map[j], axis=0)
-                        bottom += neig[j] * len(winner_map[j])
-
-                    # Only update if there is any instance associated with the winner node or its neighbors
-                    if bottom != 0:
-                        new_weights[i] = upper / bottom
-
-                # Update all nodes concurrently
-                self._weights = new_weights
-
-                # Print progress, if verbose is activated
-                if verbose:
-                    print("Iteration:", it, "/", n_iteration, sep=' ', end='\r', flush=True)
+            print(
+                "Training with",
+                n_iteration,
+                "iterations.\nTraining mode:",
+                mode,
+                sep=" ",
+            )
+
+        if mode == "random":
+            self._train_random(data_array, n_iteration, verbose)
+        elif mode == "sequential":
+            self._train_sequential(data_array, n_iteration, verbose)
+        elif mode == "batch":
+            self._train_batch(data_array, n_iteration, verbose)
         else:
             # Invalid training mode value
             raise ValueError(
-                "Invalid value for 'mode' parameter. Value should be in " + str(['random', 'sequential', 'batch']))
+                "Invalid value for 'mode' parameter. Value should be in "
+                + str(["random", "sequential", "batch"])
+            )
 
         # Compute quantization error
         q_error = self.quantization_error(data_array)
         if verbose:
-            print("Quantization error:", q_error, sep=' ')
+            print("Quantization error:", q_error, sep=" ")
         return q_error
 
-    def weight_initialization(self, mode: str = 'random',
-                              **kwargs: Union[np.ndarray, pd.DataFrame, list, str, int]) -> None:
-        """
-        Function for weight initialization of the self-organizing map. Calls other methods for each initialization mode.
+    def _train_random(
+        self, data_array: np.ndarray, n_iteration: int, verbose: bool
+    ) -> None:
+        if TQDM_AVAILABLE and verbose:
+            iterator: enumerate | tqdm.tqdm = tqdm.tqdm(
+                np.random.choice(
+                    len(data_array),
+                    size=n_iteration,
+                    replace=(n_iteration > len(data_array)),
+                ),
+                total=n_iteration,
+                desc="Training",
+            )
+        else:
+            iterator = enumerate(
+                np.random.choice(
+                    len(data_array),
+                    size=n_iteration,
+                    replace=(n_iteration > len(data_array)),
+                )
+            )
+
+        for it, i in iterator:  # type: ignore
+            # Calculating decaying alpha and sigma parameters for updating weights
+            alpha = self._learning_rate_decay(self._learning_rate, it, n_iteration)
+            sigma = self._neighborhood_radius_decay(
+                self._neighborhood_radius, it, n_iteration
+            )
+
+            # Finding winner node (best-matching unit)
+            winner = self.winner(data_array[i])
+
+            # Updating weights, based on current neighborhood function
+            self._weights += (
+                alpha
+                * self._neighborhood_function(winner, sigma)[..., None]
+                * (data_array[i] - self._weights)
+            )
+
+            # Print progress, if verbose is activated and tqdm is not available
+            if verbose and not TQDM_AVAILABLE:
+                print(
+                    "Iteration:",
+                    it,
+                    "/",
+                    n_iteration,
+                    sep=" ",
+                    end="\r",
+                    flush=True,
+                )
+
+    def _train_sequential(
+        self, data_array: np.ndarray, n_iteration: int, verbose: bool
+    ) -> None:
+        if TQDM_AVAILABLE and verbose:
+            iterator: enumerate | tqdm.tqdm = tqdm.tqdm(
+                enumerate(data_array),
+                total=n_iteration,
+                desc="Training",
+            )
+        else:
+            iterator = enumerate(data_array)
+
+        for it, i in iterator:  # type: ignore
+            # Calculating decaying alpha and sigma parameters for updating weights
+            alpha = self._learning_rate_decay(self._learning_rate, it, n_iteration)
+            sigma = self._neighborhood_radius_decay(
+                self._neighborhood_radius, it, n_iteration
+            )
+
+            # Finding winner node (best-matching unit)
+            winner = self.winner(i)
+
+            # Updating weights, based on current neighborhood function
+            self._weights += (
+                alpha
+                * self._neighborhood_function(winner, sigma)[..., None]
+                * (i - self._weights)
+            )
+
+            # Print progress, if verbose is activated and tqdm is not available
+            if verbose and not TQDM_AVAILABLE:
+                print(
+                    "Iteration:",
+                    it,
+                    "/",
+                    n_iteration,
+                    sep=" ",
+                    end="\r",
+                    flush=True,
+                )
+
+    def _train_batch(
+        self, data_array: np.ndarray, n_iteration: int, verbose: bool
+    ) -> None:
+        if TQDM_AVAILABLE and verbose:
+            iterator: range | tqdm.tqdm = tqdm.tqdm(
+                range(n_iteration), total=n_iteration, desc="Training"
+            )
+        else:
+            iterator = range(n_iteration)
+
+        for it in iterator:
+            # Calculating decaying sigma
+            sigma = self._neighborhood_radius_decay(
+                self._neighborhood_radius, it, n_iteration
+            )
+
+            # For each node, create a list of instances associated to it
+            winner_map = self.winner_map(data_array)
+
+            # Calculate the weighted average of all instances in the neighborhood of each node
+            new_weights = np.zeros(self._weights.shape)
+            for i in winner_map.keys():
+                neig = self._neighborhood_function(i, sigma)
+                upper, bottom = np.zeros(self._input_len), 0.0
+                for j in winner_map.keys():
+                    upper += neig[j] * np.sum(winner_map[j], axis=0)
+                    bottom += neig[j] * len(winner_map[j])
+
+                # Only update if there is any instance associated with the winner node
+                # or its neighbors
+                if bottom != 0:
+                    new_weights[i] = upper / bottom
+
+            # Update all nodes concurrently
+            self._weights = new_weights
+
+            # Print progress, if verbose is activated and tqdm is not available
+            if verbose and not TQDM_AVAILABLE:
+                print(
+                    "Iteration:",
+                    it,
+                    "/",
+                    n_iteration,
+                    sep=" ",
+                    end="\r",
+                    flush=True,
+                )
+
+    def weight_initialization(
+        self,
+        mode: str = "random",
+        **kwargs: np.ndarray | pd.DataFrame | list | str | int
+    ) -> None:
+        """Function for weight initialization of the self-organizing map.
+
+        Calls other methods for each initialization mode.
 
         :param mode: str: Initialization mode. May be either 'random', 'linear', or 'sample'.
             Note: Each initialization method may require multiple additional arguments in kwargs.
         :param kwargs:
-            For 'random' initialization mode, 'sample_mode': str may be provided to determine the sampling mode.
-            'sample_mode' may be either 'standard_normal' (default) or 'uniform'.
-            For 'random' and 'sample' modes, 'random_seed': int may be provided for the random value generator.
-            For 'sample' and 'linear' modes, 'data': array-like must be provided for sampling/PCA.
-        """
-        modes = {'random': self._weight_initialization_random, 'linear': self._weight_initialization_linear,
-                 'sample': self._weight_initialization_sample}
+            For 'random' initialization mode, 'sample_mode': str may be provided to determine
+            the sampling mode. 'sample_mode' may be either 'standard_normal' (default) or 'uniform'
+            For 'random' and 'sample' modes, 'random_seed': int may be provided for the random
+            value generator. For 'sample' and 'linear' modes, 'data': array-like must be provided
+            for sampling/PCA.
+        """
+        modes: dict[str, Callable[..., None]] = {
+            "random": self._weight_initialization_random,
+            "linear": self._weight_initialization_linear,
+            "sample": self._weight_initialization_sample,
+        }
         try:
             modes[mode](**kwargs)
-        except KeyError:
-            raise ValueError("Invalid value for 'mode' parameter. Value should be in " + str(modes.keys()))
+        except KeyError as exc:
+            raise ValueError(
+                "Invalid value for 'mode' parameter. Value should be in "
+                + str(modes.keys())
+            ) from exc
 
-    def _weight_initialization_random(self, sample_mode: str = 'standard_normal',
-                                      random_seed: Union[int, None] = None) -> None:
-        """
-        Random initialization method. Assigns weights from a random distribution defined by 'sample_mode'.
+    def _weight_initialization_random(
+        self, sample_mode: str = "standard_normal", random_seed: int | None = None
+    ) -> None:
+        """Random initialization method.
 
-        :param sample_mode: str: Distribution for random sampling. May be either 'uniform' or 'standard_normal'.
+        Assigns weights from a random distribution defined by 'sample_mode'.
+
+        :param sample_mode: str: Distribution for random sampling.
+            May be either 'uniform' or 'standard_normal'.
             Defaults to 'standard_normal'.
         :param random_seed: int or None: Seed for NumPy random value generator. Defaults to None.
         """
-        sample_modes = {'uniform': np.random.random, 'standard_normal': np.random.standard_normal}
+        sample_modes = {
+            "uniform": np.random.random,
+            "standard_normal": np.random.standard_normal,
+        }
 
         # Seed numpy random generator
         if random_seed is None:
-            random_seed = np.random.randint(
-                np.random.randint(np.iinfo(np.int32).max))
+            random_seed = np.random.randint(np.iinfo(np.int32).max)
         else:
-            random_seed = np.int(random_seed)
+            random_seed = int(random_seed)
         np.random.seed(random_seed)
 
         # Initialize weights randomly
         try:
             self._weights = sample_modes[sample_mode](size=self._weights.shape)
-        except KeyError:
+        except KeyError as exc:
             raise ValueError(
-                "Invalid value for 'sample_mode' parameter. Value should be in " + str(sample_modes.keys()))
+                "Invalid value for 'sample_mode' parameter. Value should be in "
+                + str(sample_modes.keys())
+            ) from exc
 
-    def _weight_initialization_linear(self, data: Union[np.ndarray, pd.DataFrame, list]) -> None:
-        """
-        Linear initialization method. Assigns weights spanning the hyperplane formed by the two first principal
+    def _weight_initialization_linear(
+        self, data: np.ndarray | pd.DataFrame | list
+    ) -> None:
+        """Linear initialization method.
+
+        Assigns weights spanning the hyperplane formed by the two first principal
         components of 'data'.
 
-        This is the recommended initialization method, as it may lead to a faster convergence. Unlike other
-        initialization modes, this method is deterministic based on the input dataset.
+        This is the recommended initialization method, as it may lead to a faster convergence.
+        Unlike other initialization modes, this method is deterministic based on the input dataset.
 
         :param data: array-like: Dataset for weight initialization w/ PCA.
         """
         # Convert data to numpy array for training
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
+        data_array = self._data_to_numpy(data)
 
         # Perform PCA w/ sklearn
         data_array = sklearn.preprocessing.StandardScaler().fit_transform(data_array)
@@ -548,37 +725,40 @@ class SOM:
         # Initialize weights spanning first 2 principal components of data
         for i, c1 in enumerate(np.linspace(-1, 1, num=self._shape[0])):
             for j, c2 in enumerate(np.linspace(-1, 1, num=self._shape[1])):
-                self._weights[i, j] = c1 * pca.explained_variance_[0] + c2 * pca.explained_variance_[1]
-
-    def _weight_initialization_sample(self, data: Union[np.ndarray, pd.DataFrame, list],
-                                      random_seed: Union[int, None] = None) -> None:
-        """
-        Initialization method. Assigns weights to random samples from an input dataset.
+                self._weights[i, j] = (
+                    c1 * pca.explained_variance_[0] + c2 * pca.explained_variance_[1]
+                )
+
+    def _weight_initialization_sample(
+        self,
+        data: np.ndarray | pd.DataFrame | list,
+        random_seed: int | None = None,
+    ) -> None:
+        """Initialization method. Assigns weights to random samples from an input dataset.
 
         :param data: Dataset for weight initialization/sampling.
         :param random_seed: int or None: Seed for NumPy random value generator. Defaults to None.
         """
         # Seed numpy random generator
         if random_seed is None:
-            random_seed = np.random.randint(
-                np.random.randint(np.iinfo(np.int32).max))
+            random_seed = np.random.randint(np.iinfo(np.int32).max)
         else:
-            random_seed = np.int(random_seed)
+            random_seed = int(random_seed)
         np.random.seed(random_seed)
 
         # Convert data to numpy array for training
-        if isinstance(data, pd.DataFrame):
-            data_array = data.to_numpy()
-        else:
-            data_array = np.array(data)
+        data_array = self._data_to_numpy(data)
 
         # Assign weights to random samples from dataset
-        sample_size = self._shape[0] * self._shape[1]
-        sample = np.random.choice(len(data_array), size=sample_size,
-                                  replace=(sample_size > len(data_array)))
+        sample_size: np.uint = self._shape[0] * self._shape[1]
+        sample = np.random.choice(
+            len(data_array),
+            size=int(sample_size),
+            replace=bool(sample_size > len(data_array)),
+        )
         self._weights = data_array[sample].reshape(self._weights.shape)
 
-    def _gaussian(self, c: Tuple[int, int], sigma: float) -> np.ndarray:
+    def _gaussian(self, c: tuple[int, ...], sigma: float) -> np.ndarray:
         """
         Gaussian neighborhood function, centered in c. Has support for cyclic arrays.
 
@@ -601,12 +781,12 @@ class SOM:
         ay = np.exp(-np.power(dy, 2) / d)
         return np.outer(ax, ay)
 
-    def _bubble(self, c: Tuple[int, int], sigma: float) -> np.ndarray:
+    def _bubble(self, c: tuple[int, ...], sigma: float) -> np.ndarray:
         """
         Bubble neighborhood function, centered in c. Has support for cyclic arrays.
 
-        The neighbors of c are the nodes in the region of sigma positions in the vertical and horizontal directions
-        around c.
+        The neighbors of c are the nodes in the region of sigma positions in the vertical
+        and horizontal directions around c.
 
         :param c: (int, int): Center coordinates for gaussian function.
         :param sigma: float: Spread variable for gaussian function.
@@ -622,13 +802,24 @@ class SOM:
         # Calculate cyclic regions
         if self._cyclic[0]:
             if c[0] - sigma < 0:
-                ax[int(c[0] - sigma):] = True
+                ax[int(c[0] - sigma) :] = True
             if c[0] + sigma >= self._shape[0]:
-                ax[:int((c[0] + sigma) % self._shape[0] + 1)] = True
+                ax[: int((c[0] + sigma) % self._shape[0] + 1)] = True
         if self._cyclic[1]:
             if c[1] - sigma < 0:
-                ay[int(c[1] - sigma):] = True
+                ay[int(c[1] - sigma) :] = True
             if c[1] + sigma >= self._shape[1]:
-                ay[:int((c[1] + sigma) % self._shape[1] + 1)] = True
+                ay[: int((c[1] + sigma) % self._shape[1] + 1)] = True
 
         return np.outer(ax, ay).astype(int)
+
+    def _data_to_numpy(self, data: np.ndarray | pd.DataFrame | list) -> np.ndarray:
+        """
+        Converts data to numpy array.
+
+        :param data: array-like: Dataset for training.
+        :return: np.ndarray: Numpy array of the dataset.
+        """
+        if isinstance(data, pd.DataFrame):
+            return data.to_numpy()
+        return np.array(data)

{python_som-0.0.1a1.dist-info → python_som-0.1.1.dist-info}/METADATA

@@ -1,28 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-som
-Version: 0.0.1a1
+Version: 0.1.1
 Summary: Python implementation of the Self-Organizing Map
-Home-page: https://github.com/andremsouza/python-som
-Author: André Moreira Souza
-Author-email: msouza.andre@hotmail.com
-License: MIT
-Project-URL: Bug Reports, https://github.com/andremsouza/python-som/issues
-Project-URL: Source, https://github.com/andremsouza/python-som
-Keywords: som kohonen-map self-organizing-map machine-learning
+Project-URL: Homepage, https://github.com/andremsouza/python-som
+Project-URL: Issues, https://github.com/andremsouza/python-som/issues
+Author-email: André Moreira Souza <msouza.andre@hotmail.com>
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pandas
-Requires-Dist: scikit-learn
 
 # python-som
 
@@ -144,4 +139,4 @@ Volume 37,
 2013,
 Pages 52-65,
 ISSN 0893-6080,
-https://doi.org/10.1016/j.neunet.2012.09.018.
+https://doi.org/10.1016/j.neunet.2012.09.018.

python_som-0.1.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+python_som/__init__.py,sha256=MMEdaZxLE5MQsrmjYWhwQcC3Nj47QRLlPTtRiOJiSa8,33022
+python_som-0.1.1.dist-info/METADATA,sha256=YyBET88cyw79ltVyrYUNXOagJpdjgaYaw8ii6RhcyLM,4957
+python_som-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_som-0.1.1.dist-info/licenses/LICENSE,sha256=dMZQho8iIicWbAJQk1QaAXXvvJlaWSQ3a-9NkWxu_lc,1077
+python_som-0.1.1.dist-info/RECORD,,

{python_som-0.0.1a1.dist-info → python_som-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

python_som-0.0.1a1.dist-info/RECORD

@@ -1,6 +0,0 @@
-python_som/__init__.py,sha256=1s6ryY2Og0N9MnX98lk6TaCTogan6d3Dhwc3fX5R5gg,29200
-python_som-0.0.1a1.dist-info/LICENSE,sha256=dMZQho8iIicWbAJQk1QaAXXvvJlaWSQ3a-9NkWxu_lc,1077
-python_som-0.0.1a1.dist-info/METADATA,sha256=QGrBTJ2eWkQU_4TKxsGZGhw1qlVslZPwr3UF_Ok4lSw,5096
-python_som-0.0.1a1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-python_som-0.0.1a1.dist-info/top_level.txt,sha256=__rpeARBlUvNEMA9BWjqS7nbMeb_3JUR_QQndHHo5Mk,11
-python_som-0.0.1a1.dist-info/RECORD,,

python_som-0.0.1a1.dist-info/top_level.txt

@@ -1 +0,0 @@
-python_som