aisp 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

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

@@ -1,16 +1,14 @@
 """Negative Selection Algorithm."""
 
+from __future__ import annotations
 from typing import Any, 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,
-    check_detector_rnsa_validity,
-)
+from ..base import set_seed_numba
+from ._ns_core import check_detector_rnsa_validity
 from ..exceptions import MaxDiscardsReachedError
 from ..utils.distance import (
     min_distance_to_class_vectors,
@@ -98,6 +96,7 @@ class RNSA(BaseNSA):
         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)
@@ -121,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).
 
@@ -148,7 +147,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 +156,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 and progress is not None:
-                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])
@@ -188,8 +185,7 @@ class RNSA(BaseNSA):
                     else:
                         radius = None
                     valid_detectors_set.append(Detector(vector_x, radius))
-                    if verbose and progress is not None:
-                        progress.update(1)
+                    progress.update(1)
                 else:
                     discard_count += 1
                     if discard_count == self.max_discards:
@@ -198,11 +194,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 and progress is not None:
-            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
@@ -340,14 +336,12 @@ 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()
 
-
     def __compare_sample_to_detectors(self, line: npt.NDArray) -> Optional[str]:
         """
         Compare a sample with the detectors, verifying if the sample is proper.
@@ -448,229 +442,4 @@ class RNSA(BaseNSA):
                 if (p - new_detector_r) < 0 or (p + new_detector_r) > 1:
                     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")
-        progress = None
-        # 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.
-        if verbose:
-            progress = tqdm(
-                total=int(self.N * (len(self.classes))),
-                bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
-                postfix="\n",
-            )
-
-        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 and progress is not None:
-                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)
-                    if verbose and progress is not None:
-                        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.
-        if verbose and progress is not None:
-            progress.set_description(
-                f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
-                f"successfully generated\033[0m"
-            )
-        # 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))
+        return True, new_detector_r

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/validation.py

@@ -14,9 +14,9 @@ def detect_vector_data_type(
     Detect the type of data in a vector.
 
     The function detects if the vector contains data of type:
-    - "binary": binary data (boolean True/False or integer 0/1)
-    - "continuous": continuous data between 0.0 and 1.0 (float)
-    - "ranged": numerical data with values outside the normalized range (float)
+    - 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
     ----------
@@ -25,8 +25,8 @@ def detect_vector_data_type(
 
     Returns
     -------
-    Literal["binary-features", "continuous-features", "ranged-features"]
-        The classified data type of the vector.
+    str
+        The data type of the vector: "binary-features", "continuous-features", or "ranged-features".
 
     Raises
     ------

{aisp-0.2.1.dist-info → aisp-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.2.1
+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>
@@ -84,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.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+aisp/__init__.py,sha256=Lw5uajT371MeIBBN6FoMYQ5jmznkO0NiM-sZVWDXkCg,708
+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=kFP58oYJP-Spk-_qI61rg0eS1jPb3Af-xQVwI9TzSnw,3373
+aisp/base/_clusterer.py,sha256=tcaZ9UOuQUHSN0qyj45aiZ1nU3QMVEeZous95JZkqtA,2466
+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=E6i1TsTjpUYnSZUCQbyGjeeaiX6K_ZPR-0HQdWKc0rQ,18871
+aisp/csa/_base.py,sha256=pUObVlUB-ugz2plH29oJJBH_7Ny0611sCI0C5kv4ho4,3593
+aisp/csa/_cell.py,sha256=GUxnzvPyIbBm1YYkMhSx0tcV_oyDhJ7wAo5gtr_1CoY,1845
+aisp/ina/__init__.py,sha256=cOnxGcxrBdg6lLv2w2sdlToMahKMh_Gw57AfUUPQjMo,329
+aisp/ina/_ai_network.py,sha256=-mp6ggEBbb4lHwD3EhHl1giAVbnfNQNARCtr7N_4Nkw,20984
+aisp/ina/_base.py,sha256=x9eFUKiAcXSfwqVyBVmS54FDeIcApEtFPGruZvwQOwQ,4404
+aisp/nsa/__init__.py,sha256=vL_HbASV6aGiiHAMx0UShqkL-ly-OYcqQLasKdu9p-M,425
+aisp/nsa/_base.py,sha256=3YKlZzA3yhP2uQHfhyKswbHUutlxkOR4wn6N10nSO-w,4119
+aisp/nsa/_binary_negative_selection.py,sha256=af5z7jjUhuAdVz4MpNOToaHmtrJQxDgiAciMUZ6dGV4,9750
+aisp/nsa/_negative_selection.py,sha256=5IaXmwUolVR3LaDQuxoBY0D4IMuIx2YrUenPAR02H9s,18792
+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.1.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+aisp-0.3.1.dist-info/METADATA,sha256=c4c4Zh31XJxi6SO0OA-4YnmSOTn-MqvZNdyRU4TolKA,5173
+aisp-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aisp-0.3.1.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
+aisp-0.3.1.dist-info/RECORD,,