aisp 0.3.0__tar.gz → 0.3.1__tar.gz

{aisp-0.3.0 → aisp-0.3.1}/PKG-INFO

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

aisp-0.3.1/aisp/__init__.py

@@ -0,0 +1,26 @@
+"""AISP - Artificial Immune Systems Package.
+
+AISP is a Python package of immunoinspired techniques that apply metaphors from the vertebrate
+immune system to pattern recognition and optimization tasks.
+
+The package is organized into specialized modules, each dedicated to a family of Artificial
+Immune Systems algorithms:
+- csa: Clonal Selection Algorithms
+- nsa: Negative Selection Algorithms
+- ina: Immune Network Algorithms
+
+For detailed documentation and examples, visit:
+https://ais-package.github.io/docs/intro
+"""
+
+from . import csa
+from . import nsa
+from . import ina
+
+__author__ = "AISP Development Team"
+__version__ = "0.3.1"
+__all__ = [
+    'csa',
+    'nsa',
+    'ina'
+]

{aisp-0.3.0 → aisp-0.3.1}/aisp/base/_classifier.py

@@ -1,5 +1,6 @@
 """Base class for classification algorithm."""
 
+from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import Optional, Union
 
@@ -19,7 +20,7 @@ class BaseClassifier(ABC, Base):
     classes: Union[npt.NDArray, list] = []
 
     @abstractmethod
-    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "BaseClassifier":
+    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.
 

{aisp-0.3.0 → aisp-0.3.1}/aisp/base/_clusterer.py

@@ -1,5 +1,6 @@
 """Base class for clustering algorithms."""
 
+from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import Optional
 
@@ -17,7 +18,7 @@ class BaseClusterer(ABC, Base):
     """
 
     @abstractmethod
-    def fit(self, X: npt.NDArray, verbose: bool = True) -> "BaseClusterer":
+    def fit(self, X: npt.NDArray, verbose: bool = True) -> BaseClusterer:
         """
         Train the model using the input data X.
 

{aisp-0.3.0 → aisp-0.3.1}/aisp/csa/_ai_recognition_sys.py

@@ -1,5 +1,6 @@
 """Artificial Immune Recognition System (AIRS)."""
 
+from __future__ import annotations
 import random
 from collections import Counter
 from heapq import nlargest
@@ -189,6 +190,7 @@ class AIRS(BaseAIRS):
         self.p: np.float64 = np.float64(kwargs.get("p", 2.0))
 
         self._cells_memory = None
+        self._all_class_cell_vectors = None
         self.affinity_threshold = 0.0
         self.classes = []
         self._bounds: Optional[npt.NDArray[np.float64]] = None
@@ -198,7 +200,7 @@ class AIRS(BaseAIRS):
         """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":
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> AIRS:
         """
         Fit the model to the training data using the AIRS.
 
@@ -301,6 +303,11 @@ class AIRS(BaseAIRS):
         )
         progress.close()
         self._cells_memory = pool_cells_classes
+        self._all_class_cell_vectors = [
+            (class_name, cell.vector)
+            for class_name in self.classes
+            for cell in self._cells_memory[class_name]
+        ]
         return self
 
     def predict(self, X: npt.NDArray) -> Optional[npt.NDArray]:
@@ -322,7 +329,7 @@ class AIRS(BaseAIRS):
             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:
+        if self._all_class_cell_vectors is None:
             return None
 
         super()._check_and_raise_exceptions_predict(
@@ -331,16 +338,10 @@ class AIRS(BaseAIRS):
 
         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
+                for class_name, memory in self._all_class_cell_vectors
             ]
             # 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])

{aisp-0.3.0 → aisp-0.3.1}/aisp/csa/_base.py

@@ -54,7 +54,6 @@ class BaseAIRS(BaseClassifier, ABC):
                 "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,

{aisp-0.3.0 → aisp-0.3.1}/aisp/ina/_ai_network.py

@@ -1,5 +1,6 @@
 """Artificial Immune Network (AiNet)."""
 
+from __future__ import annotations
 from collections import Counter
 from heapq import nlargest
 from typing import Optional
@@ -21,7 +22,7 @@ from ..utils.validation import detect_vector_data_type
 
 
 class AiNet(BaseAiNet):
-    """Artificial Immune Network for Compression and Clustering .
+    """Artificial Immune Network for Compression and Clustering.
 
     This class implements the aiNet algorithm, an artificial immune network model designed for
     clustering and data compression tasks. The aiNet algorithm uses principles from immune
@@ -77,13 +78,11 @@ class AiNet(BaseAiNet):
 
     References
     ----------
-    .. [1] de Castro, L. N., & Von Zuben, F. J. (2001).
-           *aiNet: An Artificial Immune Network for Data Analysis*.
-           Draft Chapter XII of the book *Data Mining: A Heuristic Approach*.
-           Department of Computer and Automation Engineering, University of Campinas.
+    .. [1] De Castro, Leandro & José, Fernando & von Zuben, Antonio Augusto. (2001). aiNet: An
+           Artificial Immune Network for Data Analysis.
            Available at:
-             https://www.dca.fee.unicamp.br/~vonzuben/research/lnunes_dout/
-             artigos/DMHA.PDF
+             https://www.researchgate.net/publication/
+             228378350_aiNet_An_Artificial_Immune_Network_for_Data_Analysis
     .. [2] SciPy Documentation. *Minimum Spanning Tree*.
            https://docs.scipy.org/doc/scipy/reference/generated/
            scipy.sparse.csgraph.minimum_spanning_tree
@@ -175,7 +174,7 @@ class AiNet(BaseAiNet):
             'std_distance': self._mst_std_distance
         }
 
-    def fit(self, X: npt.NDArray, verbose: bool = True):
+    def fit(self, X: npt.NDArray, verbose: bool = True) -> AiNet:
         """
         Train the AiNet model on input data.
 

{aisp-0.3.0 → aisp-0.3.1}/aisp/nsa/__init__.py

@@ -5,7 +5,8 @@ distinguish between self and non-self. Only T-cells capable of recognizing non-s
 preserved.
 """
 
-from ._negative_selection import BNSA, RNSA
+from ._binary_negative_selection import BNSA
+from ._negative_selection import RNSA
 
 __author__ = "João Paulo da Silva Barros"
 __all__ = ["RNSA", "BNSA"]

aisp-0.3.1/aisp/nsa/_binary_negative_selection.py

@@ -0,0 +1,239 @@
+"""Negative Selection Algorithm."""
+
+from __future__ import annotations
+from typing import Dict, Literal, Optional, Union
+from tqdm import tqdm
+
+import numpy as np
+import numpy.typing as npt
+
+from ._ns_core import (
+    check_detector_bnsa_validity,
+    bnsa_class_prediction
+)
+from ..exceptions import MaxDiscardsReachedError
+from ..utils.sanitizers import sanitize_seed, sanitize_param
+from ._base import BaseNSA
+
+
+class BNSA(BaseNSA):
+    """BNSA (Binary Negative Selection Algorithm).
+    
+    Class is for classification and identification purposes of anomalies through the self and not
+    self method.
+
+    Parameters
+    ----------
+    N : int, default=100
+        Number of detectors.
+    aff_thresh : float, default=0.1
+        The variable represents the percentage of similarity between the T cell and the own
+        samples. The default value is 10% (0.1), while a value of 1.0 represents 100% similarity.
+    max_discards : int, default=1000
+        This parameter indicates the maximum number of detector discards in sequence, which aims
+        to avoid a possible infinite loop if a radius is defined that it is not possible to
+        generate non-self detectors.
+    seed : Optional[int], default=None
+         Seed for the random generation of values in the detectors.
+    no_label_sample_selection : str, default="max_average_difference"
+        Method for selecting labels for samples designated as non-self by all detectors.
+        Available method types:
+
+        - max_average_difference - Selects the class with the highest average difference among the
+        detectors.
+
+        - max_nearest_difference - Selects the class with the highest difference between the
+        nearest and farthest detector from the sample.
+    """
+
+    def __init__(
+        self,
+        N: int = 100,
+        aff_thresh: float = 0.1,
+        max_discards: int = 1000,
+        seed: Optional[int] = None,
+        no_label_sample_selection: Literal[
+            "max_average_difference", "max_nearest_difference"
+        ] = "max_average_difference",
+    ):
+        self.N: int = sanitize_param(N, 100, lambda x: x > 0)
+        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: Optional[int] = sanitize_seed(seed)
+
+        if self.seed is not None:
+            np.random.seed(seed)
+
+        self.no_label_sample_selection: str = sanitize_param(
+            no_label_sample_selection,
+            "max_average_difference",
+            lambda x: x == "nearest_difference",
+        )
+
+        self.classes: Union[npt.NDArray, list] = []
+        self._detectors: Optional[dict] = None
+        self._detectors_stack: Optional[npt.NDArray] = None
+
+    @property
+    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) -> BNSA:
+        """Training according to X and y, using the method negative selection method.
+
+        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, default=True
+            Feedback from detector generation to the user.
+
+        Returns
+        -------
+        self : BNSA
+             Returns the instance it self.
+        """
+        super()._check_and_raise_exceptions_fit(X, y, "BNSA")
+        # Converts the entire array X to boolean
+        X = X.astype(np.bool_)
+
+        # Identifying the possible classes within the output array `y`.
+        self.classes = np.unique(y)
+        # Dictionary that will store detectors with classes as keys.
+        list_detectors_by_class = {}
+        # Separates the classes for training.
+        sample_index: dict = self._slice_index_list_by_class(y)
+        # Progress bar for generating all detectors.
+
+        progress = tqdm(
+            total=int(self.N * (len(self.classes))),
+            bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
+            postfix="\n",
+            disable=not verbose
+        )
+
+        for _class_ in self.classes:
+            # Initializes the empty set that will contain the valid detectors.
+            valid_detectors_set: list = []
+            discard_count: int = 0
+            # Updating the progress bar with the current class the algorithm is processing.
+            progress.set_description_str(
+                f"Generating the detectors for the {_class_} class:"
+            )
+            x_class = X[sample_index[_class_]]
+            while len(valid_detectors_set) < self.N:
+                # Generates a candidate detector vector randomly with values 0 and 1.
+                vector_x = np.random.randint(0, 2, size=X.shape[1]).astype(np.bool_)
+                # If the detector is valid, add it to the list of valid detectors.
+                if check_detector_bnsa_validity(x_class, vector_x, self.aff_thresh):
+                    discard_count = 0
+                    valid_detectors_set.append(vector_x)
+                    progress.update(1)
+                else:
+                    discard_count += 1
+                    if discard_count == self.max_discards:
+                        raise MaxDiscardsReachedError(_class_)
+
+            # Add detectors to the dictionary with classes as keys.
+            list_detectors_by_class[_class_] = np.array(valid_detectors_set)
+
+        # Notify the completion of detector generation for the classes.
+        progress.set_description(
+            f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
+            f"successfully generated\033[0m"
+        )
+        progress.close()
+        # Saves the found detectors in the attribute for the class detectors.
+        self._detectors = list_detectors_by_class
+        self._detectors_stack = np.array(
+            [np.stack(self._detectors[class_name]) for class_name in self.classes]
+        )
+        return self
+
+    def predict(self, X: npt.NDArray) -> Optional[npt.NDArray]:
+        """Prediction of classes based on detectors created after training.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Array with input samples with [``N_samples`` (Lines)] and [``N_characteristics``(
+            Columns)]
+
+        Returns
+        -------
+        c : Optional[npt.NDArray]
+            an ndarray of the form ``C`` [``N samples``], containing the predicted classes for
+            ``X``. Returns``None``: If there are no detectors for the prediction.
+        """
+        # If there are no detectors, Returns None.
+        if self._detectors is None or self._detectors_stack is None:
+            return None
+
+        super()._check_and_raise_exceptions_predict(
+            X, len(self._detectors[self.classes[0]][0]), "BNSA"
+        )
+
+        # Converts the entire array X to boolean.
+        if X.dtype != bool:
+            X = X.astype(bool)
+
+        # Initializes an empty array that will store the predictions.
+        c = []
+        # For each sample row in X.
+        for line in X:
+            class_found: bool = True
+            # Class prediction based on detectors
+            class_index = bnsa_class_prediction(
+                line, self._detectors_stack, self.aff_thresh
+            )
+            # If belonging to one or more classes, adds the class with the greatest
+            # average distance
+            if class_index > -1:
+                c.append(self.classes[class_index])
+                class_found = True
+            else:
+                class_found = False
+
+            # If there is only one class and the sample is not classified, sets the
+            # output as non-self.
+            if not class_found and len(self.classes) == 1:
+                c.append("non-self")
+            # If the class cannot be identified by the detectors
+            elif not class_found:
+                self.__assign_class_to_non_self_sample(line, c)
+
+        return np.array(c)
+
+    def __assign_class_to_non_self_sample(self, line: npt.NDArray, c: list):
+        """Determine the class of a sample when all detectors classify it as "non-self".
+        
+        Classification is performed using the ``max_average_difference`` and
+        ``max_nearest_difference`` methods.
+
+        Parameters
+        ----------
+        line : npt.NDArray
+            Sample to be classified.
+        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
+            # Assign the label to the class with the greatest distance from
+            # the nearest detector.
+            if self.no_label_sample_selection == "nearest_difference":
+                class_differences[_class_] = distances.min()
+            # Or based on the greatest distance from the average distances of the detectors.
+            else:
+                class_differences[_class_] = distances.sum() / self.N
+
+        c.append(max(class_differences, key=class_differences.get))

{aisp-0.3.0 → aisp-0.3.1}/aisp/nsa/_negative_selection.py

@@ -1,5 +1,6 @@
 """Negative Selection Algorithm."""
 
+from __future__ import annotations
 from typing import Any, Dict, Literal, Optional, Union
 from tqdm import tqdm
 
@@ -7,11 +8,7 @@ import numpy as np
 import numpy.typing as npt
 
 from ..base import set_seed_numba
-from ._ns_core import (
-    check_detector_bnsa_validity,
-    bnsa_class_prediction,
-    check_detector_rnsa_validity,
-)
+from ._ns_core import check_detector_rnsa_validity
 from ..exceptions import MaxDiscardsReachedError
 from ..utils.distance import (
     min_distance_to_class_vectors,
@@ -123,7 +120,7 @@ class RNSA(BaseNSA):
         """Returns the trained detectors, organized by class."""
         return self._detectors
 
-    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True) -> "RNSA":
+    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).
 
@@ -339,10 +336,9 @@ class RNSA(BaseNSA):
         if len(knn) < self.k:
             knn.append(distance)
             knn.sort()
-
         # Otherwise, add the distance if the new distance is smaller than the largest
         # distance in the list.
-        if knn[self.k - 1] > distance:
+        elif knn[self.k - 1] > distance:
             knn[self.k - 1] = distance
             knn.sort()
 
@@ -447,226 +443,3 @@ class RNSA(BaseNSA):
                     return False
 
         return True, new_detector_r
-
-
-class BNSA(BaseNSA):
-    """BNSA (Binary Negative Selection Algorithm).
-    
-    Class is for classification and identification purposes of anomalies through the self and not
-    self method.
-
-    Parameters
-    ----------
-    N : int, default=100
-        Number of detectors.
-    aff_thresh : float, default=0.1
-        The variable represents the percentage of similarity between the T cell and the own
-        samples. The default value is 10% (0.1), while a value of 1.0 represents 100% similarity.
-    max_discards : int, default=1000
-        This parameter indicates the maximum number of detector discards in sequence, which aims
-        to avoid a possible infinite loop if a radius is defined that it is not possible to
-        generate non-self detectors.
-    seed : Optional[int], default=None
-         Seed for the random generation of values in the detectors.
-    no_label_sample_selection : str, default="max_average_difference"
-        Method for selecting labels for samples designated as non-self by all detectors.
-        Available method types:
-
-        - max_average_difference - Selects the class with the highest average difference among the
-        detectors.
-
-        - max_nearest_difference - Selects the class with the highest difference between the
-        nearest and farthest detector from the sample.
-    """
-
-    def __init__(
-        self,
-        N: int = 100,
-        aff_thresh: float = 0.1,
-        max_discards: int = 1000,
-        seed: Optional[int] = None,
-        no_label_sample_selection: Literal[
-            "max_average_difference", "max_nearest_difference"
-        ] = "max_average_difference",
-    ):
-        self.N: int = sanitize_param(N, 100, lambda x: x > 0)
-        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: Optional[int] = sanitize_seed(seed)
-
-        if self.seed is not None:
-            np.random.seed(seed)
-
-        self.no_label_sample_selection: str = sanitize_param(
-            no_label_sample_selection,
-            "max_average_difference",
-            lambda x: x == "nearest_difference",
-        )
-
-        self.classes: Union[npt.NDArray, list] = []
-        self._detectors: Optional[dict] = None
-        self._detectors_stack: Optional[npt.NDArray] = None
-
-    @property
-    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) -> "BNSA":
-        """Training according to X and y, using the method negative selection method.
-
-        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, default=True
-            Feedback from detector generation to the user.
-
-        Returns
-        -------
-        self : BNSA
-             Returns the instance it self.
-        """
-        super()._check_and_raise_exceptions_fit(X, y, "BNSA")
-        # Converts the entire array X to boolean
-        X = X.astype(np.bool_)
-
-        # Identifying the possible classes within the output array `y`.
-        self.classes = np.unique(y)
-        # Dictionary that will store detectors with classes as keys.
-        list_detectors_by_class = {}
-        # Separates the classes for training.
-        sample_index: dict = self._slice_index_list_by_class(y)
-        # Progress bar for generating all detectors.
-
-        progress = tqdm(
-            total=int(self.N * (len(self.classes))),
-            bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
-            postfix="\n",
-            disable=not verbose
-        )
-
-        for _class_ in self.classes:
-            # Initializes the empty set that will contain the valid detectors.
-            valid_detectors_set: list = []
-            discard_count: int = 0
-            # Updating the progress bar with the current class the algorithm is processing.
-            progress.set_description_str(
-                f"Generating the detectors for the {_class_} class:"
-            )
-            x_class = X[sample_index[_class_]]
-            while len(valid_detectors_set) < self.N:
-                # Generates a candidate detector vector randomly with values 0 and 1.
-                vector_x = np.random.randint(0, 2, size=X.shape[1]).astype(np.bool_)
-                # If the detector is valid, add it to the list of valid detectors.
-                if check_detector_bnsa_validity(x_class, vector_x, self.aff_thresh):
-                    discard_count = 0
-                    valid_detectors_set.append(vector_x)
-                    progress.update(1)
-                else:
-                    discard_count += 1
-                    if discard_count == self.max_discards:
-                        raise MaxDiscardsReachedError(_class_)
-
-            # Add detectors to the dictionary with classes as keys.
-            list_detectors_by_class[_class_] = np.array(valid_detectors_set)
-
-        # Notify the completion of detector generation for the classes.
-        progress.set_description(
-            f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
-            f"successfully generated\033[0m"
-        )
-        progress.close()
-        # Saves the found detectors in the attribute for the class detectors.
-        self._detectors = list_detectors_by_class
-        self._detectors_stack = np.array(
-            [np.stack(self._detectors[class_name]) for class_name in self.classes]
-        )
-        return self
-
-    def predict(self, X: npt.NDArray) -> Optional[npt.NDArray]:
-        """Prediction of classes based on detectors created after training.
-
-        Parameters
-        ----------
-        X : npt.NDArray
-            Array with input samples with [``N_samples`` (Lines)] and [``N_characteristics``(
-            Columns)]
-
-        Returns
-        -------
-        c : Optional[npt.NDArray]
-            an ndarray of the form ``C`` [``N samples``], containing the predicted classes for
-            ``X``. Returns``None``: If there are no detectors for the prediction.
-        """
-        # If there are no detectors, Returns None.
-        if self._detectors is None or self._detectors_stack is None:
-            return None
-
-        super()._check_and_raise_exceptions_predict(
-            X, len(self._detectors[self.classes[0]][0]), "BNSA"
-        )
-
-        # Converts the entire array X to boolean.
-        if X.dtype != bool:
-            X = X.astype(bool)
-
-        # Initializes an empty array that will store the predictions.
-        c = []
-        # For each sample row in X.
-        for line in X:
-            class_found: bool = True
-            # Class prediction based on detectors
-            class_index = bnsa_class_prediction(
-                line, self._detectors_stack, self.aff_thresh
-            )
-            # If belonging to one or more classes, adds the class with the greatest
-            # average distance
-            if class_index > -1:
-                c.append(self.classes[class_index])
-                class_found = True
-            else:
-                class_found = False
-
-            # If there is only one class and the sample is not classified, sets the
-            # output as non-self.
-            if not class_found and len(self.classes) == 1:
-                c.append("non-self")
-            # If the class cannot be identified by the detectors
-            elif not class_found:
-                self.__assign_class_to_non_self_sample(line, c)
-
-        return np.array(c)
-
-    def __assign_class_to_non_self_sample(self, line: npt.NDArray, c: list):
-        """Determine the class of a sample when all detectors classify it as "non-self".
-        
-        Classification is performed using the ``max_average_difference`` and
-        ``max_nearest_difference`` methods.
-
-        Parameters
-        ----------
-        line : npt.NDArray
-            Sample to be classified.
-        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
-            # Assign the label to the class with the greatest distance from
-            # the nearest detector.
-            if self.no_label_sample_selection == "nearest_difference":
-                class_differences[_class_] = distances.min()
-            # Or based on the greatest distance from the average distances of the detectors.
-            else:
-                class_differences[_class_] = distances.sum() / self.N
-
-        c.append(max(class_differences, key=class_differences.get))

{aisp-0.3.0 → aisp-0.3.1}/aisp.egg-info/PKG-INFO

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

{aisp-0.3.0 → aisp-0.3.1}/aisp.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ aisp/ina/_ai_network.py
 aisp/ina/_base.py
 aisp/nsa/__init__.py
 aisp/nsa/_base.py
+aisp/nsa/_binary_negative_selection.py
 aisp/nsa/_negative_selection.py
 aisp/nsa/_ns_core.py
 aisp/utils/__init__.py

{aisp-0.3.0 → aisp-0.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aisp"
-version = "0.3.0"
+version = "0.3.1"
 authors = [
   { name="João Paulo da Silva Barros", email="jpsilvabarr@gmail.com" },
 ]

aisp-0.3.0/aisp/__init__.py

@@ -1,4 +0,0 @@
-"""Artificial Immune Systems Package."""
-
-__author__ = "João Paulo da Silva Barros"
-__version__ = "0.3.0"