aisp 0.1.41__tar.gz → 0.1.42__tar.gz

{aisp-0.1.41 → aisp-0.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.1.41
+Version: 0.1.42
 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.1.42/aisp/__init__.py

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

{aisp-0.1.41 → aisp-0.1.42}/aisp/base/__init__.py

@@ -1,4 +1,5 @@
 """Base class modules."""
+
 from ._classifier import BaseClassifier
 
 __all__ = ['BaseClassifier']

aisp-0.1.42/aisp/base/_classifier.py

@@ -0,0 +1,116 @@
+"""Base class for classification algorithm."""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Union
+
+import numpy.typing as npt
+
+from ..utils import slice_index_list_by_class
+from ..utils.metrics import accuracy_score
+
+
+class BaseClassifier(ABC):
+    """Base class for classification algorithms.
+
+    Defines the abstract methods ``fit`` and ``predict``, and implements the ``score``,
+    ``get_params`` method.
+    """
+
+    classes: Optional[Union[npt.NDArray, list]] = None
+
+    @abstractmethod
+    def fit(self, X: npt.NDArray, y: npt.NDArray, verbose: bool = True):
+        """
+        Train the model using the input data X and corresponding labels y.
+
+        This abstract method is implemented by the class that inherits it.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input data used for training the model.
+        y : npt.NDArray
+            Corresponding labels or target values for the input data.
+        verbose : bool, default=True
+            Flag to enable or disable detailed output during training.
+
+        Returns
+        -------
+        self : BaseClassifier
+            Returns the instance of the class that implements this method.
+        """
+
+    @abstractmethod
+    def predict(self, X) -> Optional[npt.NDArray]:
+        """
+        Generate predictions based on the input data X.
+
+        This abstract method is implemented by the class that inherits it.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input data for which predictions will be generated.
+
+        Returns
+        -------
+        Predictions : Optional[npt.NDArray]
+            Predicted values for each input sample, or ``None`` if the prediction fails.
+        """
+
+    def score(self, X: npt.NDArray, y: list) -> float:
+        """
+        Score function calculates forecast accuracy.
+
+        Details
+        -------
+        This function performs the prediction of X and checks how many elements are equal
+        between vector y and y_predicted. This function was added for compatibility with some
+        scikit-learn functions.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            Feature set with shape (n_samples, n_features).
+        y : np.ndarray
+            True values with shape (n_samples,).
+
+        Returns
+        -------
+        accuracy : float
+            The accuracy of the model.
+        """
+        if len(y) == 0:
+            return 0
+        y_pred = self.predict(X)
+        return accuracy_score(y, y_pred)
+
+    def _slice_index_list_by_class(self, y: npt.NDArray) -> dict:
+        """Separate the indices of the lines according to the output class.
+
+        Loop through the sample array only in positions where the output matches the class
+        being trained.
+
+        Parameters
+        ----------
+        y : npt.NDArray
+            Receives a y [``N sample``] array with the output classes of the ``X`` sample array.
+
+        Returns
+        -------
+        dict: dict
+            A dictionary with the list of array positions(``y``), with the classes as key.
+        """
+        return slice_index_list_by_class(self.classes, y)
+
+    def get_params(self, deep: bool = True) -> dict:  # pylint: disable=W0613
+        """
+        Return a dictionary with the object's main parameters.
+
+        This method is required to ensure compatibility with scikit-learn functions.
+        """
+        return {
+            key: value
+            for key, value in self.__dict__.items()
+            if not key.startswith("_")
+        }

{aisp-0.1.41 → aisp-0.1.42}/aisp/exceptions.py

@@ -1,4 +1,4 @@
-"""Custom warnings and errors"""
+"""Custom warnings and errors."""
 
 
 class MaxDiscardsReachedError(Exception):
@@ -17,16 +17,17 @@ class MaxDiscardsReachedError(Exception):
 
 
 class FeatureDimensionMismatch(Exception):
-    """ 
-    Exception raised when the number of input features does not match the expected number 
-    required by the model for prediction
+    """
+    Exception raised when the number of input features does not match the expected number.
+
+    This exception is triggered during prediction if the input features' dimension is incorrect.
     """
 
     def __init__(
-            self,
-            expected: int,
-            received: int,
-            variable_name: str = None
+        self,
+        expected: int,
+        received: int,
+        variable_name: str = None
     ):
         parts = []
         if variable_name:

{aisp-0.1.41 → aisp-0.1.42}/aisp/nsa/__init__.py

@@ -1,11 +1,11 @@
-"""nsa: Module (NSA) Negative Selection Algorithm
+"""Module (NSA) Negative Selection Algorithm.
 
 NSAs simulate the maturation process of T-cells in the immune system, where these cells learn to 
 distinguish between self and non-self. Only T-cells capable of recognizing non-self elements are 
 preserved.
 """
+
 from ._negative_selection import BNSA, RNSA
 
 __author__ = "João Paulo da Silva Barros"
 __all__ = ["RNSA", "BNSA"]
-__version__ = "0.1.40"

{aisp-0.1.41 → aisp-0.1.42}/aisp/nsa/_base.py

@@ -13,8 +13,9 @@ from ..exceptions import FeatureDimensionMismatch
 
 class BaseNSA(BaseClassifier, ABC):
     """
-    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.
+    Base class containing functions used by multiple classes in the package.
+
+    These functions are essential for the overall functioning of the system.
     """
 
     @staticmethod
@@ -23,22 +24,26 @@ class BaseNSA(BaseClassifier, ABC):
         y: npt.NDArray = None,
         _class_: Literal["RNSA", "BNSA"] = "RNSA",
     ) -> None:
-        """
-        Function responsible for verifying fit function parameters and throwing exceptions if the
-        verification is not successful.
+        """Verify fit function parameters.
+
+        Throw exceptions if the verification fails.
 
         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)].
-        * _class_ (``Literal[RNSA, BNSA], optional``) Current class. Defaults to 'RNSA'.
+        * 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)].
+        * _class_ : Literal[RNSA, BNSA], default="RNSA"
+            Current class.
 
         Raises
-        ----------
-        * TypeError: If X or y are not ndarrays or have incompatible shapes.
-        * ValueError: If _class_ is BNSA and X contains values that are not composed only of
-            0 and 1.
+        ------
+        TypeError
+            If X or y are not ndarrays or have incompatible shapes.
+        ValueError
+            If _class_ is BNSA and X contains values that are not composed only of 0 and 1.
         """
         if isinstance(X, list):
             X = np.array(X)
@@ -66,27 +71,28 @@ class BaseNSA(BaseClassifier, ABC):
         expected: int = 0,
         _class_: Literal["RNSA", "BNSA"] = "RNSA",
     ) -> None:
-        """
-        Function responsible for verifying predict function parameters and throwing exceptions if
-        the verification is not successful.
+        """Verify predict function parameters.
+
+        Throw exceptions if the verification fails.
 
         Parameters
         ----------
-        * X (``npt.NDArray``)
+        X : npt.NDArray
             Input array for prediction, containing the samples and their characteristics,
             [``N samples`` (rows)][``N features`` (columns)].
-        * expected (``int``)
+        expected : int
             Expected number of features per sample (columns in X).
-        * _class_ (``Literal[RNSA, BNSA], optional``)
+        _class_ : Literal[RNSA, BNSA], default="RNSA"
             Current class. Defaults to 'RNSA'.
 
         Raises
-        ----------
-        * TypeError: If X is not an ndarray or list.
-        * FeatureDimensionMismatch: If the number of features in X does not match the expected
-            number.
-        * ValueError: If _class_ is BNSA and X contains values that are not composed only of 0
-        and 1.
+        ------
+        TypeError
+            If X is not an numpy.ndarray or list.
+        FeatureDimensionMismatch
+            If the number of features in X does not match the expected number.
+        ValueError
+            If _class_ is BNSA 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")
@@ -110,8 +116,10 @@ class Detector:
 
     Attributes
     ----------
-    * position (``npt.NDArray[np.float64]``): Detector feature vector.
-    * radius (``float, optional``): Detector radius, used in the V-detector algorithm.
+    position : npt.NDArray[np.float64]
+        Detector feature vector.
+    radius : float, optional
+        Detector radius, used in the V-detector algorithm.
     """
 
     position: npt.NDArray[np.float64]