aisp 0.1.42__py3-none-any.whl → 0.2.1__py3-none-any.whl

aisp/base/_classifier.py

@@ -16,10 +16,10 @@ class BaseClassifier(ABC):
     ``get_params`` method.
     """
 
-    classes: Optional[Union[npt.NDArray, list]] = None
+    classes: Union[npt.NDArray, list] = []
 
     @abstractmethod
-    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True):
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "BaseClassifier":
         """
         Train the model using the input data X and corresponding labels y.
 
@@ -83,6 +83,10 @@ class BaseClassifier(ABC):
         if len(y) == 0:
             return 0
         y_pred = self.predict(X)
+
+        if y_pred is None:
+            return 0
+
         return accuracy_score(y, y_pred)
 
     def _slice_index_list_by_class(self, y: npt.NDArray) -> dict:

aisp/base/mutation.py

@@ -0,0 +1,130 @@
+"""
+The functions perform utilize Numba decorators for Just-In-Time compilation.
+
+Contains functions that generate sets of mutated clones from continuous or binary vectors,
+simulating the clonal expansion process in artificial immune systems.
+"""
+
+import numpy as np
+import numpy.typing as npt
+from numba import njit, types
+
+
+@njit([(types.float64[:], types.int64)], cache=True)
+def clone_and_mutate_continuous(
+    vector: npt.NDArray[np.float64],
+    n: int
+) -> npt.NDArray[np.float64]:
+    """
+    Generate a set of mutated clones from a cell represented by a continuous vector.
+
+    This function creates `n` clones of the input vector and applies random mutations to each of
+    them, simulating the process of clonal expansion in artificial immune systems. Each clone
+    will have a random number of mutations applied in distinct positions of the original vector.
+
+    Parameters
+    ----------
+    vector : npt.NDArray[np.float64]
+        The original immune cell with continuous values to be cloned and mutated.
+    n : int
+        The number of mutated clones to be generated.
+
+    Returns
+    -------
+    clone_set : npt.NDArray
+        An Array(n, len(vector)) containing the `n` mutated clones of the original vector.
+    """
+    n_features = vector.shape[0]
+    clone_set = np.empty((n, n_features), dtype=np.float64)
+    for i in range(n):
+        n_mutations = np.random.randint(1, n_features)
+        clone = vector.copy()
+        position_mutations = np.random.permutation(n_features)[:n_mutations]
+        for j in range(n_mutations):
+            idx = position_mutations[j]
+            clone[idx] = np.float64(np.random.random())
+        clone_set[i] = clone
+
+    return clone_set
+
+
+@njit([(types.boolean[:], types.int64)], cache=True)
+def clone_and_mutate_binary(
+    vector: npt.NDArray[np.bool_],
+    n: int
+) -> npt.NDArray[np.bool_]:
+    """
+    Generate a set of mutated clones from a cell represented by a binary vector.
+
+    This function creates `n` clones of the input vector and applies random mutations to each of
+    them, changing some bits randomly. The process simulates clonal expansion in artificial
+    immune systems with discrete representations.
+
+    Parameters
+    ----------
+    vector : npt.NDArray[np.bool_]
+        The original immune cell with binary values to be cloned and mutated.
+    n : int
+        The number of mutated clones to be generated.
+
+    Returns
+    -------
+    clone_set : npt.NDArray[np.bool_]
+        An Array(n, len(vector)) containing the `n` mutated clones of the original vector.
+    """
+    n_features = vector.shape[0]
+    clone_set = np.empty((n, n_features), dtype=np.bool_)
+    for i in range(n):
+        n_mutations = np.random.randint(1, n_features)
+        clone = vector.copy()
+        position_mutations = np.random.permutation(n_features)[:n_mutations]
+        for j in range(n_mutations):
+            idx = position_mutations[j]
+            clone[idx] = np.bool_(np.random.randint(0, 2))
+        clone_set[i] = clone
+
+    return clone_set
+
+
+@njit([(types.float64[:], types.int64, types.float64[:, :])], cache=True)
+def clone_and_mutate_ranged(
+    vector: npt.NDArray[np.float64],
+    n: int,
+    bounds: npt.NDArray[np.float64]
+) -> npt.NDArray[np.float64]:
+    """
+    Generate a set of mutated clones from a cell represented by custom ranges per dimension.
+
+    This function creates `n` clones of the input vector and applies random mutations to each of
+    them, simulating the process of clonal expansion in artificial immune systems. Each clone
+    will have a random number of mutations applied in distinct positions of the original vector.
+
+    Parameters
+    ----------
+    vector : npt.NDArray[np.bool_]
+        The original immune cell with binary values to be cloned and mutated.
+    n : int
+        The number of mutated clones to be generated.
+    bounds : np.ndarray
+        Array (n_features, 2) with min and max per dimension.
+
+    Returns
+    -------
+    clone_set : npt.NDArray
+        An Array(n, len(vector)) containing the `n` mutated clones of the original vector.
+    """
+    n_features = vector.shape[0]
+    clone_set = np.empty((n, n_features), dtype=np.float64)
+
+    for i in range(n):
+        n_mutations = np.random.randint(1, n_features)
+        clone = vector.copy()
+        position_mutations = np.random.permutation(n_features)[:n_mutations]
+        for j in range(n_mutations):
+            idx = position_mutations[j]
+            min_limit = bounds[idx, 0]
+            max_limit = bounds[idx, 1]
+            clone[idx] = np.random.uniform(min_limit, max_limit)
+        clone_set[i] = clone
+
+    return clone_set

aisp/csa/__init__.py

@@ -0,0 +1,9 @@
+"""Module (CSA) Clonal Selection Algorithm.
+
+CSAs are inspired by the process of antibody proliferation upon detecting an antigen, during which
+the generated antibodies undergo mutations in an attempt to enhance pathogen recognition.
+"""
+from ._ai_immune_recognition_sys import AIRS
+
+__author__ = 'João Paulo da Silva Barros'
+__all__ = ['AIRS']

aisp/csa/_ai_immune_recognition_sys.py

@@ -0,0 +1,498 @@
+"""Artificial Immune Recognition System (AIRS)."""
+
+import random
+from collections import Counter
+from heapq import nlargest
+from operator import attrgetter
+from typing import List, Optional, Dict
+
+import numpy as np
+import numpy.typing as npt
+from scipy.spatial.distance import pdist
+from tqdm import tqdm
+
+
+from ._cell import Cell
+from ..utils.sanitizers import sanitize_param, sanitize_seed, sanitize_choice
+from ..utils.distance import hamming, compute_metric_distance, get_metric_code
+from ..utils.types import FeatureType, MetricType
+from ..utils.validation import detect_vector_data_type
+from ._base import BaseAIRS
+
+
+class _ARB(Cell):
+    """ARB (Artificial recognition ball).
+
+    Individual from the set of recognizing cells (ARB), inherits characteristics from a B-cell,
+    adding resource consumption
+
+    Parameters
+    ----------
+    vector : npt.NDArray
+        A vector of cell features.
+    stimulation : Optional[float], default=None
+        The rate at which the cell stimulates antigens.
+    """
+
+    def __init__(
+        self,
+        vector: npt.NDArray,
+        stimulation: Optional[float] = None
+    ) -> None:
+        super().__init__(vector)
+        self.resource: float = 0.0
+        if stimulation is not None:
+            self.stimulation: float = stimulation
+
+    def consume_resource(self, n_resource: float, amplified: float = 1) -> float:
+        """
+        Update the amount of resources available for an ARB after consumption.
+
+        This function consumes the resources and returns the remaining amount of resources after
+        consumption.
+
+        Parameters
+        ----------
+        n_resource : float
+            Amount of resources.
+        amplified : float
+            Amplifier for the resource consumption by the cell. It is multiplied by the cell's
+            stimulus. The default value is 1.
+
+        Returns
+        -------
+        n_resource : float
+            The remaining amount of resources after consumption.
+        """
+        consumption = self.stimulation * amplified
+        n_resource -= consumption
+        if n_resource < 0:
+            return 0
+
+        self.resource = consumption
+        return n_resource
+
+    def to_cell(self) -> Cell:
+        """Convert this _ARB into a pure Cell object."""
+        return Cell(self.vector)
+
+
+class AIRS(BaseAIRS):
+    """Artificial Immune Recognition System (AIRS).
+
+    The Artificial Immune Recognition System (AIRS) is a classification algorithm inspired by the
+    clonal selection process of the biological immune system. This implementation is based on the
+    simplified AIRS2 version described in [1]_. The algorithm has been adapted to support both
+    real-valued (continuous) and binary feature datasets.
+
+    Parameters
+    ----------
+    n_resources : float, default=10
+            Total amount of available resources.
+    rate_clonal : float, default=10
+        Maximum number of possible clones of a class. This quantity is multiplied by (
+        cell_stimulus * rate_hypermutation) to define the number of clones.
+    rate_mc_init : float, default=0.2
+            Percentage of samples used to initialize memory cells.
+    rate_hypermutation : float, default=0.75
+            The rate of mutated clones derived from rate_clonal as a scalar factor.
+    affinity_threshold_scalar : float, default=0.75
+            Normalized affinity threshold.
+    k : int, default=3
+        The number of K nearest neighbors that will be used to choose a label in the prediction.
+    max_iters : int, default=100
+        Maximum number of interactions in the refinement process of the ARB set exposed to aᵢ.
+    resource_amplified : float, default=1.0
+        Resource consumption amplifier is multiplied with the incentive to subtract resources.
+        Defaults to 1.0 without amplification.
+    metric : Literal["manhattan", "minkowski", "euclidean"], default="euclidean"
+        Way to calculate the distance between the detector and the sample:
+
+        * ``'Euclidean'`` ➜ The calculation of the distance is given by the expression:
+            √( (x₁ – x₂)² + (y₁ – y₂)² + ... + (yn – yn)²).
+
+        * ``'minkowski'`` ➜ The calculation of the distance is given by the expression:
+            ( |X₁ – Y₁|p + |X₂ – Y₂|p + ... + |Xn – Yn|p) ¹/ₚ.
+
+        * ``'manhattan'`` ➜ The calculation of the distance is given by the expression:
+            ( |x₁ – x₂| + |y₁ – y₂| + ... + |yn – yn|).
+
+    seed : int
+        Seed for the random generation of detector values. Defaults to None.
+
+    **kwargs
+        p : float
+            This parameter stores the value of ``p`` used in the Minkowski distance. The default
+            is ``2``, which represents normalized Euclidean distance.\
+            Different values of p lead to different variants of the Minkowski Distance.
+
+    Notes
+    -----
+    This implementation is inspired by AIRS2, a simplified version of the original AIRS algorithm.
+    Introducing adaptations to handle continuous and binary datasets.
+
+    Based on Algorithm 16.5 from Brabazon et al. [1]_.
+
+    Related and noteworthy works: access here [2]_.
+
+    References
+    ----------
+    .. [1] Brabazon, A., O’Neill, M., & McGarraghy, S. (2015). Natural Computing Algorithms. In
+        Natural Computing Series. Springer Berlin Heidelberg.
+        https://doi.org/10.1007/978-3-662-43631-8
+
+    .. [2] AZZOUG, Aghiles. Artificial Immune Recognition System V2.
+        Available at: https://github.com/AghilesAzzoug/Artificial-Immune-System
+    """
+
+    def __init__(
+        self,
+        n_resources: float = 10,
+        rate_clonal: int = 10,
+        rate_mc_init: float = 0.2,
+        rate_hypermutation: float = 0.75,
+        affinity_threshold_scalar: float = 0.75,
+        k: int = 3,
+        max_iters: int = 100,
+        resource_amplified: float = 1.0,
+        metric: MetricType = "euclidean",
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        self.n_resources: float = sanitize_param(n_resources, 10, lambda x: x >= 1)
+        self.rate_mc_init: float = sanitize_param(
+            rate_mc_init, 0.2, lambda x: 0 < x <= 1
+        )
+        self.rate_clonal: int = sanitize_param(rate_clonal, 10, lambda x: x > 0)
+        self.rate_hypermutation: float = sanitize_param(
+            rate_hypermutation, 0.75, lambda x: x > 0
+        )
+        self.affinity_threshold_scalar: float = sanitize_param(
+            affinity_threshold_scalar, 0.75, lambda x: x > 0
+        )
+        self.resource_amplified: float = sanitize_param(
+            resource_amplified, 1, lambda x: x > 1
+        )
+        self.k: int = sanitize_param(k, 3, lambda x: x > 3)
+        self.max_iters: int = sanitize_param(max_iters, 100, lambda x: x > 0)
+        self.seed: Optional[int] = sanitize_seed(seed)
+        if self.seed is not None:
+            np.random.seed(self.seed)
+
+        self._feature_type: FeatureType = "continuous-features"
+
+        self.metric = sanitize_choice(
+            metric, ["manhattan", "minkowski"], "euclidean"
+        )
+
+        self.p: np.float64 = np.float64(kwargs.get("p", 2.0))
+
+        self._cells_memory = None
+        self.affinity_threshold = 0.0
+        self.classes = []
+        self._bounds: Optional[npt.NDArray[np.float64]] = None
+
+    @property
+    def cells_memory(self) -> Optional[Dict[str, list[Cell]]]:
+        """Returns the trained cells memory, organized by class."""
+        return self._cells_memory
+
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "AIRS":
+        """
+        Fit the model to the training data using the AIRS.
+
+        The function ``fit(...)``, performs the training according to ``X`` and ``y``, using the
+        method AIRS.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Training array, containing the samples and their characteristics,
+            [``N samples`` (rows)][``N features`` (columns)].
+        y : npt.NDArray
+            Array of target classes of ``X`` with [``N samples`` (lines)].
+        verbose : bool
+            Feedback on which sample aᵢ the memory cells are being generated.
+
+        Returns
+        -------
+        AIRS
+            Returns the instance itself.
+        """
+        progress = None
+
+        self._feature_type = detect_vector_data_type(X)
+
+        super()._check_and_raise_exceptions_fit(X, y)
+
+        match self._feature_type:
+            case "binary-features":
+                X = X.astype(np.bool_)
+                self.metric = "hamming"
+            case "ranged-features":
+                self._bounds = np.vstack([np.min(X, axis=0), np.max(X, axis=0)])
+
+        self.classes = np.unique(y)
+        sample_index = self._slice_index_list_by_class(y)
+        if verbose:
+            progress = tqdm(
+                total=len(y),
+                postfix="\n",
+                bar_format="{desc} ┇{bar}┇ {n}/{total} memory cells for each aᵢ",
+            )
+        pool_cells_classes = {}
+        for _class_ in self.classes:
+            if verbose and progress is not None:
+                progress.set_description_str(
+                    f"Generating the memory cells for the {_class_} class:"
+                )
+
+            x_class = X[sample_index[_class_]]
+            # Calculating the similarity threshold between antigens
+            self._cells_affinity_threshold(x_class)
+            sufficiently_similar = (
+                self.affinity_threshold * self.affinity_threshold_scalar
+            )
+            # Initialize memory cells for a class.
+            pool_c: list[Cell] = self._init_memory_c(x_class)
+
+            for ai in x_class:
+                # Calculating the stimulation of memory cells with aᵢ and selecting the largest
+                # stimulation from the memory set.
+                c_match = pool_c[0]
+                match_stimulation = -1
+                for cell in pool_c:
+                    stimulation = self._affinity(cell.vector, ai)
+                    if stimulation > match_stimulation:
+                        match_stimulation = stimulation
+                        c_match = cell
+
+                arb_list: list[_ARB] = [
+                    _ARB(
+                        vector=c_match.vector,
+                        stimulation=match_stimulation
+                    )
+                ]
+
+                set_clones: npt.NDArray = c_match.hyper_clonal_mutate(
+                    int(self.rate_hypermutation * self.rate_clonal * match_stimulation),
+                    self._feature_type
+                )
+
+                for clone in set_clones:
+                    arb_list.append(
+                        _ARB(
+                            vector=clone,
+                            stimulation=self._affinity(clone, ai),
+                        )
+                    )
+
+                c_candidate = self._refinement_arb(ai, match_stimulation, arb_list)
+
+                if c_candidate.stimulation > match_stimulation:
+                    pool_c.append(c_candidate.to_cell())
+                    if self._affinity(c_candidate.vector, c_match.vector) < sufficiently_similar:
+                        pool_c.remove(c_match)
+
+                if verbose and progress is not None:
+                    progress.update(1)
+            pool_cells_classes[_class_] = pool_c
+
+        if verbose and progress is not None:
+            progress.set_description(
+                f"\033[92m✔ Set of memory cells for classes ({', '.join(map(str, self.classes))}) "
+                f"successfully generated\033[0m"
+            )
+        self._cells_memory = pool_cells_classes
+        return self
+
+    def predict(self, X: npt.NDArray) -> Optional[npt.NDArray]:
+        """
+        Predict class labels based on the memory cells created during training.
+
+        This method uses the trained memory cells to perform classification of the input data
+        using the k-nearest neighbors approach.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Array with input samples with [``N samples`` (Lines)] and [``N characteristics``(
+            Columns)]
+
+        Returns
+        -------
+        C : npt.NDArray or None
+            An ndarray of the form ``C`` [``N samples``], containing the predicted classes for
+            ``X``. or ``None``: If there are no detectors for the prediction.
+        """
+        if self._cells_memory is None:
+            return None
+
+        super()._check_and_raise_exceptions_predict(
+            X, len(self._cells_memory[self.classes[0]][0].vector), self._feature_type
+        )
+
+        c: list = []
+
+        all_cells_memory = [
+            (class_name, cell.vector)
+            for class_name in self.classes
+            for cell in self._cells_memory[class_name]
+        ]
+
+        for line in X:
+            label_stim_list = [
+                (class_name, self._affinity(memory, line))
+                for class_name, memory in all_cells_memory
+            ]
+            # Create the list with the k nearest neighbors and select the class with the most votes
+            k_nearest = nlargest(self.k, label_stim_list, key=lambda x: x[1])
+            votes = Counter(label for label, _ in k_nearest)
+            c.append(votes.most_common(1)[0][0])
+        return np.array(c)
+
+    def _refinement_arb(
+        self, ai: npt.NDArray, c_match_stimulation: float, arb_list: List[_ARB]
+    ) -> _ARB:
+        """
+        Refine the ARB set until the average stimulation exceeds the defined threshold.
+
+        This method iteratively refines the ARB set by comparing the average stimulation
+        against the `affinity_threshold_scalar`. Refinement continues through multiple iterations
+        until the threshold is met or exceeded.
+
+        Parameters
+        ----------
+        ai : npt.NDArray
+            The current antigen.
+        c_match_stimulation : float
+            The highest stimulation relative to aᵢ
+        arb_list : List[_ARB]
+            ARB set.
+
+        Returns
+        -------
+        _ARB
+            The cell with the highest ARB stimulation
+
+        Notes
+        -----
+        Based on Algorithm 16.6 from Brabazon et al. [1]_.
+
+        References
+        ----------
+        .. [1] Brabazon, A., O’Neill, M., & McGarraghy, S. (2015).
+                Natural Computing Algorithms. Natural Computing Series.
+                Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-43631-8
+        """
+        iters = 0
+        while True:
+            iters += 1
+            arb_list.sort(key=attrgetter("stimulation"), reverse=True)
+            resource = self.n_resources
+            for arb in arb_list:
+                resource = arb.consume_resource(
+                    n_resource=resource, amplified=self.resource_amplified
+                )
+                if resource == 0:
+                    break
+            # remove cells without resources and calculate the average ARB stimulus.
+            arb_list = [cell for cell in arb_list if cell.resource > 0]
+            if not arb_list:
+                break
+            avg_stimulation = sum(item.stimulation for item in arb_list) / len(arb_list)
+
+            if iters == self.max_iters or avg_stimulation > self.affinity_threshold:
+                break
+
+            # pick a random cell for mutations.
+            random_index = random.randint(0, len(arb_list) - 1)
+            clone_arb = arb_list[random_index].hyper_clonal_mutate(
+                int(self.rate_clonal * c_match_stimulation),
+                self._feature_type
+            )
+
+            arb_list = [
+                _ARB(
+                    vector=clone,
+                    stimulation=self._affinity(clone, ai)
+                )
+                for clone in clone_arb
+            ]
+
+        return max(arb_list, key=attrgetter("stimulation"))
+
+    def _cells_affinity_threshold(self, antigens_list: npt.NDArray):
+        """
+        Calculate the affinity threshold based on the average affinity between training instances.
+
+        This function calculates the affinity threshold based on the average affinity between
+        training instances, where aᵢ and aⱼ are a pair of antigens, and affinity
+        is measured by distance (Euclidean, Manhattan, Minkowski, Hamming).
+        Following the formula:
+
+        > affinity_threshold = (Σᵢ=₁ⁿ⁻¹ Σⱼ=ᵢ₊₁ⁿ affinity(aᵢ, aⱼ)) / (n(n-1)/2
+
+        Parameters
+        ----------
+        antigens_list : npt.NDArray
+            List of training antigens.
+        """
+        if self._feature_type == "binary-features":
+            distances = pdist(antigens_list, metric="hamming")
+        else:
+            metric_kwargs = {'p': self.p} if self.metric == 'minkowski' else {}
+            distances = pdist(antigens_list, metric=self.metric, **metric_kwargs)
+
+        n = antigens_list.shape[0]
+        sum_affinity = np.sum(1.0 - (distances / (1.0 + distances)))
+        self.affinity_threshold = 1.0 - (sum_affinity / ((n * (n - 1)) / 2))
+
+    def _affinity(self, u: npt.NDArray, v: npt.NDArray) -> float:
+        """
+        Calculate the stimulus between two vectors using metrics.
+
+        Parameters
+        ----------
+        u : npt.NDArray
+            Coordinates of the first point.
+        v : npt.NDArray
+            Coordinates of the second point.
+
+        Returns
+        -------
+        float
+            The stimulus rate between the vectors.
+        """
+        distance: float
+        if self._feature_type == "binary-features":
+            distance = hamming(u, v)
+        else:
+            distance = compute_metric_distance(
+                u, v, get_metric_code(self.metric), self.p
+            )
+        return 1 - (distance / (1 + distance))
+
+    def _init_memory_c(self, antigens_list: npt.NDArray) -> List[Cell]:
+        """
+        Initialize memory cells by randomly selecting `rate_mc_init` antigens.
+
+        Parameters
+        ----------
+        antigens_list : npt.NDArray
+            List of training antigens.
+
+        Returns
+        -------
+        List[Cell]
+            List of initialized memories.
+        """
+        n = antigens_list.shape[0]
+        n_cells = int(n * self.rate_mc_init)
+
+        if n == 0 or n_cells == 0:
+            return []
+
+        permutation = np.random.permutation(n)
+        selected = antigens_list[permutation[:n_cells]]
+        return [Cell(ai) for ai in selected]

aisp/csa/_base.py

@@ -0,0 +1,104 @@
+"""Base Class for Clonal Selection Algorithm."""
+
+from abc import ABC
+
+import numpy as np
+import numpy.typing as npt
+
+from ..exceptions import FeatureDimensionMismatch
+from ..utils.types import FeatureType
+from ..base import BaseClassifier
+
+
+class BaseAIRS(BaseClassifier, ABC):
+    """
+    Base class for algorithm AIRS.
+
+    The base class contains functions that are used by more than one class in the package, and
+    therefore are considered essential for the overall functioning of the system.
+    """
+
+    @staticmethod
+    def _check_and_raise_exceptions_fit(
+        X: npt.NDArray,
+        y: npt.NDArray
+    ):
+        """
+        Verify the fit parameters and throw exceptions if the verification is not successful.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Training array, containing the samples and their characteristics,
+            [``N samples`` (rows)][``N features`` (columns)].
+        y : npt.NDArray
+            Array of target classes of ``X`` with [``N samples`` (lines)].
+
+        Raises
+        ------
+        TypeError:
+            If X or y are not ndarrays or have incompatible shapes.
+        """
+        if not isinstance(X, np.ndarray):
+            if isinstance(X, list):
+                X = np.array(X)
+            else:
+                raise TypeError("X is not an ndarray or list.")
+        elif not isinstance(y, np.ndarray):
+            if isinstance(y, list):
+                y = np.array(y)
+            else:
+                raise TypeError("y is not an ndarray or list.")
+        if X.shape[0] != y.shape[0]:
+            raise TypeError(
+                "X does not have the same amount of sample for the output classes in y."
+            )
+
+
+    @staticmethod
+    def _check_and_raise_exceptions_predict(
+        X: npt.NDArray,
+        expected: int = 0,
+        feature_type: FeatureType = "continuous-features"
+    ) -> None:
+        """
+        Verify the predict parameters and throw exceptions if the verification is not successful.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input array for prediction, containing the samples and their characteristics,
+            [``N samples`` (rows)][``N features`` (columns)].
+        expected : int, default=0
+            Expected number of features per sample (columns in X).
+        feature_type : FeatureType, default="continuous-features"
+            Specifies the type of feature_type to use, depending on whether the input data has
+            continuous or binary features.
+
+        Raises
+        ------
+        TypeError
+            If X is not a ndarray or list.
+        FeatureDimensionMismatch
+            If the number of features in X does not match the expected number.
+        ValueError
+            If feature_type is binary-features and X contains values that are not composed only
+            of 0 and 1.
+        """
+        if not isinstance(X, (np.ndarray, list)):
+            raise TypeError("X is not an ndarray or list")
+        if expected != len(X[0]):
+            raise FeatureDimensionMismatch(
+                expected,
+                len(X[0]),
+                "X"
+            )
+
+        if feature_type != "binary-features":
+            return
+
+        # Checks if matrix X contains only binary samples. Otherwise, raises an exception.
+        if not np.isin(X, [0, 1]).all():
+            raise ValueError(
+                "The array X contains values that are not composed only of 0 and 1."
+            )

aisp/csa/_cell.py

@@ -0,0 +1,61 @@
+"""Represents a memory B-cell."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+import numpy as np
+import numpy.typing as npt
+
+from ..base.mutation import (
+    clone_and_mutate_continuous,
+    clone_and_mutate_binary,
+    clone_and_mutate_ranged
+)
+from ..utils.types import FeatureType
+
+
+@dataclass(slots=True)
+class Cell:
+    """
+    Represents a memory B-cell.
+
+    Attributes
+    ----------
+    vector : npt.NDArray
+        A vector of cell features.
+    """
+
+    vector: np.ndarray
+
+    def hyper_clonal_mutate(
+        self,
+        n: int,
+        feature_type: FeatureType = "continuous-features",
+        bounds: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray:
+        """
+        Clones N features from a cell's features, generating a set of mutated vectors.
+
+        Parameters
+        ----------
+        n : int
+            Number of clones to be generated from mutations of the original cell.
+        feature_type : Literal["binary-features", "continuous-features", "ranged-features"]
+            Specifies the type of feature_type to use based on the nature of the input features
+        bounds : np.ndarray
+            Array (n_features, 2) with min and max per dimension.
+
+        Returns
+        -------
+        npt.NDArray
+            An array containing N mutated vectors from the original cell.
+        """
+        if feature_type == "binary-features":
+            return clone_and_mutate_binary(self.vector, n)
+        if feature_type == "ranged-features" and bounds is not None:
+            clone_and_mutate_ranged(self.vector, n, bounds)
+        return clone_and_mutate_continuous(self.vector, n)
+
+    def __eq__(self, other):
+        """Check if two cells are equal."""
+        return np.array_equal(self.vector, other.vector)

aisp/exceptions.py

@@ -1,5 +1,7 @@
 """Custom warnings and errors."""
 
+from typing import Optional
+
 
 class MaxDiscardsReachedError(Exception):
     """Exception thrown when the maximum number of detector discards is reached."""
@@ -27,7 +29,7 @@ class FeatureDimensionMismatch(Exception):
         self,
         expected: int,
         received: int,
-        variable_name: str = None
+        variable_name: Optional[str] = None
     ):
         parts = []
         if variable_name:
@@ -41,3 +43,17 @@ class FeatureDimensionMismatch(Exception):
             "and matches the expected shape for the model."
         )
         super().__init__(message)
+
+
+class UnsupportedTypeError(Exception):
+    """
+    Exception raised when the input vector type is not supported.
+
+    This exception is thrown when the vector data type does not match any of the supported.
+    """
+
+    def __init__(self, message=None):
+        if message is None:
+            message = ("Type is not supported. Provide a binary, normalized, or bounded "
+                       "continuous vector.")
+        super().__init__(message)

aisp/nsa/_base.py

@@ -20,8 +20,8 @@ class BaseNSA(BaseClassifier, ABC):
 
     @staticmethod
     def _check_and_raise_exceptions_fit(
-        X: npt.NDArray = None,
-        y: npt.NDArray = None,
+        X: npt.NDArray,
+        y: npt.NDArray,
         _class_: Literal["RNSA", "BNSA"] = "RNSA",
     ) -> None:
         """Verify fit function parameters.
@@ -67,7 +67,7 @@ class BaseNSA(BaseClassifier, ABC):
 
     @staticmethod
     def _check_and_raise_exceptions_predict(
-        X: npt.NDArray = None,
+        X: npt.NDArray,
         expected: int = 0,
         _class_: Literal["RNSA", "BNSA"] = "RNSA",
     ) -> None:

aisp/nsa/_negative_selection.py

@@ -1,6 +1,6 @@
 """Negative Selection Algorithm."""
 
-from typing import Dict, Literal, Optional, Union
+from typing import Any, Dict, Literal, Optional, Union
 from tqdm import tqdm
 
 import numpy as np
@@ -90,12 +90,12 @@ class RNSA(BaseNSA):
         k: int = 1,
         metric: Literal["manhattan", "minkowski", "euclidean"] = "euclidean",
         max_discards: int = 1000,
-        seed: int = None,
+        seed: Optional[int] = None,
         algorithm: Literal["default-NSA", "V-detector"] = "default-NSA",
-        **kwargs: Dict[str, Union[bool, str, float]],
+        **kwargs: Any,
     ):
-        self.metric = sanitize_choice(metric, ["manhattan", "minkowski"], "euclidean")
-        self.seed = sanitize_seed(seed)
+        self.metric: str = sanitize_choice(metric, ["manhattan", "minkowski"], "euclidean")
+        self.seed: Optional[int] = sanitize_seed(seed)
         if self.seed is not None:
             np.random.seed(seed)
         self.k: int = sanitize_param(k, 1, lambda x: x > 1)
@@ -108,20 +108,20 @@ class RNSA(BaseNSA):
         self.max_discards: int = sanitize_param(max_discards, 1000, lambda x: x > 0)
 
         # Retrieves the variables from kwargs.
-        self.p: float = kwargs.get("p", 2)
-        self.cell_bounds: bool = kwargs.get("cell_bounds", False)
-        self.non_self_label: str = kwargs.get("non_self_label", "non-self")
+        self.p: np.float64 = np.float64(kwargs.get("p", 2))
+        self.cell_bounds: bool = bool(kwargs.get("cell_bounds", False))
+        self.non_self_label: str = str(kwargs.get("non_self_label", "non-self"))
 
         # Initializes the other class variables as None.
         self._detectors: Union[dict, None] = None
-        self.classes: npt.NDArray = None
+        self.classes: Union[npt.NDArray, list] = []
 
     @property
-    def detectors(self) -> Dict[str, list[Detector]]:
+    def detectors(self) -> Optional[Dict[str, list[Detector]]]:
         """Returns the trained detectors, organized by class."""
         return self._detectors
 
-    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True):
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "RNSA":
         """
         Perform training according to X and y, using the negative selection method (NegativeSelect).
 
@@ -170,7 +170,7 @@ class RNSA(BaseNSA):
             discard_count = 0
             x_class = X[sample_index[_class_]]
             # Indicating which class the algorithm is currently processing for the progress bar.
-            if verbose:
+            if verbose and progress is not None:
                 progress.set_description_str(
                     f"Generating the detectors for the {_class_} class:"
                 )
@@ -183,11 +183,12 @@ class RNSA(BaseNSA):
                 # If the detector is valid, add it to the list of valid detectors.
                 if valid_detector is not False:
                     discard_count = 0
-                    radius = (
-                        valid_detector[1] if self.algorithm == "V-detector" else None
-                    )
+                    if self.algorithm == "V-detector" and isinstance(valid_detector, tuple):
+                        radius = valid_detector[1]
+                    else:
+                        radius = None
                     valid_detectors_set.append(Detector(vector_x, radius))
-                    if verbose:
+                    if verbose and progress is not None:
                         progress.update(1)
                 else:
                     discard_count += 1
@@ -197,7 +198,7 @@ class RNSA(BaseNSA):
             # Add detectors, with classes as keys in the dictionary.
             list_detectors_by_class[_class_] = valid_detectors_set
         # Notify completion of detector generation for the classes.
-        if verbose:
+        if verbose and progress is not None:
             progress.set_description(
                 f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
                 f"successfully generated\033[0m"
@@ -258,9 +259,7 @@ class RNSA(BaseNSA):
             elif not class_found:
                 average_distance: dict = {}
                 for _class_ in self.classes:
-                    detectores = list(
-                        map(lambda x: x.position, self._detectors[_class_])
-                    )
+                    detectores = [x.position for x in self._detectors[_class_]]
                     average_distance[_class_] = np.average(
                         [self.__distance(detector, line) for detector in detectores]
                     )
@@ -291,17 +290,17 @@ class RNSA(BaseNSA):
         # If self.k > 1, uses the k nearest neighbors (kNN); otherwise, checks the detector
         # without considering kNN.
         if self.k > 1:
-            knn_list = []
+            knn_list: list = []
             for x in x_class:
                 # Calculates the distance between the two vectors and adds it to the kNN list if
                 # the distance is smaller than the largest distance in the list.
-                knn_list = self.__compare_knearest_neighbors_list(
+                self.__compare_knearest_neighbors_list(
                     knn_list, self.__distance(x, vector_x)
                 )
             # If the average of the distances in the kNN list is less than the radius, Returns true.
             distance_mean = np.mean(knn_list)
             if self.algorithm == "V-detector":
-                return self.__detector_is_valid_to_vdetector(distance_mean, vector_x)
+                return self.__detector_is_valid_to_vdetector(float(distance_mean), vector_x)
             if distance_mean > (self.r + self.r_s):
                 return True
         else:
@@ -323,8 +322,8 @@ class RNSA(BaseNSA):
         return False  # Detector is not valid!
 
     def __compare_knearest_neighbors_list(
-        self, knn: npt.NDArray, distance: float
-    ) -> npt.NDArray:
+        self, knn: list, distance: float
+    ) -> None:
         """
         Compare the k-nearest neighbor distance at position k=1 in the list knn.
 
@@ -336,17 +335,11 @@ class RNSA(BaseNSA):
             List of k-nearest neighbor distances.
         distance : float
             Distance to check.
-
-        Returns
-        -------
-        knn : npt.NDArray
-            Updated and sorted nearest neighbor list.
         """
         # If the number of distances in kNN is less than k, adds the distance.
         if len(knn) < self.k:
-            knn = np.append(knn, distance)
+            knn.append(distance)
             knn.sort()
-            return knn
 
         # Otherwise, add the distance if the new distance is smaller than the largest
         # distance in the list.
@@ -354,7 +347,6 @@ class RNSA(BaseNSA):
             knn[self.k - 1] = distance
             knn.sort()
 
-        return knn
 
     def __compare_sample_to_detectors(self, line: npt.NDArray) -> Optional[str]:
         """
@@ -371,6 +363,9 @@ class RNSA(BaseNSA):
             Returns the predicted class with the detectors or None if the sample does not qualify
             for any class.
         """
+        if self._detectors is None:
+            return None
+
         # List to store the classes and the average distance between the detectors and the sample.
         possible_classes = []
         for _class_ in self.classes:
@@ -491,7 +486,7 @@ class BNSA(BaseNSA):
         N: int = 100,
         aff_thresh: float = 0.1,
         max_discards: int = 1000,
-        seed: int = None,
+        seed: Optional[int] = None,
         no_label_sample_selection: Literal[
             "max_average_difference", "max_nearest_difference"
         ] = "max_average_difference",
@@ -500,27 +495,27 @@ class BNSA(BaseNSA):
         self.aff_thresh: float = sanitize_param(aff_thresh, 0.1, lambda x: 0 < x < 1)
         self.max_discards: float = sanitize_param(max_discards, 1000, lambda x: x > 0)
 
-        self.seed = sanitize_seed(seed)
+        self.seed: Optional[int] = sanitize_seed(seed)
 
         if self.seed is not None:
             np.random.seed(seed)
 
-        self.no_label_sample_selection: float = sanitize_param(
+        self.no_label_sample_selection: str = sanitize_param(
             no_label_sample_selection,
             "max_average_difference",
             lambda x: x == "nearest_difference",
         )
 
-        self.classes: npt.NDArray = None
+        self.classes: Union[npt.NDArray, list] = []
         self._detectors: Optional[dict] = None
-        self._detectors_stack: npt.NDArray = None
+        self._detectors_stack: Optional[npt.NDArray] = None
 
     @property
-    def detectors(self) -> Dict[str, npt.NDArray[np.bool_]]:
+    def detectors(self) -> Optional[Dict[str, npt.NDArray[np.bool_]]]:
         """Returns the trained detectors, organized by class."""
         return self._detectors
 
-    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True):
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "BNSA":
         """Training according to X and y, using the method negative selection method.
 
         Parameters
@@ -539,7 +534,7 @@ class BNSA(BaseNSA):
              Returns the instance it self.
         """
         super()._check_and_raise_exceptions_fit(X, y, "BNSA")
-
+        progress = None
         # Converts the entire array X to boolean
         X = X.astype(np.bool_)
 
@@ -562,7 +557,7 @@ class BNSA(BaseNSA):
             valid_detectors_set: list = []
             discard_count: int = 0
             # Updating the progress bar with the current class the algorithm is processing.
-            if verbose:
+            if verbose and progress is not None:
                 progress.set_description_str(
                     f"Generating the detectors for the {_class_} class:"
                 )
@@ -574,7 +569,7 @@ class BNSA(BaseNSA):
                 if check_detector_bnsa_validity(x_class, vector_x, self.aff_thresh):
                     discard_count = 0
                     valid_detectors_set.append(vector_x)
-                    if verbose:
+                    if verbose and progress is not None:
                         progress.update(1)
                 else:
                     discard_count += 1
@@ -585,7 +580,7 @@ class BNSA(BaseNSA):
             list_detectors_by_class[_class_] = np.array(valid_detectors_set)
 
         # Notify the completion of detector generation for the classes.
-        if verbose:
+        if verbose and progress is not None:
             progress.set_description(
                 f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
                 f"successfully generated\033[0m"
@@ -613,7 +608,7 @@ class BNSA(BaseNSA):
             ``X``. Returns``None``: If there are no detectors for the prediction.
         """
         # If there are no detectors, Returns None.
-        if self._detectors is None:
+        if self._detectors is None or self._detectors_stack is None:
             return None
 
         super()._check_and_raise_exceptions_predict(
@@ -664,6 +659,9 @@ class BNSA(BaseNSA):
         c : list
             List of predictions to be updated with the new classification.
         """
+        if self._detectors is None:
+            raise ValueError("Detectors is not initialized.")
+
         class_differences: dict = {}
         for _class_ in self.classes:
             distances = np.sum(line != self._detectors[_class_]) / self.N

aisp/utils/types.py

@@ -0,0 +1,31 @@
+"""
+Defines type aliases used throughout the project to improve readability.
+
+Type Aliases
+------------
+FeatureType : Literal["binary-features", "continuous-features", "ranged-features"]
+    Specifies the type of features in the input data. Can be one of:
+    - "binary-features": Features with binary values (e.g., 0 or 1).
+    - "continuous-features": Features with continuous numeric values.
+    - "ranged-features": Features represented by ranges or intervals.
+
+MetricType : Literal["manhattan", "minkowski", "euclidean"]
+    Specifies the distance metric to use for calculations. Possible values:
+    - "manhattan": The calculation of the distance is given by the expression:
+            √( (x₁ – x₂)² + (y₁ – y₂)² + ... + (yn – yn)²).
+    - "minkowski": The calculation of the distance is given by the expression:
+            ( |X₁ – Y₁|p + |X₂ – Y₂|p + ... + |Xn – Yn|p) ¹/ₚ.
+    - "euclidean": The calculation of the distance is given by the expression:
+            ( |x₁ – x₂| + |y₁ – y₂| + ... + |yn – yn|).
+"""
+
+
+from typing import Literal, TypeAlias
+
+
+FeatureType: TypeAlias = Literal[
+    "binary-features",
+    "continuous-features",
+    "ranged-features"
+]
+MetricType: TypeAlias = Literal["manhattan", "minkowski", "euclidean"]

aisp/utils/validation.py

@@ -0,0 +1,47 @@
+"""Contains functions responsible for validating data types."""
+
+import numpy as np
+import numpy.typing as npt
+
+from .types import FeatureType
+from ..exceptions import UnsupportedTypeError
+
+
+def detect_vector_data_type(
+    vector: npt.NDArray
+) -> FeatureType:
+    """
+    Detect the type of data in a vector.
+
+    The function detects if the vector contains data of type:
+    - "binary": binary data (boolean True/False or integer 0/1)
+    - "continuous": continuous data between 0.0 and 1.0 (float)
+    - "ranged": numerical data with values outside the normalized range (float)
+
+    Parameters
+    ----------
+    vector: npt.NDArray
+        An array containing the data to be classified.
+
+    Returns
+    -------
+    Literal["binary-features", "continuous-features", "ranged-features"]
+        The classified data type of the vector.
+
+    Raises
+    ------
+    UnsupportedDataTypeError
+        If the data type of the vector is not supported by the function.
+    """
+    if vector.dtype == np.bool_:
+        return "binary-features"
+
+    if np.issubdtype(vector.dtype, np.integer) and np.isin(vector, [0, 1]).all():
+        return "binary-features"
+
+    if np.issubdtype(vector.dtype, np.floating):
+        if np.all(vector >= 0.0) and np.all(vector <= 1.0):
+            return "continuous-features"
+        return "ranged-features"
+
+    raise UnsupportedTypeError()

{aisp-0.1.42.dist-info → aisp-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.1.42
+Version: 0.2.1
 Summary: Package with techniques of artificial immune systems.
 Author-email: João Paulo da Silva Barros <jpsilvabarr@gmail.com>
 Maintainer-email: Alison Zille Lopes <alisonzille@gmail.com>
@@ -26,6 +26,11 @@ Requires-Dist: numpy>=1.22.4
 Requires-Dist: numba>=0.59.0
 Requires-Dist: scipy>=1.8.1
 Requires-Dist: tqdm>=4.64.1
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2.post1; extra == "dev"
+Requires-Dist: ipykernel>=6.29.5; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Requires-Dist: pytest>=8.3.5; extra == "dev"
 Dynamic: license-file
 
 <div align = center> 
@@ -79,7 +84,8 @@ Artificial Immune Systems (AIS) are inspired by the vertebrate immune system, cr
 ##### Algorithms implemented:
 
 > - [x] [**Negative Selection.**](https://ais-package.github.io/docs/aisp-techniques/Negative%20Selection/)
-> - [ ] *Clonal Selection Algorithms.*
+> - [x] **Clonal Selection Algorithms.**
+>     * [AIRS - Artificial Immune Recognition System](https://ais-package.github.io/docs/aisp-techniques/Clonal%20Selection%20Algorithms/)
 > - [ ] *Dendritic Cells.*
 > - [ ] *Immune Network Theory.*
 
@@ -126,22 +132,14 @@ pip install aisp
 
 ---
 
-##### Example using the negative selection technique (**nsa**):
+Explore the example notebooks available in the [AIS-Package/aisp repository](https://github.com/AIS-Package/aisp/tree/main/examples).
+These notebooks demonstrate how to utilize the package's functionalities in various scenarios, including applications of the RNSA,
+BNSA and AIRS algorithms on datasets such as Iris, Geyser, and Mushrooms.
 
-In the example present in this [notebook](https://github.com/AIS-Package/aisp/blob/main/examples/RNSA/example_with_randomly_generated_dataset-en.ipynb), **500** random samples were generated, arranged in two groups, one for each class.
+You can run the notebooks directly in your browser without any local installation using Binder:
 
-Below are some examples that use a database for classification with the [Jupyter notebook](https://jupyter.org/) tool.
-
-
-##### **Negative Selection:**
-
-+ **RNSA** Application of negative selection techniques for classification using the Iris family flower database and Old Faithful Geyser:
-    + [iris_dataBase_example](https://github.com/AIS-Package/aisp/blob/main/examples/RNSA/iris_dataBase_example_en.ipynb)
-    + [geyser_dataBase_example](https://github.com/AIS-Package/aisp/blob/main/examples/RNSA/geyser_dataBase_example_en.ipynb)
-+ **BNSA** 
-    + [mushrooms_dataBase_example](https://github.com/AIS-Package/aisp/blob/main/examples/BNSA/mushrooms_dataBase_example_en.ipynb)
-
----
+[![Launch on Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/AIS-Package/aisp/HEAD?labpath=%2Fexamples)
 
+> 💡 **Tip**: Binder may take a few minutes to load the environment, especially on the first launch.
 </section>
 </section>

aisp-0.2.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+aisp/__init__.py,sha256=N5aAyup46_tqU9cXfYfGuR3bdfAjcvaPc1xwFdGdD7A,112
+aisp/exceptions.py,sha256=I9JaQx6p8Jo7qjwwcrqnuewQgyBdUnOSSZofPoBeDNE,1954
+aisp/base/__init__.py,sha256=k2Ww9hej_32ekYhhCiYGEMLgOmDKwRt261HZ8rEurwA,102
+aisp/base/_classifier.py,sha256=Ud8VLE7vNh1ddpNNg0RVET2RXCd7kvzvfvNKHKNn_GM,3734
+aisp/base/mutation.py,sha256=A_AlGp8S4ooFEMW3Jgv0n0Y6tbhfusaMMWFsoH4HmD8,4762
+aisp/csa/__init__.py,sha256=cJSKkbvNTpR_CKCL--h99fNPiMf3fJ73gFnZRq7uyVM,355
+aisp/csa/_ai_immune_recognition_sys.py,sha256=_XqTHjqEO6sGZiIRlNNLe6Lz2PDFfDCtsbpucClvYmA,18878
+aisp/csa/_base.py,sha256=jR1IIhGINn7DLo8V5iJinDn-wW-t6etcE39bAZnQylw,3595
+aisp/csa/_cell.py,sha256=GUxnzvPyIbBm1YYkMhSx0tcV_oyDhJ7wAo5gtr_1CoY,1845
+aisp/nsa/__init__.py,sha256=3cXuBmO-_Dp3-8ZG3Eu8e_bD1JDb-RH4Wu0UDNVD1bs,385
+aisp/nsa/_base.py,sha256=3YKlZzA3yhP2uQHfhyKswbHUutlxkOR4wn6N10nSO-w,4119
+aisp/nsa/_negative_selection.py,sha256=aMdbIrd4TdPxaAkHHY-HbbM5kd5f81HbE3DyB73ttX4,28467
+aisp/nsa/_ns_core.py,sha256=SXkZL-p2VQygU4Pf6J5AP_yPzU4cR6aU6wx-e_vlm-c,5021
+aisp/utils/__init__.py,sha256=RzpKhkg8nCZi4G0C4il97f3ESYs7Bbxq6EjTeOQQUGk,195
+aisp/utils/_multiclass.py,sha256=nWd58ayVfxgdopBQc9b_xywkolJ2fGW3AN-JoD2A9Fw,1134
+aisp/utils/distance.py,sha256=pIt76OUiwCry6eNEuWLYvUiW4KkeU6egjjnnmroFet8,6556
+aisp/utils/metrics.py,sha256=zDAScDbHRnfu24alRcZ6fEIUaWNoCD-QCtOCFBWPPo8,1277
+aisp/utils/sanitizers.py,sha256=u1GizdJ-RKfPWJLnuFiM09lpItZMhDR_EvK8YdVHwDk,1858
+aisp/utils/types.py,sha256=KELzr1kSBT7hHdsABoIS1xmEBGj6gRSH5A5YNG36I_c,1324
+aisp/utils/validation.py,sha256=ya7Y_6Lv7L6LAHC11EAfZRqqneCsOqrjG8i2EQFZcpA,1418
+aisp-0.2.1.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+aisp-0.2.1.dist-info/METADATA,sha256=bhd0eOBVOuNN8gZ-jN3L4QWV17Qa0R2Kb-syKX5PK1U,4844
+aisp-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aisp-0.2.1.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
+aisp-0.2.1.dist-info/RECORD,,

{aisp-0.1.42.dist-info → aisp-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

aisp-0.1.42.dist-info/RECORD

@@ -1,18 +0,0 @@
-aisp/__init__.py,sha256=N5aAyup46_tqU9cXfYfGuR3bdfAjcvaPc1xwFdGdD7A,112
-aisp/exceptions.py,sha256=M2H_oM-ccIkDGpeFA3CyklZlgMcjTVvOCTGLU2sxFi8,1447
-aisp/base/__init__.py,sha256=k2Ww9hej_32ekYhhCiYGEMLgOmDKwRt261HZ8rEurwA,102
-aisp/base/_classifier.py,sha256=_HJiL1fCNqoB5KlNUN5pH9Yuu_btOze39h0SdnBw7ug,3672
-aisp/nsa/__init__.py,sha256=3cXuBmO-_Dp3-8ZG3Eu8e_bD1JDb-RH4Wu0UDNVD1bs,385
-aisp/nsa/_base.py,sha256=D_N-VIESvGFhdf_A2NETV-JaZJ6ISankrbRzWXSMiXM,4140
-aisp/nsa/_negative_selection.py,sha256=-hqMspYvtPAb38qV1_NF5HmDCOGDWGL89BZ3M4eHiao,28141
-aisp/nsa/_ns_core.py,sha256=SXkZL-p2VQygU4Pf6J5AP_yPzU4cR6aU6wx-e_vlm-c,5021
-aisp/utils/__init__.py,sha256=RzpKhkg8nCZi4G0C4il97f3ESYs7Bbxq6EjTeOQQUGk,195
-aisp/utils/_multiclass.py,sha256=nWd58ayVfxgdopBQc9b_xywkolJ2fGW3AN-JoD2A9Fw,1134
-aisp/utils/distance.py,sha256=pIt76OUiwCry6eNEuWLYvUiW4KkeU6egjjnnmroFet8,6556
-aisp/utils/metrics.py,sha256=zDAScDbHRnfu24alRcZ6fEIUaWNoCD-QCtOCFBWPPo8,1277
-aisp/utils/sanitizers.py,sha256=u1GizdJ-RKfPWJLnuFiM09lpItZMhDR_EvK8YdVHwDk,1858
-aisp-0.1.42.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-aisp-0.1.42.dist-info/METADATA,sha256=rsVoFnO5H9UV643wtHx7vvNWBxxg6QPcgjrbfQGOF0Y,4818
-aisp-0.1.42.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-aisp-0.1.42.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
-aisp-0.1.42.dist-info/RECORD,,