aisp 0.1.35__py3-none-any.whl → 0.1.40__py3-none-any.whl

aisp/nsa/_ns_core.py

@@ -0,0 +1,153 @@
+"""ns: Negative Selection
+
+The functions perform detector checks and utilize Numba decorators for Just-In-Time compilation
+"""
+
+import numpy.typing as npt
+from numba import njit, types
+
+from ..utils.distance import compute_metric_distance, hamming
+
+
+@njit(
+    [(
+        types.boolean[:, :],
+        types.boolean[:],
+        types.float64
+    )],
+    cache=True
+)
+def check_detector_bnsa_validity(
+    x_class: npt.NDArray,
+    vector_x: npt.NDArray,
+    aff_thresh: float
+) -> bool:
+    """
+    Checks the validity of a candidate detector (vector_x) against samples from a class (x_class)
+    using the Hamming distance. A detector is considered INVALID if its distance to any sample
+    in ``x_class`` is less than or equal to ``aff_thresh``.
+
+    Parameters
+    ----------
+    * x_class (``npt.NDArray``): Array containing the class samples. Expected shape: 
+        (n_samples, n_features).
+    * vector_x (``npt.NDArray``): Array representing the detector. Expected shape: (n_features,).
+    * aff_thresh (``float``): Affinity threshold.
+
+    Returns
+    ----------
+    * True if the detector is valid, False otherwise.
+    """
+    n = x_class.shape[1]
+    if n != vector_x.shape[0]:
+        return False
+
+    for i in range(x_class.shape[0]):
+        # Calculate the normalized Hamming Distance
+        if hamming(x_class[i], vector_x) <= aff_thresh:
+            return False
+    return True
+
+
+@njit(
+    [(
+        types.boolean[:],
+        types.boolean[:, :, :],
+        types.float64
+    )],
+    cache=True
+)
+def bnsa_class_prediction(
+    features: npt.NDArray,
+    class_detectors: npt.NDArray,
+    aff_thresh: float
+) -> int:
+    """
+    Defines the class of a sample from the non-self detectors.
+
+    Parameters
+    ----------
+    * features (``npt.NDArray``): binary sample to be classified (shape: [n_features]).
+    * class_detectors (``npt.NDArray``): Array containing the detectors of all classes
+    (shape: [n_classes, n_detectors, n_features]).
+    * aff_thresh (``float``): Affinity threshold that determines whether a detector recognizes the
+    sample as non-self.
+
+    Returns
+    ----------
+    * int: Index of the predicted class. Returns -1 if it is non-self for all classes.
+    """
+    n_classes, n_detectors, _ = class_detectors.shape
+    best_class_idx = -1
+    best_avg_distance = 0
+
+    for class_index in range(n_classes):
+        total_distance = 0.0
+        class_found = True
+
+        # Calculates the Hamming distance between the row and all detectors.
+        for detector_index in range(n_detectors):
+            # Calculates the normalized Hamming distance between the sample and the detector
+            distance = hamming(features, class_detectors[class_index][detector_index])
+
+            # If the distance is less than or equal to the threshold, the detector recognizes
+            # the sample as non-self.
+            if distance <= aff_thresh:
+                class_found = False
+                break
+            total_distance += distance
+
+        # if the sample is self for the class
+        if class_found:
+            avg_distance = total_distance / n_detectors
+            # Choose the class with the largest average distance.
+            if avg_distance > best_avg_distance:
+                best_avg_distance = avg_distance
+                best_class_idx = class_index
+
+    return best_class_idx
+
+
+@njit(
+    [(
+        types.float64[:, :], types.float64[:],
+        types.float64, types.int32, types.float64
+    )],
+    cache=True
+)
+def check_detector_rnsa_validity(
+    x_class: npt.NDArray,
+    vector_x: npt.NDArray,
+    threshold: float,
+    metric: int,
+    p: float
+) -> bool:
+    """
+    Checks the validity of a candidate detector (vector_x) against samples from a class (x_class)
+    using the Hamming distance. A detector is considered INVALID if its distance to any sample
+    in ``x_class`` is less than or equal to ``aff_thresh``.
+
+    Parameters
+    ----------
+    * x_class (``npt.NDArray``): Array containing the class samples. Expected shape: 
+        (n_samples, n_features).
+    * vector_x (``npt.NDArray``): Array representing the detector. Expected shape: (n_features,).
+    * threshold (``float``): threshold.
+    * metric (``int``): Distance metric to be used. Available options: 
+        [0 (Euclidean), 1 (Manhattan), 2 (Minkowski)].
+    * p (``float``): Parameter for the Minkowski distance (used only if `metric` 
+    is "minkowski").
+
+    Returns
+    ----------
+    * True if the detector is valid, False otherwise.
+    """
+    n = x_class.shape[1]
+    if n != vector_x.shape[0]:
+        return False
+
+    for i in range(x_class.shape[0]):
+        distance = compute_metric_distance(vector_x, x_class[i], metric, p)
+        if distance <= threshold:
+            return False
+    return True

aisp/utils/_multiclass.py

@@ -1,4 +1,5 @@
 """Utility functions for handling classes with multiple categories."""
+
 from typing import Union
 import numpy as np
 import numpy.typing as npt

aisp/utils/distance.py

@@ -0,0 +1,215 @@
+"""Utility functions for normalized distance between arrays with numba decorators."""
+
+import numpy as np
+import numpy.typing as npt
+from numba import njit, types
+
+EUCLIDEAN = 0
+MANHATTAN = 1
+MINKOWSKI = 2
+HAMMING = 3
+
+
+@njit([(types.boolean[:], types.boolean[:])], cache=True)
+def hamming(u: npt.NDArray[np.bool_], v: npt.NDArray[np.bool_]) -> np.float64:
+    """
+    Function to calculate the normalized Hamming distance between two points.
+    
+    ((x₁ ≠ x₂) + (y₁ ≠ y₂) + ... + (yn ≠ yn)) / n
+
+    Parameters
+    ----------
+    * u (``npt.NDArray``): Coordinates of the first point.
+    * v (``npt.NDArray``): Coordinates of the second point.
+
+    returns
+    ----------
+    * Distance (``float``) between the two points.
+    """
+    n = len(u)
+    if n == 0:
+        return 0.0
+
+    return np.sum(u != v) / n
+
+
+@njit()
+def euclidean(u: npt.NDArray[np.float64], v: npt.NDArray[np.float64]) -> np.float64:
+    """
+    Function to calculate the normalized Euclidean distance between two points.
+    
+    √( (x₁ – x₂)² + (y₁ – y₂)² + ... + (yn – yn)²)
+
+    Parameters
+    ----------
+    * u (``npt.NDArray``): Coordinates of the first point.
+    * v (``npt.NDArray``): Coordinates of the second point.
+
+    returns
+    ----------
+    * Distance (``float``) between the two points.
+    """
+    return np.linalg.norm(u - v)
+
+
+@njit()
+def cityblock(u: npt.NDArray[np.float64], v: npt.NDArray[np.float64]) -> np.float64:
+    """
+    Function to calculate the normalized Manhattan distance between two points.
+    
+    (|x₁ – x₂| + |y₁ – y₂| + ... + |yn – yn|) / n
+
+    Parameters
+    ----------
+    * u (``npt.NDArray``): Coordinates of the first point.
+    * v (``npt.NDArray``): Coordinates of the second point.
+
+    returns
+    ----------
+    * Distance (``float``) between the two points.
+    """
+    n = len(u)
+    if n == 0:
+        return -1.0
+
+    return np.sum(np.abs(u - v)) / n
+
+
+@njit()
+def minkowski(u: npt.NDArray[np.float64], v: npt.NDArray[np.float64], p: float = 2.0):
+    """
+    Function to calculate the normalized Minkowski distance between two points.
+    
+    (( |X₁ – Y₁|p + |X₂ – Y₂|p + ... + |Xn – Yn|p) ¹/ₚ.) / n
+
+    Parameters
+    ----------
+    * u (``npt.NDArray``): Coordinates of the first point.
+    * v (``npt.NDArray``): Coordinates of the second point.
+    * p float: The p parameter defines the type of distance to be calculated:
+        - p = 1: **Manhattan** distance — sum of absolute differences.
+        - p = 2: **Euclidean** distance — sum of squared differences (square root).
+        - p > 2: **Minkowski** distance with an increasing penalty as p increases.
+
+    returns
+    ----------
+    * Distance (``float``) between the two points.
+    """
+    n = len(u)
+    if n == 0:
+        return -1.0
+
+    return (np.sum(np.abs(u - v) ** p) ** (1 / p)) / n
+
+
+@njit(
+    [(
+        types.float64[:], types.float64[:],
+        types.int32, types.float64
+    )],
+    cache=True
+)
+def compute_metric_distance(
+    u: npt.NDArray[np.float64],
+    v: npt.NDArray[np.float64],
+    metric: int,
+    p: np.float64 = 2.0
+) -> np.float64:
+    """
+    Function to calculate the distance between two points by the chosen ``metric``.
+
+    Parameters
+    ----------
+    * u (``npt.NDArray``): Coordinates of the first point.
+    * v (``npt.NDArray``): Coordinates of the second point.
+    * metric (``int``): Distance metric to be used. Available options: 
+    [0 (Euclidean), 1 (Manhattan), 2 (Minkowski)]
+    * p (``float``): Parameter for the Minkowski distance (used only if `metric` 
+    is "minkowski").
+
+    returns
+    ----------
+    * Distance (``double``) between the two points with the selected metric.
+    """
+    if metric == MANHATTAN:
+        return cityblock(u, v)
+    if metric == MINKOWSKI:
+        return minkowski(u, v, p)
+
+    return euclidean(u, v)
+
+
+@njit(
+    [(
+        types.float64[:, :], types.float64[:],
+        types.int32, types.float64
+    )],
+    cache=True
+)
+def min_distance_to_class_vectors(
+    x_class: npt.NDArray[np.float64],
+    vector_x: npt.NDArray[np.float64],
+    metric: int,
+    p: float = 2.0
+) -> float:
+    """
+    Calculates the minimum distance between an input vector and the vectors of a class.
+
+    Parameters
+    ----------
+    * x_class (``npt.NDArray``): Array containing the class vectors to be compared 
+    with the input vector. Expected shape: (n_samples, n_features).
+    * vector_x (``npt.NDArray``): Vector to be compared with the class vectors.
+    Expected shape: (n_features,).
+    * metric (``str``): Distance metric to be used. Available options: 
+    ["hamming", "cityblock", "minkowski", "euclidean"]
+    * p (``float``): Parameter for the Minkowski distance (used only if `metric` 
+    is "minkowski").
+
+    Returns
+    ----------
+    * float: The minimum distance calculated between the input vector and the class vectors.
+    * Returns -1.0 if the input dimensions are incompatible.
+    """
+    n = x_class.shape[1]
+    if n != vector_x.shape[0]:
+        return -1.0
+
+    min_distance = np.inf
+    for i in range(x_class.shape[0]):
+        distance = compute_metric_distance(vector_x, x_class[i], metric, p)
+        min_distance = min(min_distance, distance)
+
+    return min_distance
+
+
+def get_metric_code(metric: str) -> int:
+    """
+    Returns the numeric code associated with a distance metric.
+
+    Parameters
+    ----------
+    * metric (str): Name of the metric. Can be "euclidean", "manhattan", "minkowski" or "hamming".
+
+    Raises
+    ----------
+    * ValueError: If the metric provided is not supported.
+
+    Returns
+    ----------
+    * int: Numeric code corresponding to the metric.
+    """
+    metric_map = {
+        "euclidean": EUCLIDEAN,
+        "manhattan": MANHATTAN,
+        "minkowski": MINKOWSKI,
+        "hamming": HAMMING
+    }
+
+    normalized_metric = metric.strip().lower()
+
+    if normalized_metric not in metric_map:
+        supported = "', '".join(metric_map.keys())
+        raise ValueError(f"Unknown metric: '{metric}'. Supported: {supported}")
+
+    return metric_map[normalized_metric]

aisp/utils/metrics.py

@@ -6,8 +6,8 @@ import numpy.typing as npt
 
 
 def accuracy_score(
-        y_true: Union[npt.NDArray, list],
-        y_pred: Union[npt.NDArray, list]
+    y_true: Union[npt.NDArray, list],
+    y_pred: Union[npt.NDArray, list]
 ) -> float:
     """
     Function to calculate the accuracy score based on true and predicted labels.

aisp/utils/sanitizers.py

@@ -3,6 +3,7 @@ from typing import TypeVar, Iterable, Callable, Any, Optional
 
 T = TypeVar('T')
 
+
 def sanitize_choice(value: T, valid_choices: Iterable[T], default: T) -> T:
     """
     Returns the value if it is present in the set of valid choices; otherwise, 
@@ -10,8 +11,8 @@ def sanitize_choice(value: T, valid_choices: Iterable[T], default: T) -> T:
 
     Parameters
     ----------
-    * value: The value to be checked.
-    * valid_choices (iterable): A collection of valid choices.
+    * value (``T``): The value to be checked.
+    * valid_choices (``Iterable[T]``): A collection of valid choices.
     * default: The default value to be returned if 'value' is not in 'valid_choices'.
 
     Returns

{aisp-0.1.35.dist-info → aisp-0.1.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.1.35
+Version: 0.1.40
 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>
@@ -9,18 +9,21 @@ Project-URL: Homepage, https://ais-package.github.io/
 Project-URL: Documentation, https://ais-package.github.io/docs/intro
 Project-URL: Source Code, https://github.com/AIS-Package/aisp
 Project-URL: Tracker, https://github.com/AIS-Package/aisp/issues
-Keywords: Artificial Immune Systems,classification,Natural computing,machine learning,artificial intelligence
+Keywords: Artificial Immune Systems,classification,Natural computing,machine learning,artificial intelligence,AIS
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.22.4
+Requires-Dist: numba>=0.59.0
 Requires-Dist: scipy>=1.8.1
 Requires-Dist: tqdm>=4.64.1
 Dynamic: license-file
@@ -86,7 +89,7 @@ Artificial Immune Systems (AIS) are inspired by the vertebrate immune system, cr
 
 #### **Installation**
 
-The module requires installation of [python 3.8.10](https://www.python.org/downloads/) or higher.
+The module requires installation of [python 3.10](https://www.python.org/downloads/) or higher.
 
 <section id='dependencies'>
 
@@ -99,6 +102,7 @@ The module requires installation of [python 3.8.10](https://www.python.org/downl
 |    numpy      |    ≥ 1.22.4   |
 |    scipy      |    ≥ 1.8.1    |
 |    tqdm       |    ≥ 4.64.1   |
+|    numba      |    ≥ 0.59.0   |
 
 </div>
 

aisp-0.1.40.dist-info/RECORD

@@ -0,0 +1,18 @@
+aisp/__init__.py,sha256=pKOdkhFxWup_lhQPofFTk4rpqd0_IlYygHnkBhE2g2w,111
+aisp/exceptions.py,sha256=ONiKCZrBhfUaMO1vYHnOr1_eL9PtVJ7b_HRroMbORpc,1405
+aisp/base/__init__.py,sha256=rpb9ADmBtNpRAEJw61c7CsbZhHA2vGQOvjFmpk7w39c,100
+aisp/base/_classifier.py,sha256=qv6TxzfnRwO7HvN7CA8PS1dueAnm-RifelRnCjrK9D0,3027
+aisp/nsa/__init__.py,sha256=3-fSIJCMB_jcLGTr6DcVkloRfWyQJ8-JzD0CLhvpvgc,411
+aisp/nsa/_base.py,sha256=cT404V5onduK19WW6ajxy_yUZha3Fk8KZJvJHt_UZBM,4250
+aisp/nsa/_negative_selection.py,sha256=0_VI3rAeVzPcSRwjMjqCq6RT-1_a_-HCFtIIJL6jpyc,29582
+aisp/nsa/_ns_core.py,sha256=VWt_L2ODXtngJ7BVmSVT7i7kK98axibOmCzbYCkjeqI,4934
+aisp/utils/__init__.py,sha256=-r--qdfTq4dVJU-VoJ7dvXTNS5_I1q1aGAQ02zNBOGw,217
+aisp/utils/_multiclass.py,sha256=t0RLIdUoUbvFL30a8XfO3BMXc8MimtLCHNbGCDL2BQk,1051
+aisp/utils/distance.py,sha256=SZTE5KEB7QX9vKoY9GfFOfFGbswVhQM6-9baLq4ZXns,6304
+aisp/utils/metrics.py,sha256=o6aD6qTLQtXhWNOMGjgweHMQ6SMQ2hh42NcSEmgY3RI,1292
+aisp/utils/sanitizers.py,sha256=7wJSo5ZkRX1g16C9sEN8TWQ5l9Gzfl0-8CgLULnPNlk,1873
+aisp-0.1.40.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+aisp-0.1.40.dist-info/METADATA,sha256=em8eJAx3lr87ZZ1ajsoSkIj-itauLz25E1FKcdjf1QU,4818
+aisp-0.1.40.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+aisp-0.1.40.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
+aisp-0.1.40.dist-info/RECORD,,

{aisp-0.1.35.dist-info → aisp-0.1.40.dist-info}/WHEEL

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

aisp-0.1.35.dist-info/RECORD

@@ -1,14 +0,0 @@
-aisp/__init__.py,sha256=6is9Nwltdm6JZAsdLPXY56WXC7qnd0kNUEJoizOxWHg,111
-aisp/exceptions.py,sha256=ONiKCZrBhfUaMO1vYHnOr1_eL9PtVJ7b_HRroMbORpc,1405
-aisp/nsa/__init__.py,sha256=wgoFb-0WovzFovQG6UFkAb-IbZWK2wlytuJ03wmV4Q0,411
-aisp/nsa/_base.py,sha256=OpBC3loiWk8NEb4ulogulIOKeh6hTnxcpImF6BNy8iI,8086
-aisp/nsa/_negative_selection.py,sha256=iYtd39eR4O2y1bOVAAEqfMmgzIzQ_oexLCN3sRO8Mxg,32089
-aisp/utils/__init__.py,sha256=-r--qdfTq4dVJU-VoJ7dvXTNS5_I1q1aGAQ02zNBOGw,217
-aisp/utils/_multiclass.py,sha256=KJ2Le62KsSPRQB3UDMv7HT13xQLvwwZQM3QekTATDiY,1049
-aisp/utils/metrics.py,sha256=RmqR5FRxQUZkF9GZhAUXNplaeRldhXv592DeeYPdyV8,1300
-aisp/utils/sanitizers.py,sha256=QKpIu8YyNLIZT472O49QybLZB5P-NQqGaNI5xylyJ8k,1856
-aisp-0.1.35.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-aisp-0.1.35.dist-info/METADATA,sha256=aHoORgNbmyDlN7Pd2MXCaNgGD7T30g_jtM_XIH20pZs,4603
-aisp-0.1.35.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-aisp-0.1.35.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
-aisp-0.1.35.dist-info/RECORD,,