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

aisp/base/mutation.py

@@ -0,0 +1,86 @@
+"""
+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

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,506 @@
+"""Artificial Immune Recognition System (AIRS)."""
+
+import random
+from collections import Counter
+from heapq import nlargest
+from operator import attrgetter
+from typing import List, Literal, 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 ._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|).
+
+    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
+            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: Literal["manhattan", "minkowski", "euclidean"] = "euclidean",
+        algorithm: Literal[
+            "continuous-features", "binary-features"
+        ] = "continuous-features",
+        seed: 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: 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"
+            )
+        )
+
+        if algorithm == "binary-features":
+            self.metric: str = "hamming"
+        else:
+            self.metric: str = 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
+
+    @property
+    def cells_memory(self) -> 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):
+        """
+        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
+
+        super()._check_and_raise_exceptions_fit(X, y, self.algorithm)
+
+        if self.algorithm == "binary-features":
+            X = X.astype(np.bool_)
+
+        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:
+                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 = None
+                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.algorithm
+                )
+
+                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:
+                    progress.update(1)
+            pool_cells_classes[_class_] = pool_c
+
+        if verbose:
+            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.algorithm
+        )
+
+        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.algorithm
+            )
+
+            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.algorithm == "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)
+        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.algorithm == "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,119 @@
+"""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 ..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 = None,
+        y: npt.NDArray = None,
+        algorithm: Literal[
+            "continuous-features", "binary-features"
+        ] = "continuous-features"
+    ):
+        """
+        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)].
+        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):
+                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."
+            )
+
+        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,
+        expected: int = 0,
+        algorithm: Literal[
+            "continuous-features", "binary-features"
+        ] = "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).
+        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 is not a ndarray or list.
+        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
+            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 algorithm != "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,47 @@
+"""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.1.42.dist-info → aisp-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.1.42
+Version: 0.2.0
 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>
@@ -79,7 +79,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 +127,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.1.42.dist-info → aisp-0.2.0.dist-info}/RECORD

@@ -2,6 +2,11 @@ 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/base/mutation.py,sha256=j_2WiZDxUS3KS4QgGXaFqoLVSxSz88BpLfZTjLuGaSU,3110
+aisp/csa/__init__.py,sha256=cJSKkbvNTpR_CKCL--h99fNPiMf3fJ73gFnZRq7uyVM,355
+aisp/csa/_ai_immune_recognition_sys.py,sha256=0f8DQzZ7lG69xCMI1jpR0QBKZ4oNvRXpayQMUekzC5o,19233
+aisp/csa/_base.py,sha256=y1OX0Z0ZGQu63fQmg1umMZ1110H8bkStP5NaGNOvgmY,4399
+aisp/csa/_cell.py,sha256=PhGdXKytRYnV97pmaLLKVhaV_OwU31-92URZVMszohY,1377
 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
@@ -11,8 +16,8 @@ aisp/utils/_multiclass.py,sha256=nWd58ayVfxgdopBQc9b_xywkolJ2fGW3AN-JoD2A9Fw,113
 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,,
+aisp-0.2.0.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+aisp-0.2.0.dist-info/METADATA,sha256=5jLC17E3FIl_8ewjhK5hkJQ7YsJFP_a-bMW8EHDCDSc,4631
+aisp-0.2.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+aisp-0.2.0.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
+aisp-0.2.0.dist-info/RECORD,,