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

aisp/ina/_base.py

@@ -0,0 +1,124 @@
+"""Base Class for Network Theory Algorithms."""
+
+from abc import ABC
+from typing import Optional
+
+from numpy import typing as npt
+
+import numpy as np
+
+from ..base import BaseClusterer
+from ..exceptions import FeatureDimensionMismatch
+from ..utils.types import FeatureType
+
+
+class BaseAiNet(BaseClusterer, ABC):
+    """Abstract base class for AINet-based clustering algorithms."""
+
+    @staticmethod
+    def _check_and_raise_exceptions_fit(
+        X: npt.NDArray
+    ):
+        """
+        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)].
+
+        Raises
+        ------
+        TypeError
+            If X is not an ndarray or list.
+        """
+        if not isinstance(X, np.ndarray) and not isinstance(X, list):
+            raise TypeError("X is not an ndarray or list.")
+
+    @staticmethod
+    def _check_and_raise_exceptions_predict(
+        X: npt.NDArray,
+        expected: int = 0,
+        feature_type: FeatureType = "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).
+        feature_type : FeatureType, default="continuous-features"
+            Specifies the type of features: "continuous-features", "binary-features",
+            or "ranged-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 feature_type is "binary-features" and X contains values other than 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 feature_type != "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."
+            )
+
+    @staticmethod
+    def _generate_random_antibodies(
+        n_samples: int,
+        n_features: int,
+        feature_type: FeatureType = "continuous-features",
+        bounds: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray:
+        """
+        Generate a random antibody population.
+
+        Parameters
+        ----------
+        n_samples : int
+            Number of antibodies (samples) to generate.
+        n_features : int
+            Number of features (dimensions) for each antibody.
+        feature_type : FeatureType, default="continuous-features"
+            Specifies the type of features: "continuous-features", "binary-features",
+            or "ranged-features".
+        bounds : np.ndarray
+            Array (n_features, 2) with min and max per dimension.
+
+        Returns
+        -------
+        npt.NDArray
+            Array of shape (n_samples, n_features) containing the generated antibodies.
+            Data type depends on the feature_type type (float for continuous/ranged, bool for
+            binary).
+        """
+        if n_features <= 0:
+            raise ValueError("Number of features must be greater than zero.")
+
+        if feature_type == "binary-features":
+            return np.random.randint(0, 2, size=(n_samples, n_features)).astype(np.bool_)
+        if feature_type == "ranged-features" and bounds is not None:
+            return np.random.uniform(low=bounds[0], high=bounds[1], size=(n_samples, n_features))
+
+        return np.random.random_sample(size=(n_samples, n_features))

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/nsa/_negative_selection.py

@@ -1,11 +1,12 @@
 """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
 import numpy.typing as npt
 
+from ..base import set_seed_numba
 from ._ns_core import (
     check_detector_bnsa_validity,
     bnsa_class_prediction,
@@ -90,14 +91,15 @@ 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)
+            set_seed_numba(self.seed)
         self.k: int = sanitize_param(k, 1, lambda x: x > 1)
         self.N: int = sanitize_param(N, 100, lambda x: x >= 1)
         self.r: float = sanitize_param(r, 0.05, lambda x: x > 0)
@@ -108,20 +110,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).
 
@@ -148,7 +150,6 @@ class RNSA(BaseNSA):
         self : RNSA
         Returns the instance itself.
         """
-        progress = None
         super()._check_and_raise_exceptions_fit(X, y)
 
         # Identifying the possible classes within the output array `y`.
@@ -158,22 +159,21 @@ class RNSA(BaseNSA):
         # Separates the classes for training.
         sample_index = self._slice_index_list_by_class(y)
         # Progress bar for generating all detectors.
-        if verbose:
-            progress = tqdm(
-                total=int(self.N * (len(self.classes))),
-                bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
-                postfix="\n",
-            )
+        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 = []
             discard_count = 0
             x_class = X[sample_index[_class_]]
             # Indicating which class the algorithm is currently processing for the progress bar.
-            if verbose:
-                progress.set_description_str(
-                    f"Generating the detectors for the {_class_} class:"
-                )
+            progress.set_description_str(
+                f"Generating the detectors for the {_class_} class:"
+            )
             while len(valid_detectors_set) < self.N:
                 # Generates a candidate detector vector randomly with values between 0 and 1.
                 vector_x = np.random.random_sample(size=X.shape[1])
@@ -183,12 +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:
-                        progress.update(1)
+                    progress.update(1)
                 else:
                     discard_count += 1
                     if discard_count == self.max_discards:
@@ -197,11 +197,11 @@ 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:
-            progress.set_description(
-                f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
-                f"successfully generated\033[0m"
-            )
+        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 non-self detectors of the trained model
         self._detectors = list_detectors_by_class
         return self
@@ -258,9 +258,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 +289,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 +321,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 +334,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,8 +346,6 @@ class RNSA(BaseNSA):
             knn[self.k - 1] = distance
             knn.sort()
 
-        return knn
-
     def __compare_sample_to_detectors(self, line: npt.NDArray) -> Optional[str]:
         """
         Compare a sample with the detectors, verifying if the sample is proper.
@@ -371,6 +361,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:
@@ -453,7 +446,7 @@ class RNSA(BaseNSA):
                 if (p - new_detector_r) < 0 or (p + new_detector_r) > 1:
                     return False
 
-        return (True, new_detector_r)
+        return True, new_detector_r
 
 
 class BNSA(BaseNSA):
@@ -491,7 +484,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 +493,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 +532,6 @@ class BNSA(BaseNSA):
              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_)
 
@@ -550,22 +542,22 @@ class BNSA(BaseNSA):
         # Separates the classes for training.
         sample_index: dict = self._slice_index_list_by_class(y)
         # Progress bar for generating all detectors.
-        if verbose:
-            progress = tqdm(
-                total=int(self.N * (len(self.classes))),
-                bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
-                postfix="\n",
-            )
+
+        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.
-            if verbose:
-                progress.set_description_str(
-                    f"Generating the detectors for the {_class_} class:"
-                )
+            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.
@@ -574,8 +566,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:
-                        progress.update(1)
+                    progress.update(1)
                 else:
                     discard_count += 1
                     if discard_count == self.max_discards:
@@ -585,11 +576,11 @@ class BNSA(BaseNSA):
             list_detectors_by_class[_class_] = np.array(valid_detectors_set)
 
         # Notify the completion of detector generation for the classes.
-        if verbose:
-            progress.set_description(
-                f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
-                f"successfully generated\033[0m"
-            )
+        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(
@@ -613,7 +604,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 +655,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/utils/distance.py

@@ -5,10 +5,10 @@ import numpy.typing as npt
 from numba import njit, types
 from numpy import float64
 
-EUCLIDEAN = 0
-MANHATTAN = 1
-MINKOWSKI = 2
-HAMMING = 3
+EUCLIDEAN: int = 0
+MANHATTAN: int = 1
+MINKOWSKI: int = 2
+HAMMING: int = 3
 
 
 @njit([(types.boolean[:], types.boolean[:])], cache=True)

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/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 features: boolean values or integers restricted to 0 and 1.
+    - Continuous features: floating-point values in the normalized range [0.0, 1.0].
+    - Ranged features: floating-point values outside the normalized range.
+
+    Parameters
+    ----------
+    vector: npt.NDArray
+        An array containing the data to be classified.
+
+    Returns
+    -------
+    str
+        The data type of the vector: "binary-features", "continuous-features", or "ranged-features".
+
+    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.dist-info → aisp-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.2.0
+Version: 0.3.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>
@@ -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> 
@@ -79,10 +84,11 @@ 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/)
-> - [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.*
+> - [x] [**Clonal Selection Algorithms.**](https://ais-package.github.io/docs/aisp-techniques/Clonal%20Selection%20Algorithms/)
+>     * [AIRS - Artificial Immune Recognition System](https://ais-package.github.io/docs/aisp-techniques/Clonal%20Selection%20Algorithms/airs/)
+> - [ ] *Danger Theory.*
+> - [x] [*Immune Network Theory.*](https://ais-package.github.io/docs/aisp-techniques/Immune%20Network%20Theory)
+>   - [AiNet - Artificial Immune Network para Clustering and Compression](https://ais-package.github.io/docs/aisp-techniques/Immune%20Network%20Theory/ainet)
 
 </section>
 

aisp-0.3.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+aisp/__init__.py,sha256=GUbFSuDKAfnn80xxK4giPZxuAakRl5dHC5gdp_WTJU0,111
+aisp/exceptions.py,sha256=I9JaQx6p8Jo7qjwwcrqnuewQgyBdUnOSSZofPoBeDNE,1954
+aisp/base/__init__.py,sha256=cDDN6YcYqSU080AvEankhUtIALkSTVmm6XTa48htHjU,211
+aisp/base/_base.py,sha256=uTVh__hQJGe8RCOzCet4ZV3vQbwgj5fXAt4Jdf0x1r0,1792
+aisp/base/_classifier.py,sha256=yGxRGhJxN8jIpr6S7_fsaEOCMPFws8rNCF4E-hYs37E,3339
+aisp/base/_clusterer.py,sha256=VKwhX8oHMc7ylsSu2jnbw3uar3GHc2AMSNPMEmwrPo0,2432
+aisp/base/mutation.py,sha256=A_AlGp8S4ooFEMW3Jgv0n0Y6tbhfusaMMWFsoH4HmD8,4762
+aisp/csa/__init__.py,sha256=708jwpqia10bqmh-4-_srwwNuBh7jf2Zix-u8Hfbzmk,348
+aisp/csa/_ai_recognition_sys.py,sha256=_niEark6HNsu9ognXussura16KeCw4mi3xU4Xm18hQo,18760
+aisp/csa/_base.py,sha256=jR1IIhGINn7DLo8V5iJinDn-wW-t6etcE39bAZnQylw,3595
+aisp/csa/_cell.py,sha256=GUxnzvPyIbBm1YYkMhSx0tcV_oyDhJ7wAo5gtr_1CoY,1845
+aisp/ina/__init__.py,sha256=cOnxGcxrBdg6lLv2w2sdlToMahKMh_Gw57AfUUPQjMo,329
+aisp/ina/_ai_network.py,sha256=aNXNWdFvgmjqki7-lWApLZWq5w1OVUuZpgxsnluiqNE,21053
+aisp/ina/_base.py,sha256=x9eFUKiAcXSfwqVyBVmS54FDeIcApEtFPGruZvwQOwQ,4404
+aisp/nsa/__init__.py,sha256=3cXuBmO-_Dp3-8ZG3Eu8e_bD1JDb-RH4Wu0UDNVD1bs,385
+aisp/nsa/_base.py,sha256=3YKlZzA3yhP2uQHfhyKswbHUutlxkOR4wn6N10nSO-w,4119
+aisp/nsa/_negative_selection.py,sha256=4FA0fwGVHpSsParsUUdNnnv0FYtJS4_olZBWWiPODk8,28153
+aisp/nsa/_ns_core.py,sha256=SXkZL-p2VQygU4Pf6J5AP_yPzU4cR6aU6wx-e_vlm-c,5021
+aisp/utils/__init__.py,sha256=RzpKhkg8nCZi4G0C4il97f3ESYs7Bbxq6EjTeOQQUGk,195
+aisp/utils/_multiclass.py,sha256=nWd58ayVfxgdopBQc9b_xywkolJ2fGW3AN-JoD2A9Fw,1134
+aisp/utils/distance.py,sha256=pY23YGZpu6qVCCkZfhaEpRazUULfVUy2piyzYuAryN0,6576
+aisp/utils/metrics.py,sha256=zDAScDbHRnfu24alRcZ6fEIUaWNoCD-QCtOCFBWPPo8,1277
+aisp/utils/sanitizers.py,sha256=u1GizdJ-RKfPWJLnuFiM09lpItZMhDR_EvK8YdVHwDk,1858
+aisp/utils/types.py,sha256=KELzr1kSBT7hHdsABoIS1xmEBGj6gRSH5A5YNG36I_c,1324
+aisp/utils/validation.py,sha256=RqcS2VdFXkNcOH_7Y3yPi7FBoGWR_ReLBPDBx0UMCqI,1431
+aisp-0.3.0.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+aisp-0.3.0.dist-info/METADATA,sha256=hYtREi4OT36M5B0LgIKnnrzdQ1SZKwzYNdpIT-O7Hwg,5173
+aisp-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aisp-0.3.0.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
+aisp-0.3.0.dist-info/RECORD,,

{aisp-0.2.0.dist-info → aisp-0.3.0.dist-info}/WHEEL

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