aisp 0.2.0__tar.gz → 0.2.1__tar.gz

{aisp-0.2.0 → aisp-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.2.0
+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> 

{aisp-0.2.0 → aisp-0.2.1}/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-0.2.0 → aisp-0.2.1}/aisp/base/mutation.py

@@ -84,3 +84,47 @@ def clone_and_mutate_binary(
         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-0.2.0 → aisp-0.2.1}/aisp/csa/_ai_immune_recognition_sys.py

@@ -4,16 +4,19 @@ import random
 from collections import Counter
 from heapq import nlargest
 from operator import attrgetter
-from typing import List, Literal, Optional, Dict
+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
 
 
@@ -114,20 +117,12 @@ class AIRS(BaseAIRS):
         * ``'manhattan'`` ➜ The calculation of the distance is given by the expression:
             ( |x₁ – x₂| + |y₁ – y₂| + ... + |yn – yn|).
 
-    algorithm : Literal["continuous-features", "binary-features"], default="continuous-features"
-        Specifies the type of algorithm to use based on the nature of the input features:
-
-        * ``continuous-features``: selects an algorithm designed for continuous data, which should
-            be normalized within the range [0, 1].
-
-        * ``binary-features``: selects an algorithm specialized for handling binary variables.
-
     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 Minkowsks distance. The default
+            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.
 
@@ -160,11 +155,8 @@ class AIRS(BaseAIRS):
         k: int = 3,
         max_iters: int = 100,
         resource_amplified: float = 1.0,
-        metric: Literal["manhattan", "minkowski", "euclidean"] = "euclidean",
-        algorithm: Literal[
-            "continuous-features", "binary-features"
-        ] = "continuous-features",
-        seed: int = None,
+        metric: MetricType = "euclidean",
+        seed: Optional[int] = None,
         **kwargs,
     ) -> None:
         self.n_resources: float = sanitize_param(n_resources, 10, lambda x: x >= 1)
@@ -183,35 +175,29 @@ class AIRS(BaseAIRS):
         )
         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: int = sanitize_seed(seed)
+        self.seed: Optional[int] = sanitize_seed(seed)
         if self.seed is not None:
             np.random.seed(self.seed)
 
-        self.algorithm: Literal["continuous-features", "binary-features"] = (
-            sanitize_param(
-                algorithm, "continuous-features", lambda x: x == "binary-features"
-            )
-        )
+        self._feature_type: FeatureType = "continuous-features"
 
-        if algorithm == "binary-features":
-            self.metric: str = "hamming"
-        else:
-            self.metric: str = sanitize_choice(
-                metric, ["manhattan", "minkowski"], "euclidean"
-            )
+        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 = None
+        self.classes = []
+        self._bounds: Optional[npt.NDArray[np.float64]] = None
 
     @property
-    def cells_memory(self) -> Dict[str, list[Cell]]:
+    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):
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "AIRS":
         """
         Fit the model to the training data using the AIRS.
 
@@ -235,10 +221,16 @@ class AIRS(BaseAIRS):
         """
         progress = None
 
-        super()._check_and_raise_exceptions_fit(X, y, self.algorithm)
+        self._feature_type = detect_vector_data_type(X)
 
-        if self.algorithm == "binary-features":
-            X = X.astype(np.bool_)
+        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)
@@ -250,7 +242,7 @@ class AIRS(BaseAIRS):
             )
         pool_cells_classes = {}
         for _class_ in self.classes:
-            if verbose:
+            if verbose and progress is not None:
                 progress.set_description_str(
                     f"Generating the memory cells for the {_class_} class:"
                 )
@@ -267,7 +259,7 @@ class AIRS(BaseAIRS):
             for ai in x_class:
                 # Calculating the stimulation of memory cells with aᵢ and selecting the largest
                 # stimulation from the memory set.
-                c_match = None
+                c_match = pool_c[0]
                 match_stimulation = -1
                 for cell in pool_c:
                     stimulation = self._affinity(cell.vector, ai)
@@ -284,7 +276,7 @@ class AIRS(BaseAIRS):
 
                 set_clones: npt.NDArray = c_match.hyper_clonal_mutate(
                     int(self.rate_hypermutation * self.rate_clonal * match_stimulation),
-                    self.algorithm
+                    self._feature_type
                 )
 
                 for clone in set_clones:
@@ -302,11 +294,11 @@ class AIRS(BaseAIRS):
                     if self._affinity(c_candidate.vector, c_match.vector) < sufficiently_similar:
                         pool_c.remove(c_match)
 
-                if verbose:
+                if verbose and progress is not None:
                     progress.update(1)
             pool_cells_classes[_class_] = pool_c
 
-        if verbose:
+        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"
@@ -337,7 +329,7 @@ class AIRS(BaseAIRS):
             return None
 
         super()._check_and_raise_exceptions_predict(
-            X, len(self._cells_memory[self.classes[0]][0].vector), self.algorithm
+            X, len(self._cells_memory[self.classes[0]][0].vector), self._feature_type
         )
 
         c: list = []
@@ -417,7 +409,7 @@ class AIRS(BaseAIRS):
             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.algorithm
+                self._feature_type
             )
 
             arb_list = [
@@ -446,12 +438,12 @@ class AIRS(BaseAIRS):
         antigens_list : npt.NDArray
             List of training antigens.
         """
-        if self.algorithm == "binary-features":
+        if self._feature_type == "binary-features":
             distances = pdist(antigens_list, metric="hamming")
-        elif self.metric == "minkowski":
-            distances = pdist(antigens_list, metric="minkowski", p=self.p)
         else:
-            distances = pdist(antigens_list, metric=self.metric)
+            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))
@@ -473,7 +465,7 @@ class AIRS(BaseAIRS):
             The stimulus rate between the vectors.
         """
         distance: float
-        if self.algorithm == "binary-features":
+        if self._feature_type == "binary-features":
             distance = hamming(u, v)
         else:
             distance = compute_metric_distance(

{aisp-0.2.0 → aisp-0.2.1}/aisp/csa/_base.py

@@ -1,12 +1,12 @@
 """Base Class for Clonal Selection Algorithm."""
 
 from abc import ABC
-from typing import Literal
 
 import numpy as np
 import numpy.typing as npt
 
-from aisp.exceptions import FeatureDimensionMismatch
+from ..exceptions import FeatureDimensionMismatch
+from ..utils.types import FeatureType
 from ..base import BaseClassifier
 
 
@@ -20,11 +20,8 @@ class BaseAIRS(BaseClassifier, ABC):
 
     @staticmethod
     def _check_and_raise_exceptions_fit(
-        X: npt.NDArray = None,
-        y: npt.NDArray = None,
-        algorithm: Literal[
-            "continuous-features", "binary-features"
-        ] = "continuous-features"
+        X: npt.NDArray,
+        y: npt.NDArray
     ):
         """
         Verify the fit parameters and throw exceptions if the verification is not successful.
@@ -36,17 +33,11 @@ class BaseAIRS(BaseClassifier, ABC):
             [``N samples`` (rows)][``N features`` (columns)].
         y : npt.NDArray
             Array of target classes of ``X`` with [``N samples`` (lines)].
-        algorithm : Literal["continuous-features", "binary-features"], default="continuous-features"
-            Specifies the type of algorithm to use, depending on whether the input data has
-            continuous or binary features.
 
         Raises
         ------
         TypeError:
             If X or y are not ndarrays or have incompatible shapes.
-        ValueError
-            If algorithm is binary-features and X contains values that are not composed only
-            of 0 and 1.
         """
         if not isinstance(X, np.ndarray):
             if isinstance(X, list):
@@ -63,18 +54,12 @@ class BaseAIRS(BaseClassifier, ABC):
                 "X does not have the same amount of sample for the output classes in y."
             )
 
-        if algorithm == "binary-features" and not np.isin(X, [0, 1]).all():
-            raise ValueError(
-                "The array X contains values that are not composed only of 0 and 1."
-            )
 
     @staticmethod
     def _check_and_raise_exceptions_predict(
-        X: npt.NDArray = None,
+        X: npt.NDArray,
         expected: int = 0,
-        algorithm: Literal[
-            "continuous-features", "binary-features"
-        ] = "continuous-features"
+        feature_type: FeatureType = "continuous-features"
     ) -> None:
         """
         Verify the predict parameters and throw exceptions if the verification is not successful.
@@ -86,8 +71,8 @@ class BaseAIRS(BaseClassifier, ABC):
             [``N samples`` (rows)][``N features`` (columns)].
         expected : int, default=0
             Expected number of features per sample (columns in X).
-        algorithm : Literal["continuous-features", "binary-features"], default="continuous-features"
-            Specifies the type of algorithm to use, depending on whether the input data has
+        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
@@ -97,7 +82,7 @@ class BaseAIRS(BaseClassifier, ABC):
         FeatureDimensionMismatch
             If the number of features in X does not match the expected number.
         ValueError
-            If algorithm is binary-features and X contains values that are not composed only
+            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)):
@@ -109,7 +94,7 @@ class BaseAIRS(BaseClassifier, ABC):
                 "X"
             )
 
-        if algorithm != "binary-features":
+        if feature_type != "binary-features":
             return
 
         # Checks if matrix X contains only binary samples. Otherwise, raises an exception.

aisp-0.2.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-0.2.0 → aisp-0.2.1}/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-0.2.0 → aisp-0.2.1}/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-0.2.0 → aisp-0.2.1}/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-0.2.1/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-0.2.1/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.2.0 → aisp-0.2.1}/aisp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.2.0
+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> 

{aisp-0.2.0 → aisp-0.2.1}/aisp.egg-info/SOURCES.txt

@@ -23,4 +23,6 @@ aisp/utils/__init__.py
 aisp/utils/_multiclass.py
 aisp/utils/distance.py
 aisp/utils/metrics.py
-aisp/utils/sanitizers.py
+aisp/utils/sanitizers.py
+aisp/utils/types.py
+aisp/utils/validation.py

aisp-0.2.1/aisp.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy>=1.22.4
+numba>=0.59.0
+scipy>=1.8.1
+tqdm>=4.64.1
+
+[dev]
+build>=1.2.2.post1
+ipykernel>=6.29.5
+twine>=5.1.1
+pytest>=8.3.5

{aisp-0.2.0 → aisp-0.2.1}/aisp.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 aisp
+build
 dist
 docs
 examples

{aisp-0.2.0 → aisp-0.2.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aisp"
-version = "0.2.0"
+version = "0.2.1"
 authors = [
   { name="João Paulo da Silva Barros", email="jpsilvabarr@gmail.com" },
 ]
@@ -56,6 +56,14 @@ Documentation = "https://ais-package.github.io/docs/intro"
 "Source Code" = "https://github.com/AIS-Package/aisp"
 Tracker = "https://github.com/AIS-Package/aisp/issues"
 
+[project.optional-dependencies]
+dev = [
+  "build>=1.2.2.post1",
+  "ipykernel>=6.29.5",
+  "twine>=5.1.1",
+  "pytest>=8.3.5",
+]
+
 [tool.setuptools]
 packages = { find = { exclude = [
   "*test*",

aisp-0.2.0/aisp/csa/_cell.py

@@ -1,47 +0,0 @@
-"""Represents a memory B-cell."""
-
-from dataclasses import dataclass
-from typing import Literal
-
-import numpy as np
-import numpy.typing as npt
-
-from ..base.mutation import clone_and_mutate_continuous, clone_and_mutate_binary
-
-
-@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,
-        algorithm: Literal["continuous-features", "binary-features"] = "continuous-features"
-    ) -> 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.
-        algorithm : Literal["continuous-features", "binary-features"], default="continuous-features"
-            Specifies the type of algorithm to use based on the nature of the input features
-
-        Returns
-        -------
-        npt.NDArray
-            An array containing N mutated vectors from the original cell.
-        """
-        if algorithm == "binary-features":
-            return clone_and_mutate_binary(self.vector, n)
-        return clone_and_mutate_continuous(self.vector, n)

aisp-0.2.0/aisp.egg-info/requires.txt

@@ -1,4 +0,0 @@
-numpy>=1.22.4
-numba>=0.59.0
-scipy>=1.8.1
-tqdm>=4.64.1