.
-
----
diff --git a/docs/en/classes/Negative Selection/RNSA.md b/docs/en/classes/Negative Selection/RNSA.md
deleted file mode 100644
index 2606294..0000000
--- a/docs/en/classes/Negative Selection/RNSA.md
+++ /dev/null
@@ -1,215 +0,0 @@
-
-# RNSA (Real-Valued Negative Selection Algorithm)
-
-This class extends the [**Base**](../../advanced-guides/base/classifier.md) class.
-
-## Constructor RNSA
-
-The ``RNSA`` class has the purpose of classifying and identifying anomalies through the self and not self methods.
-
-**Attributes:**
-
-* **N** (``int``): Number of detectors. Defaults to ``100``.
-* **r** (``float``): Radius of the detector. Defaults to ``0.05``.
-* **k** (``int``): Number of neighbors near the randomly generated detectors to perform the distance average calculation. Defaults to ``1``.
-* **metric** (``str``): Way to calculate the distance between the detector and the sample:
-
- * ``'Euclidean'`` ➜ 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) ¹/ₚ , In this project ``p == 2``.
- * ``'manhattan'`` ➜ The calculation of the distance is given by the expression: ( |X₁ - X₂| + |Y₁ - Y₂| + ...+ |Yn - Yn₂|) .
-
- Defaults to ``'euclidean'``.
-
-* **max_discards** (``int``): This parameter indicates the maximum number of consecutive detector discards, aimed at preventing a possible infinite loop in case a radius is defined that cannot generate non-self detectors.
-* **seed** (``int``): Seed for the random generation of values in the detectors. Defaults to ``None``.
-
-* **algorithm** (``str``), Set the algorithm version:
-
- * ``'default-NSA'``: Default algorithm with fixed radius.
- * ``'V-detector'``: This algorithm is based on the article "[Real-Valued Negative Selection Algorithm with Variable-Sized Detectors](https://doi.org/10.1007/978-3-540-24854-5_30)", by Ji, Z., Dasgupta, D. (2004), and uses a variable radius for anomaly detection in feature spaces.
-
- Defaults to ``'default-NSA'``.
-
-* **r_s** (``float``): rₛ Radius of the ``X`` own samples.
-* ``**kwargs``:
- * *non_self_label* (``str``): This variable stores the label that will be assigned when the data has only one
- output class, and the sample is classified as not belonging to that class. Defaults to ``'non-self'``.
- * *cell_bounds* (``bool``): If set to ``True``, this option limits the generation of detectors to the space within
- the plane between 0 and 1. This means that any detector whose radius exceeds this limit is discarded,
- this variable is only used in the ``V-detector`` algorithm. Defaults to ``False``.
-
-**Other variables initiated:**
-
-* **detectors** (``dict``): This variable stores a list of detectors by class.
-* **classes** (``npt.NDArray``): list of output classes.
-
----
-
-### Method fit(...)
-
-The ``fit(...)`` function generates the detectors for non-fits with respect to the samples:
-
-```python
-def fit(
- self,
- X: Union[npt.NDArray, list],
- y: Union[npt.NDArray, list],
- verbose: bool = True,
-) -> RNSA:
-```
-
-In it, training is performed according to ``X`` and ``y``, using the negative selection method(``NegativeSelect``).
-
-The input parameters are:
-
-* **X** (`Union[npt.NDArray, list]`): array with the characteristics of the samples with **N** samples (rows) and **N** characteristics (columns).
-* **y** (`Union[npt.NDArray, list]`): array with the output classes arranged in **N** samples that are related to ``X``.
-* **verbose** (`bool`): boolean with default value ``True``, determines if the feedback from the detector generation will be printed.
-
-**Raises**
-
-* ``TypeError``: If X or y are not ndarrays or have incompatible shapes.
-* ``MaxDiscardsReachedError``: The maximum number of detector discards was reached during
- maturation. Check the defined radius value and consider reducing it.
-
-**Returns**
-
- the instance of the class.
-
----
-
-### Method predict(...)
-
-The ``predict(...)`` function performs class prediction using the generated detectors:
-
-```python
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-**The input parameter is:**
-
-* **X** (`Union[npt.NDArray, list]`): array with the characteristics for the prediction, with **N** samples (Rows) and **N** columns.
-
-**Raises:**
-
-* ``TypeError``: If X is not an ndarray or list.
-* ``FeatureDimensionMismatch``: If the number of features in X does not match the expected number.
-* ``ModelNotFittedError``: If the mode has not yet been adjusted and does not have defined detectors or classes, it is not able to predictions
-
-**Returns:**
-
-* C (``npt.NDArray``): A ndarray of the form ``C`` (n_samples), containing the predicted classes for ``X``.
-
----
-
-### Method score(...)
-
-The function ``score(...)`` calculates the accuracy of the trained model by making predictions and computing accuracy.
-
-```python
-def score(self, X: npt.NDArray, y: list) -> float:
-```
-
-It returns the accuracy as a float type.
-
----
-
-## Private Methods
-
----
-
-### Method _checks_valid_detector(...)
-
-The ``def _checks_valid_detector(...)`` function check if the detector has a valid non-proper r radius for the class.
-
-```python
-def _checks_valid_detector(
- self,
- x_class: npt.NDArray,
- vector_x: npt.NDArray
-) -> Union[bool, tuple[bool, float]]:
-```
-
-**Parameters**
-
-* **x_class** (`npt.NDArray`): Array ``x_class`` with the samples per class.
-* **vector_x** (`npt.NDArray`): Randomly generated vector x candidate detector with values between[0, 1].
-
-**Returns**
-* **Validity** (``bool``): Returns whether the detector is valid or not.
-
----
-
-### Method _compare_KnearestNeighbors_List(...)
-
-The ``def _compare_KnearestNeighbors_List(...)`` function compares the distance of the k-nearest neighbors, so if the distance of the new sample is smaller, replaces ``k-1`` and sorts in ascending order:
-
-```python
-def _compare_knearest_neighbors_list(self, knn: list, distance: float) -> None:
-```
-
-**Parameters**
-* **knn** (`list`): List of k-nearest neighbor distances.
-* **distance** (`float`): Distance to check.
-
-Returns a list of k-nearest neighbor distances.
-
----
-
-### Method _compare_sample_to_detectors(...)
-
-Function to compare a sample with the detectors, verifying if the sample is proper.
-In this function, when there is class ambiguity, it returns the class that has the greatest average distance between the detectors.
-
-```python
-def _compare_sample_to_detectors(self, line: npt.NDArray) -> Optional[str]:
-```
-
-**Parameters**
-
-* line (`npt.NDArray`): vector with N-features
-
-**Returns**
-
-The predicted class with the detectors or None if the sample does not qualify for any class.
-
----
-
-### Method _detector_is_valid_to_Vdetector(...)
-
-Check if the distance between the detector and the samples, minus the radius of the samples, is greater than the minimum radius.
-
-```python
-def _detector_is_valid_to_vdetector(
- self,
- distance: float,
- vector_x: npt.NDArray
-) -> Union[bool, tuple[bool, float]]:
-```
-
-**Parameters**
-
-* distance (``float``): minimum distance calculated between all samples.
-* vector_x (``npt.NDArray``): randomly generated candidate detector vector x with values between 0 and 1.
-
-**Returns:**
-
-* ``False``: if the calculated radius is smaller than the minimum distance or exceeds the edge of the space, if this option is enabled.
-* ``True`` and the distance minus the radius of the samples, if the radius is valid.`
-
----
-
-### Method _distance(...)
-
-The function ``def _distance(...)`` calculates the distance between two points using the technique defined in ``metric``, which are: ``'euclidean', 'norm_euclidean', or 'manhattan'``
-
-```python
-def _distance(self, u: npt.NDArray, v: npt.NDArray):
-```
-
-**Parameters**
-* **u** (`npt.NDArray`): Coordinates of the first point.
-* **v** (`npt.NDArray`): Coordinates of the second point.
-
-**Returns:**
-* distance (`float`): the distance between the two points.
diff --git a/docs/en/classes/Network Theory Algorithms/AiNet.md b/docs/en/classes/Network Theory Algorithms/AiNet.md
deleted file mode 100644
index 5973618..0000000
--- a/docs/en/classes/Network Theory Algorithms/AiNet.md
+++ /dev/null
@@ -1,271 +0,0 @@
-# AiNet (Artificial Immune Network)
-
-This class extends the [**Base**](../../advanced-guides/base/clusterer.md) class.
-
-## AiNet Constructor
-
-The ``AiNet`` class implements the Artificial Immune Network algorithm for **compression** and **clustering**.
-It uses principles from immune network theory, clonal selection, and affinity maturation to compress datasets and find clusters.
-
-For clustering, it optionally uses a **Minimum Spanning Tree (MST)** to separate distant nodes into groups.
-
-**Attributes:**
-
-* **N** (``int``): Number of memory cells (antibodies) in the population. Defaults to 50.
-* **n_clone** (``int``): Number of clones generated per selected memory cell. Defaults to 10.
-* **top_clonal_memory_size** (``Optional[int]``): Number of highest-affinity antibodies selected for cloning. Defaults to 5.
-* **n_diversity_injection** (``int``): Number of new random antibodies injected to maintain diversity. Defaults to 5.
-* **affinity_threshold** (``float``): Threshold for cell selection/suppression. Defaults to 0.5.
-* **suppression_threshold** (``float``): Threshold for removing similar memory cells. Defaults to 0.5.
-* **mst_inconsistency_factor** (``float``): Factor to determine inconsistent MST edges. Defaults to 2.0.
-* **max_iterations** (``int``): Maximum number of training iterations. Defaults to 10.
-* **k** (``int``): Number of nearest neighbors used for label prediction. Defaults to 3.
-* **metric** (Literal["manhattan", "minkowski", "euclidean"]): Way to calculate the distance between the detector and the sample:
- * ``'Euclidean'`` ➜ 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) ¹/ₚ.
- * ``'manhattan'`` ➜ The calculation of the distance is given by the expression:
- ( |x₁ - x₂| + |y₁ - y₂| + ... + |yn - yn|).
- Defaults to "Euclidean".
-
-* **seed** (``Optional[int]``): Seed for random number generation. Defaults to None.
-* **use_mst_clustering** (``bool``): Whether to perform MST-based clustering. Defaults to True.
-* **kwargs**:
- * **p** (``float``): Parameter for Minkowski distance. Defaults to 2.
-
-**Other initialized variables:**
-
-* **_population_antibodies** (``Optional[npt.NDArray]``): Stores the current set of antibodies.
-* **_memory_network** (``Dict[int, List[Cell]]``): Dictionary mapping clusters to antibodies.
-* **_mst_structure** (``Optional[npt.NDArray]``): MST adjacency structure.
-* **_mst_mean_distance** (``Optional[float]``): Mean of MST edge distances.
-* **_mst_std_distance** (``Optional[float]``): Standard deviation of MST edge distances.
-* **labels** (``Optional[npt.NDArray]``): List of cluster labels.
-
----
-
-## Public Methods
-
-### Method `fit(...)`
-
-Trains the AiNet model on input data:
-
-```python
-def fit(self, X: Union[npt.NDArray, list], verbose: bool = True) -> AiNet:
-```
-
-**Parameters:**
-
-* **X** (`Union[npt.NDArray, list]`): Array with input samples (rows) and features (columns).
-* **verbose** (`bool`): Boolean, default True, enables progress feedback.
-
-**Raises**
-
-* `TypeError`: If X is not a ndarray or list.
-* `UnsupportedTypeError`: If the data type of the vector is not supported.
-
-*Returns the class instance.*
-
----
-
-### Method `predict(...)`
-
-Predicts cluster labels for new samples:
-
-```python
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-**Parameters:**
-
-* **X** (`Union[npt.NDArray, list]`): Array of input features.
-
-**Raises**
-
-* `TypeError`: If X is not a ndarray or list.
-* `ValueError`: If the array contains values other than 0 and 1.
-* `FeatureDimensionMismatch`: If the number of features in X does not match the expected number.
-* `ModelNotFittedError`: If the mode has not yet been adjusted and does not have defined memory cells, it is not able to predictions
-
-**Returns:**
-
-* **Predictions**: Array of cluster labels, or None if clustering is disabled.
-
----
-
-### Method `update_clusters(...)`
-
-Partitions clusters using the MST:
-
-```python
-def update_clusters(self, mst_inconsistency_factor: Optional[float] = None):
-```
-
-**Parameters:**
-
-* **mst_inconsistency_factor** (`Optional[float]`): Optional float to override the MST inconsistency factor.
-
-**Updates:**
-
-* **_memory_network**: Dictionary of cluster labels to antibody arrays.
-* **labels**: List of cluster labels.
-
----
-
-## Private Methods
-
-### Method `_init_population_antibodies(...)`
-
-Initializes antibody population randomly.
-
-```python
-def _init_population_antibodies(self) -> npt.NDArray:
-```
-
-**Returns:** Initialized antibodies (`npt.NDArray`).
-
----
-
-### Method `_select_and_clone_population(...)`
-
-Selects top antibodies and generates mutated clones:
-
-```python
-def _select_and_clone_population(self, antigen: npt.NDArray, population: npt.NDArray) -> list:
-```
-
-**Parameters:**
-
-* **antigen** (`npt.NDArray`): Array representing the antigen to which affinities will be computed.
-* **population** (`npt.NDArray`): Array of antibodies to be evaluated and cloned.
-
-**Returns:** List of mutated clones.
-
----
-
-### Method `_clonal_suppression(...)`
-
-Suppresses redundant clones based on thresholds:
-
-```python
-def _clonal_suppression(self, antigen: npt.NDArray, clones: list):
-```
-
-**Parameters:**
-
-* **antigen** (`npt.NDArray`): Array representing the antigen.
-* **clones** (`list`): List of candidate clones to be suppressed.
-
-**Returns:** List of non-redundant, high-affinity clones.
-
----
-
-### Method `_memory_suppression(...)`
-
-Removes redundant antibodies from memory pool:
-
-```python
-def _memory_suppression(self, pool_memory: list) -> list:
-```
-
-**Parameters:**
-
-* **pool_memory** (`list`): List of antibodies currently in memory.
-
-**Returns:** Cleaned memory pool (`list`).
-
----
-
-### Method `_diversity_introduction(...)`
-
-Introduces new random antibodies:
-
-```python
-def _diversity_introduction(self) -> npt.NDArray:
-```
-
-**Parameters:** None
-
-**Returns:** Array of new antibodies (`npt.NDArray`).
-
----
-
-### Method `_affinity(...)`
-
-Calculates stimulus between two vectors:
-
-```python
-def _affinity(self, u: npt.NDArray, v: npt.NDArray) -> float:
-```
-
-**Parameters:**
-
-* **u** (`npt.NDArray`): Array representing the first point.
-* **v** (`npt.NDArray`): Array representing the second point.
-
-**Returns:** Affinity score (`float`) in [0,1].
-
----
-
-### Method `_calculate_affinities(...)`
-
-Calculates affinity matrix between reference and target vectors:
-
-```python
-def _calculate_affinities(self, u: npt.NDArray, v: npt.NDArray) -> npt.NDArray:
-```
-
-**Parameters:**
-
-* **u** (`npt.NDArray`): Reference vector (`npt.NDArray`) of shape `(n_features,)`.
-* **v** (`npt.NDArray`): Target vectors (`npt.NDArray`) of shape `(n_samples, n_features)`.
-
-**Returns:** Array of affinities (`npt.NDArray`) with shape `(n_samples,)`.
-
----
-
-### Method `_clone_and_mutate(...)`
-
-Generates mutated clones:
-
-```python
-def _clone_and_mutate(self, antibody: npt.NDArray, n_clone: int) -> npt.NDArray:
-```
-
-**Parameters:**
-
-* **antibody** (`npt.NDArray`): Original antibody vector to clone and mutate.
-* **n_clone** (`int`): Number of clones to generate.
-
-**Returns:** Array of mutated clones (`npt.NDArray`) of shape `(n_clone, len(antibody))`.
-
----
-
-### Method `_build_mst(...)`
-
-Constructs the MST and stores statistics.
-
-```python
-def _build_mst(self):
-```
-
-**Parameters:** None
-
-**Raises:** ValueError if antibody population is empty.
-
-**Updates internal variables:**
-
-* **_mst_structure**: MST adjacency structure.
-* **_mst_mean_distance**: Mean edge distance.
-* **_mst_std_distance**: Standard deviation of MST edge distances.
-
----
-
-## References
-
-> 1. De Castro, Leandro & José, Fernando & von Zuben, Antonio Augusto. (2001). aiNet: An Artificial Immune Network for Data Analysis.
-> Available at: [https://www.researchgate.net/publication/228378350_aiNet_An_Artificial_Immune_Network_for_Data_Analysis](https://www.researchgate.net/publication/228378350_aiNet_An_Artificial_Immune_Network_for_Data_Analysis)
-
-> 2. SciPy Documentation. *Minimum Spanning Tree*.
-> Available at: [https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csgraph.minimum_spanning_tree](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csgraph.minimum_spanning_tree)
diff --git a/docs/en/classes/Network Theory Algorithms/README.md b/docs/en/classes/Network Theory Algorithms/README.md
deleted file mode 100644
index 8171d83..0000000
--- a/docs/en/classes/Network Theory Algorithms/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Immune Network Theory
-
-This technique was introduced by **Niels Jerne (1974)** and models the immune system as a dynamic network,
-in which cells and molecules are capable of recognizing each other.
-
-## Classes
-
-1. **[AiNet](AiNet.md)**
-
-> Artificial Immune Network for unsupervised clustering and compression tasks.
----
-
-## References
-
-> BRABAZON, Anthony; O'NEILL, Michael; MCGARRAGHY, Seán. *Natural Computing Algorithms*. Springer Berlin Heidelberg, 2015. DOI: 10.1007/978-3-662-43631-8. Disponível em: [http://dx.doi.org/10.1007/978-3-662-43631-8](http://dx.doi.org/10.1007/978-3-662-43631-8).
diff --git a/docs/en/faq.md b/docs/en/faq.md
new file mode 100644
index 0000000..3ca6182
--- /dev/null
+++ b/docs/en/faq.md
@@ -0,0 +1,141 @@
+---
+id: faq
+sidebar_position: 6
+sidebar_label: FAQ
+keywords:
+ - FAQ
+ - Frequently Asked Questions
+ - Questions
+ - Help
+---
+
+# Frequently Asked Questions
+
+Quick solutions for possible questions about aisp.
+
+## General usage
+
+### Which algorithm should I choose?
+
+It depends on the type of problem:
+
+- **Anomaly detection**: Use `RNSA` or `BNSA`.
+ - RNSA for problems with continuous data.
+ - BNSA for problems with binary data.
+- **Classification**: Use `AIRS`, `RNSA`, or `BNSA`.
+ - `RNSA` and `BNSA` were implemented to be applied to multiclass classification.
+ - `AIRS` is more robust to noise in the data.
+- **Optimization**: Use `Clonalg`.
+ - The implementation can be applied to objective function optimization (min/max).
+- **Clustering**: Use `AiNet`.
+ - Automatically separates data into groups.
+ - Does not require a predefined number of clusters.
+
+---
+
+### How do I normalize my data to use the `RNSA` algorithm?
+
+RNSA works exclusively with data normalized in the range (0.0, 1.0). Therefore, before applying it, the data must be
+normalized if they are not already in this range. A simple way to do this is by using normalization tools from
+**scikit-learn**, such as
+[``MinMaxScaler``](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html).
+
+#### Example
+
+In this example, `X` represents the non-normalized input data.
+
+```python
+from sklearn.preprocessing import MinMaxScaler
+
+scaler = MinMaxScaler()
+
+x_norm = scaler.fit_transform(X)
+
+# Training the model with normalized data
+rnsa = RNSA(N=100, r=0.1)
+rnsa.fit(x_norm, y)
+```
+
+---
+
+## Parameter configuration
+
+### How do I choose the number of detectors (`N`) in `RNSA` or `BNSA`?
+
+The number of detectors directly affects performance:
+
+- A small number of detectors may not adequately cover the non-self space.
+- A very large number of detectors may increase training time and can cause overfitting.
+
+**Recommendations**:
+
+- Test different values for the number of detectors until you find a suitable balance between training time and model performance.
+- Use cross-validation to identify the value that consistently yields the best results.
+
+---
+
+### Which radius (`r` or `aff_thresh`) should I use in `BNSA` or `RNSA`?
+
+The detector radius depends on the data distribution:
+
+- A very small radius may fail to detect anomalies.
+- A very large radius may overlap the self space and never generate valid detectors.
+
+---
+
+### What is the `r_s` parameter in `RNSA`?
+
+`r_s` is the radius of the self sample. It defines a region around each training sample.
+
+---
+
+### Clonalg: How do I define the objective function?
+
+The objective function must follow the pattern of the
+[base class](https://github.com/AIS-Package/aisp/blob/main/aisp/base/core/_optimizer.py#L140).
+It must receive a solution as input and return a cost (or affinity) value.
+
+```python
+def affinity_function(self, solution: Any) -> float:
+ pass
+```
+
+There are two ways to define the objective function in Clonalg.
+
+```python
+def sphere(solution):
+ return np.sum(solution ** 2)
+```
+
+1. Defining the function directly in the class constructor
+
+```python
+clonalg = Clonalg(
+ problem_size=2,
+ affinity_function=sphere
+)
+```
+
+2. Using the function registry
+
+```python
+clonalg = Clonalg(
+ problem_size=2,
+)
+
+clonalg.register("affinity_function", sphere)
+```
+
+## Additional information
+
+### Where can I find more examples?
+
+- [Examples in the Jupyter Notebooks](../../examples/en).
+
+### How can I contribute to the project?
+
+See the [Contribution Guide](../../CONTRIBUTING.md) on GitHub.
+
+### Still have questions?
+
+- Open an [**Issue on GitHub**](https://github.com/AIS-Package/aisp/issues)
diff --git a/docs/en/index.md b/docs/en/index.md
deleted file mode 100644
index bceec53..0000000
--- a/docs/en/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
-## **INDEX**
-
----
-
-### Class module:
-
-> 1. [**Negative selection**](classes/Negative%20Selection/README.md)
-> 2. **Danger Theory**
-> 3. [**Clonal Selection Algorithms.**](classes/Clonal%20Selection%20Algorithms/README.md)
-> 4. [**Immune Network Theory**](classes/Network%20Theory%20Algorithms/README.md)
\ No newline at end of file
diff --git a/docs/pt-br/README.md b/docs/pt-br/README.md
index cef61ec..19dfaa5 100644
--- a/docs/pt-br/README.md
+++ b/docs/pt-br/README.md
@@ -1,22 +1,41 @@
+
+
+
+
+# Artificial Immune Systems Package.
+
+
+
+---
+
## Sumário
->1. [Introdução.](#introdução)
->2. [Instalação.](#instalação)
-> 1. [Dependências](#dependências)
-> 2. [Instalação do usuário](#instalação-do-usuário)
->3. [Exemplos.](#exemplos)
+1. [Introdução.](#introdução)
+2. [Instalação.](#instalação)
+ 1. [Dependências](#dependências)
+ 2. [Instalação do usuário](#instalação-do-usuário)
+3. [Exemplos.](#exemplos)
---
+## Introdução
+
+**AISP (Artificial Immune Systems Package)** é um pacote pacote python com algoritmos imunoinspirados, os quaios aplicam
+metáforas
+
+
## Introdução
-O **AISP** é um pacote python que implementa as técnicas dos sistemas imunológicos artificiais, distribuído sob a licença GNU Lesser General Public License v3.0 (LGPLv3).
+O **AISP** é um pacote python que implementa as técnicas dos sistemas imunológicos artificiais, distribuído sob a
+licença GNU Lesser General Public License v3.0 (LGPLv3).
-O pacote foi iniciado no ano de 2022, como parte de um projeto de pesquisa desenvolvido no Instituto Federal do Norte de Minas Gerais - Campus Salinas (IFNMG - Salinas).
+O pacote foi iniciado no ano de 2022, como parte de um projeto de pesquisa desenvolvido no Instituto Federal do Norte de
+Minas Gerais - Campus Salinas (IFNMG - Salinas).
-Os sistemas imunológicos artificiais (SIA) inspiram-se no sistema imunológico dos vertebrados, criando metáforas que aplicam a capacidade de reconhecer e catalogar os patógenos, entre outras características desse sistema.
+Os sistemas imunológicos artificiais (SIA) inspiram-se no sistema imunológico dos vertebrados, criando metáforas que
+aplicam a capacidade de reconhecer e catalogar os patógenos, entre outras características desse sistema.
### Algoritmos implementados
@@ -42,12 +61,12 @@ O módulo requer a instalação do [python 3.10](https://www.python.org/download
-| Pacotes | Versão |
-|:-------------:|:-------------:|
-| numpy | ≥ 1.22.4 |
-| scipy | ≥ 1.8.1 |
-| tqdm | ≥ 4.64.1 |
-| numba | ≥ 0.59.0 |
+| Pacotes | Versão |
+|:-------:|:--------:|
+| numpy | ≥ 1.22.4 |
+| scipy | ≥ 1.8.1 |
+| tqdm | ≥ 4.64.1 |
+| numba | ≥ 0.59.0 |
diff --git a/docs/pt-br/advanced-guides/base/base.md b/docs/pt-br/advanced-guides/base/base.md
deleted file mode 100644
index 97fc376..0000000
--- a/docs/pt-br/advanced-guides/base/base.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# Classe Base
-
-Classe base para introspecção de parâmetros compatível com a API do scikit-learn.
-
-## Base
-
-Classe genérica para modelos com uma interface comum.
-Fornece os métodos `get_params` e `set_params` para compatibilidade com a API do scikit-learn, permitindo acesso aos parâmetros públicos do modelo.
-
-### Função set_params(...)
-
-```python
-def set_params(self, **params) -> Base:
-```
-
-Define os parâmetros da instância. Garante compatibilidade com funções do scikit-learn.
-
-**Parâmetros:**
-
-* **params** (`dict`): Dicionário de parâmetros que serão definidos como atributos da instância. Apenas atributos públicos (que não começam com "_") são modificados.
-
-**Retorna:**
-
-* **Base**: Retorna a própria instância após definir os parâmetros.
-
----
-
-### Função get_params(...)
-
-```python
-def get_params(self, deep: bool = True) -> dict
-```
-
-Retorna um dicionário com os principais parâmetros do objeto. Garante compatibilidade com funções do scikit-learn.
-
-**Parâmetros:**
-
-* **deep** (`bool`, padrão=True): Ignorado nesta implementação, mas incluído para compatibilidade com scikit-learn.
-
-**Retorna:**
-
-* **dict:** Dicionário contendo os atributos do objeto que não começam com "_".
-
----
diff --git a/docs/pt-br/advanced-guides/base/classifier.md b/docs/pt-br/advanced-guides/base/classifier.md
deleted file mode 100644
index a833c32..0000000
--- a/docs/pt-br/advanced-guides/base/classifier.md
+++ /dev/null
@@ -1,88 +0,0 @@
-Classe base para algoritmo de classificação.
-
-# BaseClassifier
-
-Classe base para algoritmos de classificação, definindo os métodos abstratos ``fit`` e ``predict``.
-
-## Métodos
-
-### Método `score(...)`
-
-```python
-def score(
- self,
- X: Union[npt.NDArray, list],
- y: Union[npt.NDArray, list]
-) -> float:
-```
-
-A função de pontuação (score) calcula a precisão da previsão.
-
-Esta função realiza a previsão de X e verifica quantos elementos são iguais entre o vetor y e y_predicted.
-Esta função foi adicionada para compatibilidade com algumas funções do scikit-learn.
-
-**Parâmetros**:
-
-* **X** (`Union[npt.NDArray, list]`): Conjunto de características com formato (n_amostras, n_características).
-* **y** (`Union[npt.NDArray, list]`): Valores verdadeiros com formato (n_amostras,).
-
-**Retorna:**
-
-* precisão (`float`): A precisão do modelo.
-
----
-
-### Método `_slice_index_list_by_class(...)`
-
-A função ``_slice_index_list_by_class(...)``, separa os índices das linhas conforme a classe de saída, para percorrer o array de amostra, apenas nas posições que a saída for a classe que está sendo treinada:
-
-```python
-def _slice_index_list_by_class(self, y: npt.NDArray) -> dict:
-```
-
-**Parâmetros**:
-
-* **y** (`npt.NDArray`): Recebe um array ``n_samples`` com as classes de saída do array de amostras ``X``.
-
-**Retorna:**
-
-Retorna um dicionário com as classes como chave e os índices em ``X`` das amostras.
-
----
-
-## Métodos abstratos
-
-### Método `fit(...)`
-
-```python
-@abstractmethod
-def fit(
- self,
- X: Union[npt.NDArray, list],
- y: Union[npt.NDArray, list],
- verbose: bool = True
-) -> BaseClassifier:
-```
-
-Ajusta o modelo aos dados de treinamento.
-
-Implementação:
-
-* [RNSA](../../classes/Negative%20Selection/RNSA.md#método-fit)
-* [BNSA](../../classes/Negative%20Selection/BNSA.md#método-fit)
-* [AIRS](../../classes/Clonal%20Selection%20Algorithms/AIRS.md#método-fit)
-
-### Método `predict(...)`
-
-```python
-@abstractmethod
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-Realiza a previsão dos rótulos para os dados fornecidos.
-
-Implementação:
-
-* [RNSA](../../classes/Negative%20Selection/RNSA.md#método-predict)
-* [BNSA](../../classes/Negative%20Selection/BNSA.md#método-predict)
-* [AIRS](../../classes/Clonal%20Selection%20Algorithms/AIRS.md#método-predict)
diff --git a/docs/pt-br/advanced-guides/base/clusterer.md b/docs/pt-br/advanced-guides/base/clusterer.md
deleted file mode 100644
index c1ff15d..0000000
--- a/docs/pt-br/advanced-guides/base/clusterer.md
+++ /dev/null
@@ -1,79 +0,0 @@
-# BaseClusterer
-
-Classe base abstrata para algoritmos de clustering.
-
-Esta classe define a interface central para modelos de agrupamento. Ela exige
-a implementação dos métodos **`fit`** e **`predict`** em todas as classes derivadas,
-e fornece uma implementação padrão para **`fit_predict`** e **`get_params`**.
-
----
-
-## Métodos abstratos
-
-### Método `fit(...)`
-
-```python
-@abstractmethod
-def fit(self, X: Union[npt.NDArray, list], verbose: bool = True) -> BaseClusterer:
-```
-
-Ajusta o modelo aos dados de treinamento.
-Este método abstrato deve ser implementado pelas subclasses.
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): Dados de entrada utilizados para treinar o modelo.
-* **verbose** (`bool`): default=True - Indica se a saída detalhada durante o treinamento deve ser exibida.
-
-**Retorna:**
-
-* **self:** `BaseClusterer` - Instância da classe que implementa este método.
-
-**Implementações:**
-
-* [AiNet](../../../classes/Immune%20Network%20Theory/AiNet.md#método-fit)
-
----
-
-### Método `predict(...)`
-
-```python
-@abstractmethod
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-Gera previsões com base nos dados de entrada.
-Este método abstrato deve ser implementado pelas subclasses.
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): Dados de entrada para os quais as previsões serão geradas.
-
-**Retorna:**
-
-* **predictions** (`npt.NDArray`): Rótulos previstos dos clusters para cada amostra de entrada.
-
-**Implementações:**
-
-* [AiNet](../../../classes/Immune%20Network%20Theory/AiNet.md#método-predict)
-
----
-
-## Métodos
-
-### Método `fit_predict(...)`
-
-```python
-def fit_predict(self, X: Union[npt.NDArray, list], verbose: bool = True) -> npt.NDArray:
-```
-
-Método de conveniência que combina `fit` e `predict` em uma única chamada.
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): Dados de entrada para os quais as previsões serão geradas.
-* **verbose** (`bool`, default=True): Indica se a saída detalhada durante o treinamento deve ser exibida.
-
-**Retorna:**
-
-* **predictions** (`npt.NDArray`): Rótulos previstos dos clusters para cada amostra de entrada.
\ No newline at end of file
diff --git a/docs/pt-br/advanced-guides/base/immune/cell.md b/docs/pt-br/advanced-guides/base/immune/cell.md
deleted file mode 100644
index 90b9024..0000000
--- a/docs/pt-br/advanced-guides/base/immune/cell.md
+++ /dev/null
@@ -1,96 +0,0 @@
-# Cell Classes
-
-Representação de células do sistema imunológico.
-
-## Cell
-
-Representa uma célula imune básica.
-
-```python
-@dataclass(slots=True)
-class Cell:
- vector: np.ndarray
-```
-
-### Atributos
-* **vector** (`np.ndarray`): Um vetor de características da célula.
-
-### Métodos
-* `__eq__(other)`: Verifica se duas células são iguais com base em seus vetores.
-* `__array__()`: Interface de array para NumPy, permite que a instância seja tratada como um `np.ndarray`.
-* `__getitem__(item)`: Obtém elementos do vetor de características usando indexação.
-
----
-
-## BCell
-
-Representa uma célula B de memória, derivada de `Cell`.
-
-```python
-@dataclass(slots=True, eq=False)
-class BCell(Cell):
- vector: np.ndarray
-```
-
-### Métodos
-
-### hyper_clonal_mutate(...)
-
-```python
-def hyper_clonal_mutate(
- self,
- n: int,
- feature_type: FeatureType = "continuous-features",
- bounds: Optional[npt.NDArray[np.float64]] = None
-) -> npt.NDArray:
-```
-
-Clona N características das características de uma célula, gerando um conjunto de vetores mutados.
-
-#### Parâmetros
-* **n** (`int`): Número de clones a serem gerados a partir de mutações da célula original.
-* **feature_type** (`FeatureType`, padrão="continuous-features"): Especifica o tipo de características com base na natureza das características de entrada.
-* **bounds** (`Optional[npt.NDArray[np.float64]]`, padrão=None): Array (n_features, 2) com mínimo e máximo por dimensão.
-
-#### Retorna
-* **npt.NDArray**: Um array contendo N vetores mutados da célula original.
-
----
-
-## Antibody
-
-Representa um anticorpo com afinidade, derivado de `Cell`.
-
-```python
-@dataclass(slots=True)
-class Antibody(Cell):
- vector: np.ndarray
- affinity: float
-```
-
-### Atributos
-* **vector** (`npt.NDArray`): Um vetor de características da célula.
-* **affinity** (`float`): Valor de afinidade do anticorpo.
-
-### Métodos
-* `__lt__(other)`: Compara este anticorpo com outro com base na afinidade.
-* `__eq__(other)`: Verifica se dois anticorpos têm a mesma afinidade.
-
----
-
-## Detector
-
-Representa um detector não-próprio da classe RNSA.
-
-```python
-@dataclass(slots=True)
-class Detector:
- position: npt.NDArray[np.float64]
- radius: Optional[float] = None
-```
-
-### Atributos
-* **position** (`npt.NDArray[np.float64]`): Vetor de características do detector.
-* **radius** (`Optional[float]`): Raio do detector, usado no algoritmo V-detector.
-
----
\ No newline at end of file
diff --git a/docs/pt-br/advanced-guides/base/immune/mutation.md b/docs/pt-br/advanced-guides/base/immune/mutation.md
deleted file mode 100644
index e5504d8..0000000
--- a/docs/pt-br/advanced-guides/base/immune/mutation.md
+++ /dev/null
@@ -1,115 +0,0 @@
-# Mutation
-
-Contém funções que geram conjuntos de clones mutados a partir de vetores contínuos ou binários, simulando o processo de expansão clonal em sistemas imunológicos artificiais.
-
-## clone_and_mutate_continuous
-
-```python
-@njit([(types.float64[:], types.int64, types.float64)], cache=True)
-def clone_and_mutate_continuous(
- vector: npt.NDArray[np.float64],
- n: int,
- mutation_rate: float
-) -> npt.NDArray[np.float64]:
-```
-
-Gera um conjunto de clones mutados a partir de um vetor contínuo.
-
-Esta função cria `n` clones do vetor de entrada e aplica mutações aleatórias em cada um, simulando o processo de expansão clonal em sistemas imunes artificiais. Cada clone recebe um número aleatório de mutações em posições distintas do vetor original.
-
-### Parâmetros
-
-* **vector** (`npt.NDArray[np.float64]`): Vetor contínuo original que representa a célula imune a ser clonada e mutada.
-* **n** (`int`): Quantidade de clones mutados a serem gerados.
-* **mutation_rate** : (`float`) Se 0 <= mutation_rate < 1: probabilidade de mutação de cada componente.
- Se mutation_rate >= 1 ou mutation_rate <= 0: a mutação aleatoriza a quantidade de componentes entre 1 e len(vector).
-
-
-### Retorno
-
-* `clone_set` (`npt.NDArray[np.float64]`): Array com forma `(n, len(vector))` contendo os `n` clones mutados do vetor original.
-
----
-
-## clone_and_mutate_binary
-
-```python
-@njit([(types.boolean[:], types.int64, types.float64)], cache=True)
-def clone_and_mutate_binary(
- vector: npt.NDArray[np.bool_],
- n: int,
- mutation_rate: float
-) -> npt.NDArray[np.bool_]:
-```
-
-Gera um conjunto de clones mutados a partir de um vetor binário.
-
-Esta função cria `n` clones do vetor binário de entrada e aplica mutações aleatórias em alguns bits, simulando a expansão clonal em sistemas imunes artificiais com representações discretas.
-
-### Parâmetros
-
-* **vector** (`npt.NDArray[np.bool_]`): Vetor binário original que representa a célula imune a ser clonada e mutada.
-* **n** (`int`): Quantidade de clones mutados a serem gerados.
-* **mutation_rate** (`float`): Se 0 <= mutation_rate < 1: probabilidade de mutação de cada componente.
- Se mutation_rate >= 1 ou mutation_rate <= 0: a mutação aleatoriza a quantidade de componentes entre 1 e len(vector).
-
-### Retorno
-
-* `clone_set` (`npt.NDArray[np.bool_]`): Array com forma `(n, len(vector))` contendo os `n` clones mutados do vetor original.
-
----
-
-## clone_and_mutate_ranged
-
-```python
-@njit([(types.float64[:], types.int64, types.float64[:, :], types.float64)], cache=True)
-def clone_and_mutate_ranged(
- vector: npt.NDArray[np.float64],
- n: int,
- bounds: npt.NDArray[np.float64],
- mutation_rate: float,
-) -> npt.NDArray[np.float64]:
-```
-
-Gera um conjunto de clones mutados a partir de um vetor contínuo usando limites personalizados por dimensão.
-
-Esta função cria `n` clones do vetor de entrada e aplica mutações aleatórias em cada um, simulando o processo de expansão clonal em sistemas imunes artificiais. Cada clone recebe um número aleatório de mutações em posições distintas do vetor original.
-
-### Parâmetros
-
-* **vector** (`npt.NDArray[np.float64]`): Vetor contínuo original que representa a célula imune a ser clonada e mutada.
-* **n** (`int`): Quantidade de clones mutados a serem gerados.
-* **bounds** (`npt.NDArray[np.float64]`): Um array 2D com formato `(2, len(vector))` contendo os valores mínimo e máximo para cada dimensão.
-* **mutation_rate** : (`float`) Se 0 <= mutation_rate < 1: probabilidade de mutação de cada componente.
- Se mutation_rate >= 1 ou mutation_rate <= 0: a mutação aleatoriza a quantidade de componentes entre 1 e len(vector).
-
-### Retorna
-
-* `clone_set` (`npt.NDArray[np.float64]`): Array com forma `(n, len(vector))` contendo os `n` clones mutados do vetor original.
-
----
-
-## clone_and_mutate_permutation
-
-```python
-@njit([(types.int64[:], types.int64, types.float64)], cache=True)
-def clone_and_mutate_permutation(
- vector: npt.NDArray[np.int64],
- n: int,
- mutation_rate: float
-) -> npt.NDArray[np.int64]:
-```
-
-Gera um conjunto de clones mutados a partir de um vetor de permutação.
-
-Esta função cria `n` clones do vetor de permutação de entrada e aplica mutações aleatórias em cada um, simulando a expansão clonal em sistemas imunes artificiais com permutações discretas. Cada clone recebe um número aleatório de trocas de elementos de acordo com a taxa de mutação.
-
-### Parâmetros
-
-* **vector** (`npt.NDArray[np.int64]`): A célula imune original com valores de permutação a serem clonados e mutados.
-* **n** (`int`): Número de clones mutados a serem gerados.
-* **mutation_rate** (`float`): Probabilidade de mutação de cada componente (0 <= mutation_rate < 1).
-
-### Retorna
-
-* `clone_set` (`npt.NDArray[np.int64]`): Array com dimensão `(n, len(vector))` contendo os `n` clones mutados do vetor original.
diff --git a/docs/pt-br/advanced-guides/base/immune/populations.md b/docs/pt-br/advanced-guides/base/immune/populations.md
deleted file mode 100644
index efefca1..0000000
--- a/docs/pt-br/advanced-guides/base/immune/populations.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Populations Module
-
-Fornece funções utilitárias para gerar populações de anticorpos em algoritmos imunológicos.
-
-# generate_random_antibodies(...)
-
-```python
-def generate_random_antibodies(
- n_samples: int,
- n_features: int,
- feature_type: FeatureTypeAll = "continuous-features",
- bounds: Optional[npt.NDArray[np.float64]] = None,
-) -> npt.NDArray:
-```
-
-Gera uma população aleatória de anticorpos
-
-**Parâmetros**:
-* **n_samples** (`int`): Número de anticorpos (amostras) a serem gerados.
-* **n_features** (`int`): Número de características (dimensões) de cada anticorpo.
-* **feature_type** (`FeatureTypeAll`, default="continuous-features"): Especifica o tipo de características:: "continuous-features", "binary-features", "ranged-features", or "permutation-features".
-* **bounds** (`Optional[npt.NDArray[np.float64]]`, default=None): Array (2, n_features) com valores mínimo e máximo por dimensão.
-
-**Returns**:
-* **npt.NDArray**: Array com forma (n_samples, n_features) contendo os anticorpos gerados.
-
-**Raises**:
-* **ValueError**: Se o número de características for menor que 0.
\ No newline at end of file
diff --git a/docs/pt-br/advanced-guides/base/optimizer.md b/docs/pt-br/advanced-guides/base/optimizer.md
deleted file mode 100644
index 066b153..0000000
--- a/docs/pt-br/advanced-guides/base/optimizer.md
+++ /dev/null
@@ -1,160 +0,0 @@
-# BaseOptimizer
-
-Classe base para algoritmos de otimização
-
-Esta classe define a interface central para estratégias de otimização e mantém o histórico de custos, soluções
-avaliadas e a melhor solução encontrada. Subclasses devem implementar os métodos `optimize` e `affinity_function`.
-
----
-
-## Propriedades
-
-### Propriedade `cost_history`
-
-```python
-@property
-def cost_history(self) -> List[float]
-```
-
-Retorna o histórico de custos durante a otimização.
-
----
-
-### Propriedade `solution_history`
-
-```python
-@property
-def solution_history(self) -> List
-```
-
-Retorna o histórico de soluções avaliadas.
-
----
-
-### Propriedade `best_solution`
-
-```python
-@property
-def best_solution(self) -> Optional[Any]
-```
-
-Retorna a melhor solução encontrada até o momento, ou `None` se não disponível.
-
----
-
-### Propriedade `best_cost`
-
-```python
-@property
-def best_cost(self) -> Optional[float]
-```
-
-Retorna o custo da melhor solução encontrada até o momento, ou `None` se não disponível.
-
----
-
-## Métodos
-
-### Método `_record_best(...)`
-
-```python
-def _record_best(self, cost: float, best_solution: Any) -> None
-```
-
-Registra um novo valor de custo e atualiza a melhor solução se houver melhoria.
-
-**Parâmetros**:
-
-* **cost** (`float`): Valor de custo a ser adicionado ao histórico.
-
----
-
-### Método `get_report()`
-
-```python
-def get_report(self) -> str
-```
-
-Gera um relatório resumido e formatado do processo de otimização. O relatório inclui a melhor solução, seu custo
-associado e a evolução dos valores de custo por iteração.
-
-**Retorna**:
-
-* **report** (`str`): String formatada contendo o resumo da otimização.
-
----
-
-### Método `register(...)`
-
-```python
-def register(self, alias: str, function: Callable[..., Any]) -> None
-```
-
-Registra dinamicamente uma função na instância do otimizador.
-
-**Parâmetros**:
-
-* **alias** (`str`): Nome usado para acessar a função como atributo.
-* **function** (`Callable[..., Any]`): Callable a ser registrado.
-
-**Exceções**:
-
-* **TypeError**: Se `function` não for Callable.
-* **AttributeError**: Se `alias` for protegido e não puder ser modificado, ou se `alias` não existir na classe do otimizador.
-
----
-
-### Método `reset()`
-
-```python
-def reset(self)
-```
-
-Reinicia o estado interno do objeto, limpando o histórico e resetando os valores.
-
----
-
-## Métodos abstratos
-
-### Método `optimize(...)`
-
-```python
-@abstractmethod
-def optimize(
- self,
- max_iters: int = 50,
- n_iter_no_change: int = 10,
- verbose: bool = True
-) -> Any:
-```
-
-Executa o processo de otimização. Este método deve ser implementado pela subclasse para definir como a estratégia de
-otimização explora o espaço de busca.
-
-**Parâmetros**:
-
-* **max_iters** (`int`, padrão=50): Número máximo de iterações.
-* **n_iter_no_change** (`int`, padrão=10): Número máximo de iterações sem atualização da melhor solução.
-* **verbose**: (`bool`, padrão=True): Flag para habilitar ou desabilitar saída detalhada durante a otimização.
-
-**Retorna**:
-
-* **best_solution** (`Any`): A melhor solução encontrada pelo algoritmo de otimização.
-
----
-
-### Método `affinity_function(...)`
-
-```python
-def affinity_function(self, solution: Any) -> float
-```
-
-Avalia a afinidade de uma solução candidata. Este método deve ser implementado pela subclasse para definir o problema específico.
-
-**Parâmetros**:
-
-* **solution** (`Any`): Solução candidata a ser avaliada.
-
-**Retorna**:
-
-* **cost** (`float`): Valor de custo associado à solução fornecida.
diff --git a/docs/pt-br/advanced-guides/core/Negative Selection.md b/docs/pt-br/advanced-guides/core/Negative Selection.md
deleted file mode 100644
index d274938..0000000
--- a/docs/pt-br/advanced-guides/core/Negative Selection.md
+++ /dev/null
@@ -1,93 +0,0 @@
-# Seleção Negativa
-
-As funções realizam verificações de detectores e utilizam decoradores Numba para compilação Just-In-Time.
-
-## Função `check_detector_bnsa_validity(...)`
-
-```python
-@njit([(types.boolean[:, :], types.boolean[:], types.float64)], cache=True)
-def check_detector_bnsa_validity(
- x_class: npt.NDArray[np.bool_],
- vector_x: npt.NDArray[np.bool_],
- aff_thresh: float
-) -> bool:
-```
-
-Verifica a validade de um candidato a detector (vector_x) contra amostras de uma classe (x_class) usando a distância de Hamming. Um detector é considerado INVÁLIDO se a sua distância para qualquer amostra em ``x_class`` for menor ou igual a ``aff_thresh``.
-
-**Os parâmetros de entrada são:**
-
-* **x_class** (``npt.NDArray[np.bool_]``): Array contendo as amostras da classe. Formato esperado: (n_amostras, n_características).
-* **vector_x** (``npt.NDArray[np.bool_]``): Array representando o detector. Formato esperado: (n_características,).
-* **aff_thresh** (``float``): Limiar de afinidade.
-
-**Retorna:**
-
-* True se o detector for válido, False caso contrário.
-
----
-
-## Função `bnsa_class_prediction(...)`
-
-```python
-@njit([(types.boolean[:], types.boolean[:, :, :], types.float64)], cache=True)
-def bnsa_class_prediction(
- features: npt.NDArray[np.bool_],
- class_detectors: npt.NDArray[np.bool_],
- aff_thresh: float,
-) -> int:
-```
-
-Define a classe de uma amostra a partir dos detectores não-próprios.
-
-**Os parâmetros de entrada são:**
-
-* **features** (``npt.NDArray[np.bool_]``): amostra binária a ser classificada (shape: n_features).
-* **class_detectors** (``npt.NDArray[np.bool_]``): Matriz contendo os detectores de todas as classes (shape: n_classes, n_detectors, n_features).
-* **aff_thresh** (``float``): Limiar de afinidade que determina se um detector reconhece a amostra como não-própria.
-
-**Retorna:**
-
-* `int`: Índice da classe predita. Retorna -1 se for não-própria para todas as classes.
-
----
-
-## Função `check_detector_rnsa_validity(...)`
-
-```python
-@njit(
- [
- (
- types.float64[:, :],
- types.float64[:],
- types.float64,
- types.int32,
- types.float64,
- )
- ],
- cache=True,
-)
-def check_detector_rnsa_validity(
- x_class: npt.NDArray[np.float64],
- vector_x: npt.NDArray[np.float64],
- threshold: float,
- metric: int,
- p: float,
-) -> bool:
-```
-
-Verifica a validade de um candidato a detector (vector_x) contra amostras de uma classe (x_class) usando a distância de Hamming. Um detector é considerado INVÁLIDO se a sua distância para qualquer amostra em ``x_class`` for menor ou igual a ``aff_thresh``.
-
-**Os parâmetros de entrada são:**
-
-* **x_class** (``npt.NDArray[np.float64]``): Array contendo as amostras da classe. Formato esperado: (n_amostras, n_características).
-* **vector_x** (``npt.NDArray[np.float64]``): Array representando o detector. Formato esperado: (n_características,).
-* **threshold** (``float``): Afinidade.
-* **metric** (``int``): Métrica de distância a ser utilizada. Opções disponíveis: 0 (Euclidean), 1 (Manhattan), 2 (Minkowski).
-* **p** (``float``): Parâmetro da métrica de Minkowski (utilizado apenas se `metric` for "minkowski").
-
-**Retorna:**
-
-* `True` se o detector for válido, `False` caso contrário.
-
----
diff --git a/docs/pt-br/advanced-guides/utils.md b/docs/pt-br/advanced-guides/utils.md
deleted file mode 100644
index b69a951..0000000
--- a/docs/pt-br/advanced-guides/utils.md
+++ /dev/null
@@ -1,609 +0,0 @@
-# Utils
-
-Funções de utilidade para o desenvolvimento.
-
-## Métricas (Metrics)
-
-### Função `accuracy_score(...)`
-
-```python
-def accuracy_score(
- y_true: Union[npt.NDArray, list],
- y_pred: Union[npt.NDArray, list]
-) -> float:
-```
-
-Função para calcular a acurácia de precisão com base em listas de rótulos
-verdadeiros e nos rótulos previstos.
-
-**Parâmetros:**
-
-* **y_true** (``Union[npt.NDArray, list]``): Rótulos verdadeiros (corretos)..
-* **y_pred** (``Union[npt.NDArray, list]``): Rótulos previstos.
-
-**Retorna:**
-
-* **Precisão** (``float``): A proporção de previsões corretas em relação
- ao número total de previsões.
-
-**Exceções:**
-
-* `ValueError`: Se `y_true` ou `y_pred` estiverem vazios ou se não
- tiverem o mesmo tamanho.
-
----
-
-## Multiclass
-
-### Função `predict_knn_affinity(...)`
-
-```python
-def predict_knn_affinity(
- X: npt.NDArray,
- k: int,
- all_cell_vectors: List[Tuple[Union[str, int], npt.NDArray]],
- affinity_func: Callable[[npt.NDArray, npt.NDArray], float]
-) -> npt.NDArray
-```
-
-Função para prever classes usando k-vizinhos mais próximos e células treinadas.
-
-**Parâmetros:**
-
-* **X** (`npt.NDArray`): Dados de entrada a serem classificados.
-* **k** (`int`): Número de vizinhos mais próximos a considerar para a previsão.
-* **all_cell_vectors** (`List[Tuple[Union[str, int], npt.NDArray]]`): Lista de tuplas contendo pares (nome_da_classe, vetor_da_célula).
-* **affinity_func** (`Callable[[npt.NDArray, npt.NDArray], float]`): Função que recebe dois vetores e retorna um valor de afinidade.
-
-**Retorna:**
-
-* `npt.NDArray`: Array de rótulos previstos para cada amostra em X, baseado nos k vizinhos mais próximos.
-
----
-
-### Função `slice_index_list_by_class(...)`
-
-```python
-def slice_index_list_by_class(classes: Optional[Union[npt.NDArray, list]], y: npt.NDArray) -> dict
-```
-
-A função ``slice_index_list_by_class(...)``, separa os índices das amostras
-conforme a classe de saída, para percorrer o array de amostra apenas nas posições
-onde a saída corresponde à classe sendo treinada.
-
-**Parâmetros:**
-
-* **classes** (`Optional[Union[npt.NDArray, list]]`): Lista com classes únicas. Se None, retorna um dicionário vazio.
-* **y** (`npt.NDArray`): Array com as classes de saída do array de amostra ``X``.
-
-**Retorna:**
-
-* `dict`: Um dicionário com a lista de posições do array, com as classes como chave.
-
-**Exemplos:**
-
-```python
->>> import numpy as np
->>> labels = ['a', 'b', 'c']
->>> y = np.array(['a', 'c', 'b', 'a', 'c', 'b'])
->>> slice_index_list_by_class(labels, y)
-{'a': [0, 3], 'b': [2, 5], 'c': [1, 4]}
-```
-
-## Sanitizers
-
-### Função `sanitize_choice(...)`
-
-```python
-def sanitize_choice(value: T, valid_choices: Iterable[T], default: T) -> T
-```
-
-A função ``sanitize_choice(...)``, retorna o valor se estiver presente no conjunto de opções válidas; caso contrário, retorna o valor padrão.
-
-**Parâmetros:**
-
-* **value** (``T``): O valor a ser verificado.
-* **valid_choices** (``Iterable[T]``): Uma coleção de opções válidas.
-* **default**: O valor padrão a ser retornado se ``value`` não estiver em ``valid_choices``.
-
-**Returns:**
-
-* `T`: O valor original, se válido, ou o valor padrão, se não.
-
----
-
-### Função `sanitize_param(...)`
-
-```python
-def sanitize_param(value: T, default: T, condition: Callable[[T], bool]) -> T:
-```
-
-A função ``sanitize_param(...)``, retorna o valor se ele satisfizer a condição especificada; caso contrário, retorna o valor padrão.
-
-**Parâmetros:**
-
-* **value** (``T``): O valor a ser verificado.
-* **default** (``T``): O valor padrão a ser retornado se a condição não for satisfeita.
-* **condition** (``Callable[[T], bool]``): Uma função que recebe um valor e retorna um booleano, determinando se o valor é válido.
-
-**Returns:**
-
-* `T`: O valor original se a condição for satisfeita, ou o valor padrão se não for.
-
----
-
-### Função `sanitize_seed(...)`
-
-```python
-def sanitize_seed(seed: Any) -> Optional[int]:
-```
-
-A função ``sanitize_seed(...)``, retorna a semente se for um inteiro não negativo; caso contrário, retorna Nenhum.
-
-**Parâmetros:**
-
-* **seed** (``Any``): O valor da seed a ser validado.
-
-**Returns:**
-
-* ``Optional[int]``: A seed original se for um inteiro não negativo, ou ``None`` se for inválido.
-
----
-
-### Função `sanitize_bounds(...)`
-
-```python
-def sanitize_bounds(bounds: Any, problem_size: int) -> Dict[str, npt.NDArray[np.float64]]
-```
-
-A função `sanitize_bounds(...)` valida e normaliza os limites das características (features).
-
-**Parâmetros**:
-
-* **bounds** (`Any`): Os limites de entrada, que devem ser `None` ou um dicionário com as chaves `'low'` e `'high'`.
-* **problem_size** (`int`): O tamanho esperado para as listas de limites normalizadas, correspondente ao número de features do problema.
-
-**Retorna**:
-
-* `Dict[str, list]`: Dicionário no formato `{'low': [low_1, ..., low_N], 'high': [high_1, ..., high_N]}`.
-
-## Distance
-
-Funções utilitárias para distância normalizada entre matrizes com decoradores numba.
-
-### Função `hamming(...)`
-
-```python
-@njit([(types.boolean[:], types.boolean[:])], cache=True)
-def hamming(u: npt.NDArray[np.bool_], v: npt.NDArray[np.bool_]) -> float64:
-```
-
-Função para calcular a distância de Hamming normalizada entre dois pontos.
-
-$((x₁ ≠ x₂) + (y₁ ≠ y₂) + ... + (yn ≠ yn)) / n$
-
-**Parâmetros:**
-
-* **u** (``npt.NDArray[np.bool_]``): Coordenadas do primeiro ponto
-* **v** (``npt.NDArray[np.bool_]``): Coordenadas do segundo ponto.
-
-**Returns:**
-
-* Distância (``float64``) entre os dois pontos.
-
----
-
-### Função `euclidean(...)`
-
-```python
-@njit()
-def euclidean(u: npt.NDArray[np.float64], v: npt.NDArray[np.float64]) -> float64:
-```
-
-Função para calcular a distância euclidiana normalizada entre dois pontos.
-
-$√( (x₁ - x₂)² + (y₁ - y₂)² + ... + (yn - yn)²)$
-
-**Parâmetros:**
-
-* **u** (``npt.NDArray[np.float64]``): Coordenadas do primeiro ponto
-* **v** (``npt.NDArray[np.float64]``): Coordenadas do segundo ponto.
-
-**Returns:**
-
-* Distância (``float64``) entre os dois pontos.
-
----
-
-### Função `cityblock(...)`
-
-```python
-@njit()
-def cityblock(u: npt.NDArray[float64], v: npt.NDArray[float64]) -> float64:
-```
-
-Função para calcular a distância Manhattan normalizada entre dois pontos.
-
-$(|x₁ - x₂| + |y₁ - y₂| + ... + |yn - yn|) / n$
-
-**Parâmetros:**
-
-* **u** (``npt.NDArray[float64]``): Coordenadas do primeiro ponto
-* **v** (``npt.NDArray[float64]``): Coordenadas do segundo ponto.
-
-**Returns:**
-
-* Distância (``float64``) entre os dois pontos.
-
----
-
-### Função `minkowski(...)`
-
-```python
-@njit()
-def minkowski(
- u: npt.NDArray[float64],
- v: npt.NDArray[float64],
- p: float = 2.0
-) -> float64:
-```
-
-Função para calcular a distância de Minkowski normalizada entre dois pontos.
-
-$(( |X₁ - Y₁|p + |X₂ - Y₂|p + ... + |Xn - Yn|p) ¹/ₚ) / n$
-
-**Parâmetros:**
-
-* **u** (``npt.NDArray[float64]``): Coordenadas do primeiro ponto.
-* **v** (``npt.NDArray[float64]``): Coordenadas do segundo ponto.
-* **p** (``float``, padrão=2.0): O parâmetro p define o tipo de distância a ser calculada:
- * p = 1: Distância **Manhattan** - soma das diferenças absolutas.
- * p = 2: Distância **Euclidiana** - soma das diferenças ao quadrado (raiz quadrada).
- * p > 2: Distância **Minkowski** com uma penalidade crescente à medida que p aumenta.
-
-**Returns:**
-
-* Distância (``float``) entre os dois pontos.
-
----
-
-### Função `compute_metric_distance(...)`
-
-```python
-@njit([(types.float64[:], types.float64[:], types.int32, types.float64)], cache=True)
-def compute_metric_distance(
- u: npt.NDArray[float64],
- v: npt.NDArray[float64],
- metric: int,
- p: float = 2.0
-) -> float64:
-```
-
-Função para calcular a distância entre dois pontos pela ``métrica`` escolhida.
-
-**Parâmetros:**
-
-* **u** (``npt.NDArray[float64]``): Coordenadas do primeiro ponto.
-* **v** (``npt.NDArray[float64]``): Coordenadas do segundo ponto.
-* **metric** (``int``): Métrica de distância a ser utilizada. Opções disponíveis: 0 (Euclidean), 1 (Manhattan), 2 (Minkowski).
-* **p** (``float``, padrão=2.0): Parâmetro da métrica de Minkowski (utilizado apenas se `metric` for "minkowski").
-
-**Returns:**
-
-* Distância (``double``) entre os dois pontos com a métrica selecionada.
-
----
-
-### Função `min_distance_to_class_vectors(...)`
-
-```python
-@njit([(types.float64[:, :], types.float64[:], types.int32, types.float64)], cache=True)
-def min_distance_to_class_vectors(
- x_class: npt.NDArray[float64],
- vector_x: npt.NDArray[float64],
- metric: int,
- p: float = 2.0,
-) -> float:
-```
-
-Calcula a menor distância entre um vetor de entrada e os vetores de uma classe.
-
-**Parâmetros:**
-
-* **x_class** (``npt.NDArray``): Array contendo os vetores da classe com os quais o vetor de entrada será comparado. Formato esperado: (n_amostras, n_características).
-* **vector_x** (``npt.NDArray``): Vetor a ser comparado com os vetores da classe. Formato esperado: (n_características,).
-* **metric** (``int``): Métrica de distância a ser utilizada. Opções disponíveis: 0 (Euclidean), 1 (Manhattan), 2 (Minkowski), 3 (Hamming).
-* **p** (``float``): Parâmetro da métrica de Minkowski (utilizado apenas se `metric` for "minkowski").
-
-**Returns:**
-
-* float: A menor distância calculada entre o vetor de entrada e os vetores da classe.
-* Retorna -1.0 se as dimensões de entrada forem incompatíveis.
-
----
-
-### Função `get_metric_code(...)`
-
-```python
-def get_metric_code(metric: str) -> int:
-```
-
-Retorna o código numérico associado a uma métrica de distância.
-
-**Parâmetros:**
-
-* **metric** (``str``): Nome da métrica. Pode ser "euclidean", "manhattan", "minkowski" ou "hamming".
-
-**Raises**
-
-* ``ValueError``: Se a métrica informada não for suportada.
-
-**Returns:**
-
-* ``int``: Código numérico correspondente à métrica.
-
----
-
-## Validation
-
-### Função `detect_vector_data_type(...)`
-
-```python
-def detect_vector_data_type(
- vector: npt.NDArray
-) -> FeatureType:
-```
-
-Detecta o tipo de dado em um determinado vetor.
-
-Esta função analisa o vetor de entrada e classifica seus dados como um dos tipos suportados:
-
-* **binário**: Valores booleanos (`True`/`False`) ou inteiro `0`/`1`.
-* **contínuo**: Valores float dentro do intervalo normalizado `[0.0, 1.0]`.
-* **intervalo**: Valores float fora do intervalo normalizado.
-
-**Parâmetros:**
-
-* **vector** (`npt.NDArray`): Um array contendo os dados a serem classificados.
-
-**Retorna:**
-
-* `FeatureType` (`Literal["binary-features", "continuous-features", "ranged-features"]`): O tipo de dado detectado no vetor.
-
-**Gera:**
-
-* `UnsupportedDataTypeError`: Gerado se o vetor contiver um tipo de dado não suportado.
-
----
-
-### Função `check_array_type(...)`
-
-```python
-def check_array_type(x, name: str = "X") -> npt.NDArray:
-```
-
-Garante que o parâmetro recebido é um array numpy. Converte de lista se necessário.
-
-**Parâmetros:**
-
-* **x**: Array ou lista contendo as amostras e características.
-* **name**: Nome da variável para mensagens de erro.
-
-**Retorna:**
-
-* `npt.NDArray`: O array convertido ou validado.
-
-**Exceções:**
-
-* `TypeError`: Se não for possível converter para ndarray.
-
----
-
-### Função `check_shape_match(...)`
-
-```python
-def check_shape_match(x: npt.NDArray, y: npt.NDArray):
-```
-
-Garante que os arrays `x` e `y` possuem o mesmo número de amostras (primeira dimensão).
-
-**Parâmetros:**
-
-* **x**: Array de amostras.
-* **y**: Array de classes alvo.
-
-**Exceções:**
-
-* `TypeError`: Se as dimensões não forem compatíveis.
-
----
-
-### Função `check_feature_dimension(...)`
-
-```python
-def check_feature_dimension(x: npt.NDArray, expected: int):
-```
-
-Garante que o array possui o número esperado de características (features).
-
-**Parâmetros:**
-
-* **x**: Array de entrada para predição.
-* **expected**: Número esperado de características por amostra.
-
-**Exceções:**
-
-* `FeatureDimensionMismatch`: Se o número de características não corresponder ao esperado.
-
----
-
-### Função `check_binary_array(...)`
-
-```python
-def check_binary_array(x: npt.NDArray):
-```
-
-Garante que o array contém apenas valores 0 e 1.
-
-**Parâmetros:**
-
-* **x**: Array a ser verificado.
-
-**Exceções:**
-
-* `ValueError`: Se o array contiver valores diferentes de 0 e 1.
-
----
-
-## Display
-
-Funções utilitárias para exibir informações de algoritmos
-
-### Função `_supports_box_drawing()`
-
-```python
-def _supports_box_drawing() -> bool
-```
-
-Função para verificar se o terminal suporta caracteres de borda.
-
-**Retorna**:
-
-* **bool** (`bool`): True se o terminal provavelmente suporta caracteres de borda, False caso contrário.
-
----
-
-### class TableFormatter
-
-Classe para formatar dados tabulares em strings para exibição no console.
-
-**Parâmetros**:
-
-* **headers** (`Mapping[str, int]`): Mapeamento dos nomes das colunas para suas larguras respectivas, no formato `{nome_coluna: largura_coluna}`.
-
-**Exceções**:
-
-* `ValueError`: Se `headers` estiver vazio ou não for um mapeamento válido.
-
----
-
-#### Função `_border(left, middle, right, line, new_line=True)`
-
-```python
-def _border(self, left: str, middle: str, right: str, line: str, new_line: bool = True) -> str
-```
-
-Cria uma borda horizontal para a tabela.
-
-**Parâmetros**:
-
-* **left** (`str`): Caractere na borda esquerda.
-* **middle** (`str`): Caractere separador entre colunas.
-* **right** (`str`): Caractere na borda direita.
-* **line** (`str`): Caractere usado para preencher a borda.
-* **new_line** (`bool`, opcional): Se True, adiciona uma quebra de linha antes da borda (padrão é True).
-
-**Retorna**:
-
-* **border** (`str`): String representando a borda horizontal.
-
----
-
-#### Função `get_header()`
-
-```python
-def get_header(self) -> str
-```
-
-Gera o cabeçalho da tabela, incluindo a borda superior, os títulos das colunas e a linha separadora.
-
-**Retorna**:
-
-* **header** (`str`): String formatada do cabeçalho da tabela.
-
----
-
-#### Função `get_row(values)`
-
-```python
-def get_row(self, values: Mapping[str, Union[str, int, float]]) -> str
-```
-
-Gera uma linha formatada para os dados da tabela.
-
-**Parâmetros**:
-
-* **values** (`Mapping[str, Union[str, int, float]]`): Dicionário com os valores de cada coluna, no formato `{nome_coluna: valor}`.
-
-**Retorna**:
-
-* **row** (`str`): String formatada da linha da tabela.
-
----
-
-#### Função `get_bottom(new_line=False)`
-
-```python
-def get_bottom(self, new_line: bool = False) -> str
-```
-
-Gera a borda inferior da tabela.
-
-**Parâmetros**:
-
-* **new_line** (`bool`, opcional): Se True, adiciona uma quebra de linha antes da borda (padrão é False).
-
-**Retorna**:
-
-* **bottom** (`str`): String formatada da borda inferior.
-
----
-
-### class ProgressTable(TableFormatter)
-
-Classe para exibir uma tabela formatada no console para acompanhar o progresso de um algoritmo.
-
-**Parâmetros**:
-
-* **headers** (`Mapping[str, int]`): Mapeamento `{nome_coluna: largura_coluna}`.
-* **verbose** (`bool`, padrão=True): Se False, não imprime nada no terminal.
-
-**Exceções**:
-
-* `ValueError`: Se `headers` estiver vazio ou não for um mapeamento válido.
-
----
-
-#### Função `_print_header()`
-
-```python
-def _print_header(self) -> None
-```
-
-Imprime o cabeçalho da tabela.
-
----
-
-#### Função `update(values)`
-
-```python
-def update(self, values: Mapping[str, Union[str, int, float]]) -> None
-```
-
-Adiciona uma nova linha de valores à tabela.
-
-**Parâmetros**:
-
-* **values** (`Mapping[str, Union[str, int, float]]`): As chaves devem corresponder às colunas definidas em `headers`.
-
----
-
-#### Função `finish()`
-
-```python
-def finish(self) -> None
-```
-
-Encerra a exibição da tabela, imprimindo a borda inferior e o tempo total.
-
----
diff --git a/docs/pt-br/api/base/README.md b/docs/pt-br/api/base/README.md
new file mode 100644
index 0000000..99b354e
--- /dev/null
+++ b/docs/pt-br/api/base/README.md
@@ -0,0 +1,33 @@
+---
+id: base
+sidebar_label: aisp.base
+keywords:
+ - base
+ - imune
+ - abstrato
+---
+
+# aisp.base
+
+Classe base e utilitários centrais
+
+> **Módulos:** `aisp.base`
+
+## Visão geral
+
+Este modulo fornece as classes e utilidades fundamentais para todos os algoritmos de sistemas imunológicos artificiais
+implementados no AISP.
+
+## Classes
+
+| Class | Descrição |
+|------------------------------------------|--------------------------------------------------------|
+| [`BaseClassifier`](./base-classifier.md) | Classe base abstrata para algoritmos de classificação. |
+| [`BaseClusterer`](./base-clusterer.md) | Classe base abstrata para algoritmos de clustering. |
+| [`BaseOptimizer`](./base-optimizer.md) | Classe base abstrata para algoritmos de otimização. |
+
+## Submódulos
+
+| Módulo | Descrição |
+|--------------------------------|----------------------------------------------------------|
+| [`immune`](./immune/README.md) | Módulo de suporte para sistemas imunológicos artificias. |
\ No newline at end of file
diff --git a/docs/pt-br/api/base/base-classifier.md b/docs/pt-br/api/base/base-classifier.md
new file mode 100644
index 0000000..50b1748
--- /dev/null
+++ b/docs/pt-br/api/base/base-classifier.md
@@ -0,0 +1,133 @@
+---
+id: base-classifier
+sidebar_label: BaseClassifier
+keywords:
+ - base
+ - classificação
+ - classificação interface
+ - pontuação de acurácia
+ - fit
+ - predict
+tags:
+ - classificador
+ - classificação
+---
+
+# BaseClassifier
+
+Classe base abstrata para algoritmos de classificação.
+
+> **Módulo:** `aisp.base`
+> **Importação:** `from aisp.base import BaseClassifier`
+
+---
+
+## Visão geral
+
+Esta classe define a interface principal para algoritmos de classificação.
+Ela define a implementação dos metodos `fit` e `predict` em todas as classes derivadas, e fornece uma implementação
+do método `score`.
+
+Caso de uso:
+
+- Classe base abstrata para estender classes de algoritmos de classificação.
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|-------------------------|:------:|----------------------------------------------------------------|
+| `classes` | `Optional[npt.NDArray]` | `None` | Rótulos das classes identificado de `y` durante o treinamento. |
+
+---
+
+## Métodos abstratos
+
+### fit
+
+```python
+@abstractmethod
+def fit(
+ self,
+ X: Union[npt.NDArray, list],
+ y: Union[npt.NDArray, list],
+ verbose: bool = True
+) -> BaseClassifier:
+ ...
+```
+
+Treine o modelo usando os dados de entrada X e seus rótulos correspondentes y.
+Este método abstrato é implementado é responsabilidade das classes filhas.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `y` | `Union[npt.NDArray, list]` | - | Vetor alvo no formato (n_samples,). Deve conter o mesmo número de amostras que X. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+---
+
+### predict
+
+```python
+@abstractmethod
+def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
+ ...
+```
+
+Gera previsões com base nos dados de entrada X.
+Este método abstrato é implementado é responsabilidade das classes filhas.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|----------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada. Deve ter o mesmo número de características usadas no treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|--------------------------------------------------|
+| `npt.NDArray` | Array com as previsões para cada amostra de `X`. |
+
+---
+
+## Métodos públicos
+
+### score
+
+```python
+def score(
+ self,
+ X: Union[npt.NDArray, list],
+ y: Union[npt.NDArray, list]
+) -> float:
+ ...
+```
+
+A função calcula o desempenho do modelo nas previsões utilizando a métrica de acurácia.
+
+Esta função realiza a previsão de X e verifica quantos elementos são iguais entre o vetor y e y_predicted.
+Esta função foi adicionada para compatibilidade com algumas funções do scikit-learn.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|--------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Conjunto de características com dimensões (n_samples, n_features). |
+| `y` | `Union[npt.NDArray, list]` | - | Rótulos verdadeiros com dimensão (n_amostras,). |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------|-----------------------|
+| `float` | A precisão do modelo. |
diff --git a/docs/pt-br/api/base/base-clusterer.md b/docs/pt-br/api/base/base-clusterer.md
new file mode 100644
index 0000000..2194474
--- /dev/null
+++ b/docs/pt-br/api/base/base-clusterer.md
@@ -0,0 +1,123 @@
+---
+id: base-clusterer
+sidebar_label: BaseClusterer
+keywords:
+ - base
+ - clusterer
+ - clusterer interface
+ - cluster labels
+ - fit
+ - predict
+ - fit_predict
+ - agrupamento
+tags:
+ - clusterer
+ - agrupamento
+---
+
+# BaseClusterer
+
+Classe base abstrata para algoritmos de clustering.
+
+> **Módulos:** `aisp.base`
+> **Importação:** `from aisp.base import BaseClusterer`
+
+---
+
+## Visão geral
+
+Esta classe define a interface principal para algoritmos de clusterização.
+Ela define a implementação dos metodos fit e predict em todas as classes filhas, e fornece a implementação do
+método `fit_predict`.
+
+Casos de uso:
+
+- Classe base abstrata para estender classes de algoritmos de clusterização.
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|-------------------------|:------:|---------------------------------------------------------|
+| `labels` | `Optional[npt.NDArray]` | `None` | Rótulos dos clusters encontrados durante o treinamento. |
+
+---
+
+## Métodos abstratos
+
+### fit
+
+```python
+@abstractmethod
+def fit(self, X: Union[npt.NDArray, list], verbose: bool = True) -> BaseClusterer:
+ ...
+```
+
+Treinamento do modelo utilizando os dados de entrada `X`.
+Este método abstrato é implementado é responsabilidade das classes filhas.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+---
+
+### predict
+
+```python
+@abstractmethod
+def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
+ ...
+```
+
+Gera previsões com base nos dados de entrada `X`.
+Este método abstrato é implementado é responsabilidade das classes filhas.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|----------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada. Deve ter o mesmo número de características usadas no treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|-------------------------------------------------------------|
+| `npt.NDArray` | Os labels do cluster previsto para cada amostra de entrada. |
+
+---
+
+## Métodos públicos
+
+### fit_predict
+
+```python
+def fit_predict(self, X: Union[npt.NDArray, list], verbose: bool = True) -> npt.NDArray:
+ ...
+```
+
+Ajusta o modelo e com os dados de X e retorna os labels para cada amostra de X.
+Este é um método que combina `fit` e `predict` em uma única chamada.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|-------------------------------------------------------------|
+| `npt.NDArray` | Os labels do cluster previsto para cada amostra de entrada. |
diff --git a/docs/pt-br/api/base/base-optimizer.md b/docs/pt-br/api/base/base-optimizer.md
new file mode 100644
index 0000000..56281f7
--- /dev/null
+++ b/docs/pt-br/api/base/base-optimizer.md
@@ -0,0 +1,164 @@
+---
+id: base-optimizer
+sidebar_label: BaseOptimizer
+keywords:
+ - base
+ - otimizar
+ - otimização
+ - otimizar interface
+ - objective function
+ - minimization
+ - maximization
+tags:
+ - otimizar
+ - otimização
+---
+
+# BaseOptimizer
+
+Classe base abstrata para algoritmos de otimização.
+
+> **Módulos:** `aisp.base`
+> **Importação:** `from aisp.base import BaseOptimizer`
+
+---
+
+## Visão geral
+
+Esta classe define a interface principal para algoritmos de otimização.
+Ela mantém o histórico de custos, soluções avaliadas, e a melhor solução encontrada durante a otimização. As classes
+derivadas devem implementar os métodos ``optimize`` e ``affinity_function``.
+
+Casos de uso:
+
+- Classe base abstrata para estender classes de algoritmos de otimização.
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|--------------------|-------------------|:-------:|---------------------------------------------------------------|
+| `cost_history` | `List[float]` | `[]` | Histórico dos melhores custos encontrados em cada iteração. |
+| `solution_history` | `List` | `[]` | Histórico da melhor solução encontrada em cada iteração. |
+| `best_solution` | `Any` | `None` | A melhor solução global encontrada. |
+| `best_cost` | `Optional[float]` | `None` | Custo da melhor solução global encontrada. |
+| `mode` | `{"min", "max"}` | `'min'` | Define se o algoritmo minimiza ou maximiza a função de custo. |
+
+---
+
+## Métodos abstratos
+
+### optimize
+
+```python
+@abstractmethod
+def optimize(
+ self,
+ max_iters: int = 50,
+ n_iter_no_change: int = 10,
+ verbose: bool = True
+) -> Any:
+ ...
+```
+
+Executa o processo de otimização.
+Este método abstrato é implementado é responsabilidade das classes filhas, definindo a estratégia de otimização.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|--------------------|--------|:------:|----------------------------------------------------------------------|
+| `max_iters` | `int` | `50` | Número máximo de iterações |
+| `n_iter_no_change` | `int` | `10` | Número máximo de interações sem atualização da melhor solução. |
+| `verbose` | `bool` | `True` | Indica se as mensagens de progresso do treinamento deve ser exibido. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+---
+
+### affinity_function
+
+```python
+@abstractmethod
+def affinity_function(self, solution: Any) -> float:
+ ...
+```
+
+Avalia a afinidade (qualidade) de uma solução candidata.
+
+Este método deve ser implementado conforme o problema de otimização específico, definindo como a solução sera medida.
+O valor retornado deve representar a qualidade da solução avaliada.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|-------|:------:|--------------------------------------|
+| `solution` | `Any` | - | Solução candidata que será avaliada. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------|------------------------------------------------|
+| `float` | Valor de custo associada a solução encontrada. |
+
+---
+
+## Métodos públicos
+
+### get_report
+
+```python
+def get_report(self) -> str:
+ ...
+```
+
+Gera um relatorio resumindo e formatado do processo de otimização.
+O relatorio incluir a melhor solução, seu custo, e a evolução dos valores a cada iteração.
+
+**Returns**
+
+| Tipo | Descrição |
+|-------|-------------------------------------------------------|
+| `str` | Uma string formatada contendo o resumo da otimização. |
+
+---
+
+### register
+
+```python
+def register(self, alias: str, function: Callable[..., Any]) -> None:
+ ...
+```
+
+Registra dinamicamente uma função na instância do otimizador.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|----------------------|:------:|----------------------------------------------------|
+| `alias` | `str` | - | Nome usado para acessar a função como um atributo. |
+| `function` | `Callable[..., Any]` | - | Função que será registrada. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|------------------|----------------------------------------------------------------------------------|
+| `TypeError` | Se a `function` fornecida não for uma função valida. |
+| `AttributeError` | Se o `alias` for protegido e não puder ser modificado, ou não existir na classe. |
+
+
+---
+
+### reset
+
+```python
+def reset(self):
+ ...
+```
+
+Reseta o estado interno do objeto, limpando histórico e restaurando valores iniciais.
diff --git a/docs/pt-br/api/base/immune/README.md b/docs/pt-br/api/base/immune/README.md
new file mode 100644
index 0000000..82f0110
--- /dev/null
+++ b/docs/pt-br/api/base/immune/README.md
@@ -0,0 +1,22 @@
+---
+id: immune
+sidebar_label: immune
+keywords:
+ - célula
+ - mutações
+ - populações
+---
+
+# aisp.base.immune
+
+Módulo de suporte para sistemas imunológicos artificias.
+
+> **Módulo:** `aisp.base.immune`
+
+## Submódulos
+
+| Módulos | Descrição |
+|-----------------------------------|------------------------------------------------------------------------------------------------------------|
+| [`cell`](./cell/README.md) | Representação de células do sistema imunológico. |
+| [`mutation`](./mutation.md) | Funções para gerar clones hipermutados similar a expansão clonal. |
+| [`populations`](./populations.md) | Fornece funções utilitárias para gerar populações de anticorpos utilizadas em algoritmos imuno-inspirados. |
\ No newline at end of file
diff --git a/docs/pt-br/api/base/immune/cell/README.md b/docs/pt-br/api/base/immune/cell/README.md
new file mode 100644
index 0000000..548c41c
--- /dev/null
+++ b/docs/pt-br/api/base/immune/cell/README.md
@@ -0,0 +1,32 @@
+---
+id: immune-cell
+sidebar_label: cell
+keywords:
+ - vector representation
+ - cell
+ - immune
+ - immune cell
+ - base class
+ - bcell
+ - antibody
+ - dataclass
+---
+
+# aisp.base.immune.cell
+
+Representação de células do sistema imunológico.
+
+> **Módulos:** `aisp.base.immune.cell`
+
+## Visão geral
+
+Este módulo define as representações de células dos sistemas imunológicos artificiais e as implementa como dataclass.
+
+## Classes
+
+| Class | Descrição |
+|-----------------------------|----------------------------------------------------|
+| [`Cell`](./cell.md) | Representa uma célula imune básica. |
+| [`BCell`](./b-cell.md) | Representa uma célula-B de memória. |
+| [`Antibody`](./antibody.md) | Representa um anticorpo. |
+| [`Detector`](./detector.md) | Representa um detector não-próprio da classe rnsa. |
\ No newline at end of file
diff --git a/docs/pt-br/api/base/immune/cell/antibody.md b/docs/pt-br/api/base/immune/cell/antibody.md
new file mode 100644
index 0000000..5587a53
--- /dev/null
+++ b/docs/pt-br/api/base/immune/cell/antibody.md
@@ -0,0 +1,39 @@
+---
+id: antibody
+sidebar_label: Antibody
+keywords:
+ - anticorpo
+ - afinidade
+ - célula
+ - imune
+ - dataclass
+---
+
+# Antibody
+
+Representa um anticorpo.
+
+:::tip[Herança]
+
+Esta classe herda de [Cell](./cell.md)
+
+:::
+
+> **Módulo:** `aisp.base.immune.cell`
+> **Importação:** `from aisp.base.immune.cell import Antibody`
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|---------------|:------:|----------------------------------------|
+| `vector` | `npt.NDArray` | - | Vetor com as características anticorpo |
+| `affinity` | `float` | - | Valor da afinidade do anticorpo |
+
+---
+
+## Métodos
+
+* `__lt__(other)`: Compara a célula atual com outra célula `Antibody` com base na afinidade.
+* `__eq__(other)`: Verifica se o anticorpo possui a mesma afinidade do outro.
diff --git a/docs/pt-br/api/base/immune/cell/b-cell.md b/docs/pt-br/api/base/immune/cell/b-cell.md
new file mode 100644
index 0000000..67183d6
--- /dev/null
+++ b/docs/pt-br/api/base/immune/cell/b-cell.md
@@ -0,0 +1,63 @@
+---
+id: b-cell
+sidebar_label: BCell
+keywords:
+ - célula-b
+ - memória imune
+ - dataclass
+ - mutação clonal
+ - expansão clonal
+---
+
+# BCell
+
+Representa uma célula-B de memória.
+
+:::tip[Herança]
+
+Esta classe herda de [Cell](./cell.md)
+
+:::
+
+> **Módulo:** `aisp.base.immune.cell`
+> **Importação:** `from aisp.base.immune.cell import BCell`
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|--------------|:------:|-----------------------------------------|
+| `vector` | `np.ndarray` | - | Vetor com as características da célula. |
+
+---
+
+## Métodos Públicos
+
+### hyper_clonal_mutate
+
+```python
+def hyper_clonal_mutate(
+ self,
+ n: int,
+ feature_type: FeatureType = "continuous-features",
+ bounds: Optional[npt.NDArray[np.float64]] = None
+) -> npt.NDArray:
+ ...
+```
+
+Gera **N** clones da célula atual e aplica hipermutação aos clones.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------------|------------------------------------------------------|:-----------------------:|-----------------------------------------------------------------|
+| `n` | `int` | - | Numero de clones que serão gerados a partir da célula original. |
+| `feature_type` | [`FeatureType`](../../../utils/types.md#featuretype) | `"continuous-features"` | Especifica o tipo de características da célula. |
+| `bounds` | `Optional[npt.NDArray[np.float64]]` | `None` | Matriz (n_features, 2) com o min e o max de cada dimensão. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|----------------------------------------------------------|
+| `npt.NDArray` | Uma matriz contendo N clones mutados da célula original. |
diff --git a/docs/pt-br/api/base/immune/cell/cell.md b/docs/pt-br/api/base/immune/cell/cell.md
new file mode 100644
index 0000000..0d7955c
--- /dev/null
+++ b/docs/pt-br/api/base/immune/cell/cell.md
@@ -0,0 +1,35 @@
+---
+id: cell
+sidebar_label: Cell
+keywords:
+ - vector representation
+ - cell
+ - immune
+ - immune cell
+ - base class
+ - dataclass
+---
+
+# Cell
+
+Representa uma célula imune básica.
+
+> **Módulo:** `aisp.base.immune.cell`
+> **Importação:** `from aisp.base.immune.cell import Cell`
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|--------------|:------:|-----------------------------------------|
+| `vector` | `np.ndarray` | - | Vetor com as características da célula. |
+
+---
+
+## Métodos
+
+* `__eq__(other)`: Verifica se duas células são iguais com base nos seus vetores.
+* `__array__()`: Interface de array Numpy, permite que a instância seja tratada como um `np.ndarray`
+* `__getitem__(item)`: Obtém um elemento do vetor com base no index.
+
diff --git a/docs/pt-br/api/base/immune/cell/detector.md b/docs/pt-br/api/base/immune/cell/detector.md
new file mode 100644
index 0000000..71fcfdc
--- /dev/null
+++ b/docs/pt-br/api/base/immune/cell/detector.md
@@ -0,0 +1,28 @@
+---
+id: detector
+sidebar_label: Detector
+keywords:
+ - detector
+ - célula
+ - imune
+ - raio
+ - não-próprio
+ - nsa
+ - dataclass
+---
+
+# Detector
+
+Representa um detector não-próprio da classe rnsa.
+
+> **Módulo:** `aisp.base.immune.cell`
+> **Importação:** `from aisp.base.immune.cell import Detector`
+
+---
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|---------------------------|:------:|--------------------------------------------------|
+| `position` | `npt.NDArray[np.float64]` | - | Vetor com as características do detector. |
+| `radius` | `float, optional` | - | Raio do detector, usado no algoritmo V-detector. |
diff --git a/docs/pt-br/api/base/immune/mutation.md b/docs/pt-br/api/base/immune/mutation.md
new file mode 100644
index 0000000..38fc658
--- /dev/null
+++ b/docs/pt-br/api/base/immune/mutation.md
@@ -0,0 +1,146 @@
+---
+id: mutation
+sidebar_label: mutation
+keywords:
+ - mutações
+ - expansão clonal
+ - sistema imune
+ - funções python com numba
+ - vetor de mutações
+---
+
+# mutation
+
+As funções utilizam decoradores do Numba para compilação Just-In-Time(JIT).
+
+Contém funções que geram conjuntos de clones hipermutados a partir de vetores contínuos ou binários, simulando o
+processo
+de expansão clonal dos sistemas imunológicos artificiais.
+
+> **Módulo:** `aisp.base.immune`
+> **Importação:** `from aisp.base.immune import mutation`
+
+## Funções
+
+### clone_and_mutate_continuous
+
+```python
+@njit([(types.float64[:], types.int64, types.float64)], cache=True)
+def clone_and_mutate_continuous(
+ vector: npt.NDArray[np.float64],
+ n: int,
+ mutation_rate: float
+) -> npt.NDArray[np.float64]:
+ ...
+```
+
+Gera um conjunto de clones mutados a partir de um vetor contínuo.
+
+Esta função cria `n` clones do vetor de entrada e aplica mutações em cada um, simulando o processo
+de expansão clonal em sistemas imunes artificiais.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------------|---------------------------|:------:|----------------------------------------------------------------------------------------------------------------------------------------------|
+| `vector` | `npt.NDArray[np.float64]` | - | Vetor contínuo original que representa a célula imune a ser clonada e mutada. |
+| `n` | `int` | - | Quantidade de clones mutados que serão gerados. |
+| `mutation_rate` | `float` | - | Se 0 ≤ mutation_rate < 1, usa probabilidade de mutação por características. Caso contrario, um número aleatorio de características é mutado. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------------------|----------------------------------------------------------------------------------------|
+| `npt.NDArray[np.float64]` | Array com dimensões (n, len(vector)) contendo os `n` clones mutados do vetor original. |
+
+### clone_and_mutate_binary
+
+```python
+@njit([(types.boolean[:], types.int64, types.float64)], cache=True)
+def clone_and_mutate_binary(
+ vector: npt.NDArray[np.bool_],
+ n: int,
+ mutation_rate: float
+) -> npt.NDArray[np.bool_]:
+ ...
+```
+
+Gera um conjunto de clones mutados a partir de um vetor binário.
+
+Esta função cria `n` clones do vetor binário de entrada e aplica mutações aos bits, simulando a expansão
+clonal em sistemas imunes artificiais com representações discretas.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------------|---------------------------|:------:|----------------------------------------------------------------------------------------------------------------------------------------------|
+| `vector` | `npt.NDArray[np.float64]` | - | Vetor binário original que representa a célula imune a ser clonada e mutada. |
+| `n` | `int` | - | Quantidade de clones mutados a serão gerados. |
+| `mutation_rate` | `float` | - | Se 0 ≤ mutation_rate < 1, usa probabilidade de mutação por características. Caso contrario, um número aleatorio de características é mutado. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-------------------------|----------------------------------------------------------------------------------------|
+| `npt.NDArray[np.bool_]` | Array com dimensões (n, len(vector)) contendo os `n` clones mutados do vetor original. |
+
+### clone_and_mutate_ranged
+
+```python
+@njit([(types.float64[:], types.int64, types.float64[:, :], types.float64)], cache=True)
+def clone_and_mutate_ranged(
+ vector: npt.NDArray[np.float64],
+ n: int,
+ bounds: npt.NDArray[np.float64],
+ mutation_rate: float,
+) -> npt.NDArray[np.float64]:
+ ...
+```
+
+Gera um conjunto de clones mutados a partir de uma célula representada pelo intervalo personalizados por dimensão..
+
+Esta função cria `n` clones do vetor de entrada e aplica mutações em cada um, simulando o processo
+de expansão clonal em sistemas imunes artificiais.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------------|---------------------------|:------:|----------------------------------------------------------------------------------------------------------------------------------------------|
+| `vector` | `npt.NDArray[np.float64]` | - | Vetor contínuo original que representa a célula imune a ser clonada e mutada. |
+| `n` | `int` | - | Quantidade de clones mutados a serão gerados. |
+| `bounds` | `np.ndarray` | - | Array (n_features, 2) com valor mínimo e máximo por dimensão. |
+| `mutation_rate` | `float` | - | Se 0 ≤ mutation_rate < 1, usa probabilidade de mutação por características. Caso contrario, um número aleatorio de características é mutado. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------------------|----------------------------------------------------------------------------------------|
+| `npt.NDArray[np.float64]` | Array com dimensões (n, len(vector)) contendo os `n` clones mutados do vetor original. |
+
+### clone_and_mutate_continuous
+
+```python
+@njit([(types.int64[:], types.int64, types.float64)], cache=True)
+def clone_and_mutate_permutation(
+ vector: npt.NDArray[np.int64],
+ n: int,
+ mutation_rate: float
+) -> npt.NDArray[np.int64]:
+ ...
+```
+
+Gera um conjunto de clones com mutações por permutação.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------------|-------------------------|:------:|------------------------------------------------------------------------------------|
+| `vector` | `npt.NDArray[np.int64]` | - | Vetor de permutação original que representa a célula imune a ser clonada e mutada. |
+| `n` | `int` | - | Quantidade de clones mutados a serão gerados. |
+| `mutation_rate` | `float` | - | Probabilidade de mutação de uma característica. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------------------|----------------------------------------------------------------------------------------|
+| `npt.NDArray[np.float64]` | Array com dimensões (n, len(vector)) contendo os `n` clones mutados do vetor original. |
diff --git a/docs/pt-br/api/base/immune/populations.md b/docs/pt-br/api/base/immune/populations.md
new file mode 100644
index 0000000..5f4a49e
--- /dev/null
+++ b/docs/pt-br/api/base/immune/populations.md
@@ -0,0 +1,57 @@
+---
+id: populations
+sidebar_label: populations
+keywords:
+ - binário
+ - classificação
+ - limiar de afinidade
+ - real-valor
+ - célula-b de memória
+ - expansão clonal
+ - população
+---
+
+# populations
+
+Fornece funções utilitárias para **gerar populações** de anticorpos utilizadas em algoritmos imuno-inspirados.
+
+> **Módulo:** `aisp.base.immune`
+> **Importação:** `from aisp.base.immune import populations`
+
+## Funções
+
+### generate_random_antibodies
+
+```python
+def generate_random_antibodies(
+ n_samples: int,
+ n_features: int,
+ feature_type: FeatureTypeAll = "continuous-features",
+ bounds: Optional[npt.NDArray[np.float64]] = None,
+) -> npt.NDArray:
+ ...
+```
+
+Gera uma população aleatória de anticorpos.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------------|---------------------------------------------------------|:-----------------------:|--------------------------------------------------------------------------------------------------------------------------------|
+| `n_samples` | `int` | - | Número de anticorpos (amostras) que serão gerados. |
+| `n_features` | `int` | - | Número de características (dimensões) para cada anticorpo. |
+| `feature_type` | [`FeatureTypeAll`](../../utils/types.md#featuretypeall) | `"continuous-features"` | Especifica o tipo das características: "continuous-features", "binary-features", "ranged-features", or "permutation-features". |
+| `bounds` | `npt.NDArray[np.float64]` | `None` | Array (n_features, 2) contendo os valores mínimo e máximo por dimensão. |
+
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|---------------------------------------------------------------------------|
+| `npt.NDArray` | Array de dimensão (n_samples, n_features) contendo os anticorpos gerados. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|-----------------------------------------------------------|
+| `ValueError` | Se o número de características for menor ou igual a zero. |
diff --git a/docs/pt-br/api/csa/README.md b/docs/pt-br/api/csa/README.md
new file mode 100644
index 0000000..39f9597
--- /dev/null
+++ b/docs/pt-br/api/csa/README.md
@@ -0,0 +1,33 @@
+---
+id: csa
+sidebar_label: aisp.csa
+keywords:
+ - sistema imunológico
+ - seleção clonal
+ - clonalg
+ - airsv2
+ - proliferação de anticorpos
+ - mutações
+ - algoritmos de seleção clonal
+ - sistemas imunológicos artificiais
+ - classificação
+ - otimização
+---
+
+# aisp.csa
+
+Módulo com algoritmos de seleção clonal (ASC).
+
+> **Módulo:** `aisp.csa`
+
+## Visão geral
+
+Os **ASCs** são inspirados no processo de proliferação de anticorpos ao detectar o antígeno, no qual os clones gerados
+passam por mutações na tentativa de melhorar o reconhecimento dos patógenos.
+
+## Classes
+
+| Class | Descrição |
+|---------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`AIRS`](./airs.md) | Um algoritmos supervisionado para tarefas de classificação. |
+| [`Clonalg`](./clonalg.md) | Esta implementação do ASC para otimização, foi adaptado tanto para minimização quanto maximização de custos em problemas binários, contínuos e de permutação. |
diff --git a/docs/pt-br/api/csa/airs.md b/docs/pt-br/api/csa/airs.md
new file mode 100644
index 0000000..c1868e0
--- /dev/null
+++ b/docs/pt-br/api/csa/airs.md
@@ -0,0 +1,199 @@
+---
+id: airs
+sidebar_label: AIRS
+keywords:
+ - classificação
+ - sistema imunológico artificial de reconhecimento
+ - células de memória
+ - k-nn
+ - aprendizado supervisionado
+ - AIRS2
+ - seleção clonal
+tags:
+ - classificação
+ - supervisionado
+ - seleção clonal
+---
+
+# AIRS
+
+Sistema Imunológico Artificial de Reconhecimento (AIRS)
+
+:::tip[Herança]
+
+Esta classe herda de [BaseClassifier](../base/base-classifier.md)
+
+:::
+
+
+> **Módulo:** `aisp.csa`
+> **Importação:** `from aisp.csa import AIRS`
+
+---
+
+## Visão geral
+
+O _Artificial Immune Recognition System_ (AIRS) é um algoritmo de classificação inspirado no processo de seleção
+clonal. Esta implementação é baseada na versão simplificada (AIRS2) descrita em [^1]. O algoritmo foi adaptado
+para suportar amostras com características com valores reais (contínuos) e binários (discretos).
+
+:::note
+
+Esta implementação é inspirada no AIRS2, uma versão simplificada do algoritmo AIRS original, introduzindo
+adaptações para lidar com conjuntos de dados contínuos e binários.
+
+Baseado no Algorithm 16.5 de Brabazon et al. [^1]
+
+Trabalhos relacionados e notáveis: [^2].
+
+:::
+
+---
+
+## Exemplo
+
+```python
+import numpy as np
+from aisp.csa import AIRS
+
+np.random.seed(1)
+# Gerando dados para o treinamento
+a = np.random.uniform(high=0.5, size=(50, 2))
+b = np.random.uniform(low=0.51, size=(50, 2))
+x_train = np.vstack((a, b))
+y_train = [0] * 50 + [1] * 50
+# Instancia do AIRS
+airs = AIRS(n_resources=5, rate_clonal=5, rate_hypermutation=0.65, seed=1)
+airs = airs.fit(x_train, y_train, verbose=False)
+x_test = [
+ [0.15, 0.45], # Expected: Class 0
+ [0.85, 0.65], # Esperado: Classe 1
+]
+y_pred = airs.predict(x_test)
+print(y_pred)
+```
+
+Output:
+
+```bash
+[0 1]
+```
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Default | Descrição |
+|-----------------------------|---------|:-------------:|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `n_resources` | `float` | `10` | Quantidade total de recursos disponíveis. |
+| `rate_clonal` | `float` | `10` | Número máximo de clones possíveis de uma classe. Esta quantidade é multiplicada por (estímulo da célula * rate_hypermutation) para definir o número de clones. |
+| `rate_mc_init` | `float` | `0.2` | Porcentagem de amostras usadas para inicializar a população de células de memória. |
+| `rate_hypermutation` | `float` | `0.75` | Taxa de clones mutados derivada de rate_clonal como um fator escalar. |
+| `affinity_threshold_scalar` | `float` | `0.75` | Limiar de afinidade normalizado. |
+| `k` | `int` | `3` | Número de vizinhos mais próximos (k-NN) que será usado para escolher um rótulo na predição. |
+| `max_iters` | `int` | `100` | Número máximo de interações no processo de refinamento do conjunto ARB exposto a aᵢ. |
+| `resource_amplified` | `float` | `1.0` | Amplificador de consumo de recursos, multiplicado com o estímulo para subtrair recursos. |
+| `metric` | `str` | `"euclidean"` | Métrica de distância usada para calcular a afinidade entre células e amostras. |
+| `seed` | `int` | `None` | Seed para geração aleatória. |
+| `p` | `float` | `2` | Este parâmetro é usado na distância de Minkowski. |
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|----------------|-------------------------------------------|:------:|--------------------------------------------|
+| `cells_memory` | `Optional[Dict[str \| int, list[BCell]]]` | - | Armazena as células de memória por classe. |
+
+---
+
+## Métodos Públicos
+
+### fit
+
+```python
+def fit(
+ self,
+ X: Union[npt.NDArray, list],
+ y: Union[npt.NDArray, list],
+ verbose: bool = True,
+) -> AIRS:
+ ...
+```
+
+Treina o modelo com os dados de entrada utilizando o algoritmo AIRS2.
+
+A função `fit(...)`, realiza o treinamento de acordo com X e y, usando o método AIRS.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `y` | `Union[npt.NDArray, list]` | - | Vetor alvo no formato (n_samples,). Deve conter o mesmo número de amostras que X. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------|---------------------------------------------------------------|
+| `TypeError` | Se X ou y não forem arrays ou tiverem tamanhos incompatíveis. |
+
+---
+
+### predict
+
+```python
+def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
+ ...
+```
+
+Prevê os rótulos dos dados de testes com base nas células de memórias criadas durante o treinamento.
+
+Este método utiliza as células de memórias para classificar os dados de entrada usando a abordagem dos k-vizinhos mais
+próximos (K-NN).
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|----------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada. Deve ter o mesmo número de características usadas no treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|----------------------------------------------------------------------|
+| `npt.NDArray` | Array no formato `n_samples` contendo as classes previstas para `X`. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------------------------------------------------------------------|-------------------------------------------------------------------------------------------|
+| `TypeError` | Se X não for um ndarray ou list. |
+| [`FeatureDimensionMismatch`](../exceptions.md#featuredimensionmismatch) | Se o número de características em X não corresponder ao esperado. |
+| [`ModelNotFittedError`](../exceptions.md#modelnotfittederror) | Se o modelo ainda não tiver sido treinado e não possuir o conjunto de células de memoria. |
+
+---
+
+## Exemplos Estendidos
+
+Exemplos completos de uso estão disponíveis nos notebooks Jupyter:
+
+- [**Iris Dataset Example**](../../../../examples/en/classification/AIRS/iris_dataBase_example_en.ipynb)
+- [**Geyser Dataset Example**](../../../../examples/en/classification/AIRS/geyser_dataBase_example_en.ipynb)
+- [**Mushrooms Dataset Example**](../../../../examples/en/classification/AIRS/mushrooms_dataBase_example_en.ipynb)
+- [**Random Dataset Example**](../../../../examples/en/classification/AIRS/example_with_randomly_generated_dataset-en.ipynb)
+
+---
+
+## Referências
+
+[^1]: Brabazon, A., O'Neill, M., & McGarraghy, S. (2015). Natural Computing Algorithms. In Natural Computing Series.
+ Springer Berlin Heidelberg. [https://doi.org/10.1007/978-3-662-43631-8](https://doi.org/10.1007/978-3-662-43631-8)
+
+[^2]: AZZOUG, Aghiles. Artificial Immune Recognition System V2. Available at:
+ [https://github.com/AghilesAzzoug/Artificial-Immune-System](https://github.com/AghilesAzzoug/Artificial-Immune-System)
diff --git a/docs/pt-br/api/csa/clonalg.md b/docs/pt-br/api/csa/clonalg.md
new file mode 100644
index 0000000..9474058
--- /dev/null
+++ b/docs/pt-br/api/csa/clonalg.md
@@ -0,0 +1,187 @@
+---
+id: clonalg
+sidebar_label: Clonalg
+keywords:
+ - otimização
+ - seleção clonal
+ - clonalg
+ - população de anticorpos
+ - função de custo
+tags:
+ - otimização
+ - seleção clonal
+ - minimização
+ - maximização
+ - binário
+ - contínuos
+ - permutação
+ - ranged
+---
+
+# Clonalg
+
+Algoritmo de Seleção Clonal (CLONALG).
+
+:::tip[Herança]
+
+Esta classe herda de [BaseOptimizer](../base/base-optimizer.md)
+
+:::
+
+
+> **Módulo:** `aisp.csa`
+> **Importação:** `from aisp.csa import Clonalg`
+
+---
+
+## Visão geral
+
+O _Clonal Selection Algorithm (CSA)_ é um algoritmo de otimização inspirado no processo biológico de seleção e expansão
+clonal dos anticorpos do sistema imunológico [^1]. Esta implementação do clonalg foi adaptada para minimização e
+maximização da função de custo em problemas binários, contínuos, com intervalo de valor e de permutação.
+
+:::note
+
+Esta implementação do CLONALG contem modificações para o pacote AISP, com intuito da aplicação geral em diferentes
+tipos de problemas, o que pode resultar em comportamentos diferentes de implementações focada em um problema específico.
+A adaptação visa generalizar o uso do CLONALG para tarefas de minimização e maximização, além de oferecer suporte
+a problemas binários, contínuos, com intervalo de valor e de permutação
+
+:::
+
+---
+
+## Exemplo
+
+```python
+import numpy as np
+from aisp.csa import Clonalg
+
+# Limites do espaço de busca
+bounds = {'low': -5.12, 'high': 5.12}
+
+
+# Função de custo
+def rastrigin_fitness(x):
+ x = np.clip(x, bounds['low'], bounds['high'])
+ return 10 * len(x) + np.sum(x ** 2 - 10 * np.cos(2 * np.pi * x))
+
+
+# Instância do CLONALG
+clonalg = Clonalg(problem_size=2, bounds=bounds, seed=1)
+clonalg.register('affinity_function', rastrigin_fitness)
+population = clonalg.optimize(100, 50, False)
+print('Best cost:', abs(clonalg.best_cost))
+```
+
+**Output:**
+
+```bash
+Best cost: 0.02623036956750724
+```
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Default | Descrição |
+|-------------------------|------------------------------------------------------|:-------------------:|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `problem_size` | `int` | - | Dimensão do problema que será otimizado. |
+| `N` | `int` | `50` | Número de células de memória (anticorpos) na população. |
+| `rate_clonal` | `int` | `10` | Número máximo de clones possíveis de uma célula. Esse valor é multiplicado pela afinidade da célula para definir o número de clones. |
+| `rate_hypermutation` | `float` | `1.0` | Taxa de hipermutação que controla a intensidade das mutações durante a expansão clonal. valores maiores reduzem a intensidade, enquanto menores aumentam. |
+| `n_diversity_injection` | `int` | `5` | Número de novas células de mémoria aleatórias inseridas para manter a diversidade. |
+| `selection_size` | `int` | `5` | Número dos melhores anticorpos selecionados para a clonagem. |
+| `affinity_function` | `Optional[Callable[..., npt.NDArray]]` | `None` | Função objetiva usada para avaliar as soluções candidatas durante a otimização. |
+| `feature_type` | [`FeatureTypeAll`](../utils/types.md#featuretypeall) | `'ranged-features'` | Tipo de representação das soluções: binária, contínua, com intervalo de valor e para permutação. |
+| `bounds` | `Optional[Dict]` | `None` | Define os limites no espaço de busca quando ``feature_type='ranged-features'``. |
+| `mode` | `{"min", "max"}` | `'min'` | Define se o algoritmo realiza minimização ou maximização da função de custo. |
+| `seed` | `int` | `None` | Seed para geração aleatória. |
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|--------------|----------------------------|:------:|--------------------------|
+| `population` | `Optional[List[Antibody]]` | `None` | População de anticorpos. |
+
+---
+
+## Métodos Públicos
+
+### optimize
+
+```python
+def optimize(
+ self, max_iters: int = 50, n_iter_no_change=10, verbose: bool = True
+) -> List[Antibody]:
+ ...
+```
+
+Realiza o processo de otimização e retorna a população de anticorpos resultante.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|--------------------|--------|:------:|-------------------------------------------------------------------------------------|
+| `max_iters` | `int` | `50` | Número máximo de iterações na busca da melhor solução do problema usando o CLONALG. |
+| `n_iter_no_change` | `int` | `10` | Número máximo de interações sem melhoria na melhor solução global encontrada. |
+| `verbose` | `bool` | `True` | Indica se as mensagens de progresso na busca do melhor anticorpo deve ser exibido. |
+
+**Returns**
+
+| Tipo | Descrição |
+|------------------|-----------------------------------------------------------|
+| `List[Antibody]` | População de anticorpos após a expansão e seleção clonal. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-----------------------|----------------------------------------------------------------------|
+| `NotImplementedError` | Se a função de afinidade não for fornecida para avaliar as soluções. |
+
+---
+
+### affinity_function
+
+```python
+def affinity_function(self, solution: npt.NDArray) -> np.float64:
+ ...
+```
+
+Avalia a afinidade de uma solução candidata.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|---------------|:------:|--------------------------------------|
+| `solution` | `npt.NDArray` | - | Solução candidata que será avaliada. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------------|---------------------------------------------------|
+| `np.float64` | Valor de afinidade da solução candidata avaliada. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-----------------------|---------------------------------------------------|
+| `NotImplementedError` | Se a função de afinidade não tiver sido definida. |
+
+---
+
+## Exemplos Estendidos
+
+Exemplos completos de uso estão disponíveis nos notebooks Jupyter:
+
+- [**Knapsack Problem Example**](../../../../examples/en/optimization/clonalg/knapsack_problem_example.ipynb)
+- [**Rastrigin Function Example**](../../../../examples/en/optimization/clonalg/rastrigin_function_example.ipynb)
+- [**Tsp Problem Example**](../../../../examples/en/optimization/clonalg/tsp_problem_example.ipynb)
+
+---
+
+## Referências
+
+[^1]: BROWNLEE, Jason. Clonal Selection Algorithm. Clever Algorithms: Nature-inspired
+ Programming Recipes., 2011. Available at:
+ https://cleveralgorithms.com/nature-inspired/immune/clonal_selection_algorithm.html
diff --git a/docs/pt-br/api/exceptions.md b/docs/pt-br/api/exceptions.md
new file mode 100644
index 0000000..500c4e6
--- /dev/null
+++ b/docs/pt-br/api/exceptions.md
@@ -0,0 +1,91 @@
+---
+id: exceptions
+sidebar_label: aisp.exceptions
+keywords:
+ - exceptions
+ - Exceções
+ - warnings
+---
+
+# aisp.exceptions
+
+Avisos e erros personalizados.
+
+> **Módulo:** `aisp.exceptions`
+> **Importação:** `from aisp import exceptions`
+
+## Classes de exceção
+
+### MaxDiscardsReachedError
+
+```python
+class MaxDiscardsReachedError(Exception):
+ ...
+```
+
+Exceção lançada quando o número máximo de descartes do detector é atingido.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|---------------|-----------------|:------:|------------------------------------------|
+| `object_name` | `str` | - | O nome da classe que lança a exceção. |
+| `message` | `Optional[str]` | `None` | Mensagem personalizada que será exibida. |
+
+---
+
+### FeatureDimensionMismatch
+
+```python
+class FeatureDimensionMismatch(Exception):
+ ...
+```
+
+Exceção lançada quando o número de características (dimensões) de entrada não corresponde ao esperado.
+Essa exceção é acionada durante a predição se a quantidade de características estiver incorreta.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------------|-----------------|:------:|---------------------------------------------|
+| `expected` | `int` | - | O número esperado de características. |
+| `received` | `int` | - | O número real de características recebidas. |
+| `variable_name` | `Optional[str]` | `None` | O nome da variável que causou o error. |
+
+---
+
+### UnsupportedTypeError
+
+```python
+class UnsupportedTypeError(Exception):
+ ...
+```
+
+Exceção lançada quando o tipo de dados do vetor de entrada não é suportado.
+Essa exceção é lançada quando o tipo de dado do vetor não corresponde a nenhum dos suportados.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|-----------------|:------:|------------------------------------------|
+| `message` | `Optional[str]` | `None` | Mensagem personalizada que será exibida. |
+
+---
+
+### ModelNotFittedError
+
+```python
+class ModelNotFittedError(Exception):
+ ...
+```
+
+Exceção lançada quando o método é chamado antes que o modelo ter sido treinado.
+Essa exceção ocorre quando a instância do modelo é utilizada sem que ele tenha sido previamente treinado
+por meio do método `fit`.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|---------------|-----------------|:------:|------------------------------------------|
+| `object_name` | `str` | - | O nome da classe que lança a exceção. |
+| `message` | `Optional[str]` | `None` | Mensagem personalizada que será exibida. |
diff --git a/docs/pt-br/api/ina/README.md b/docs/pt-br/api/ina/README.md
new file mode 100644
index 0000000..2b73738
--- /dev/null
+++ b/docs/pt-br/api/ina/README.md
@@ -0,0 +1,30 @@
+---
+id: ina
+sidebar_label: aisp.ina
+keywords:
+ - sistema imunológico
+ - seleção clonal
+ - rede imunológica
+ - ainet
+ - opt-ainet
+ - mutações
+ - sistemas imunológicos artificiais
+ - clusterização
+ - otimização
+---
+
+# aisp.ina
+
+Módulo com Algoritmos de Rede Imunológica (ARI).
+
+> **Módulo:** `aisp.ina`
+
+## Visão geral
+
+Este módulo implementa algoritmos inspirados na teoria das redes imunológicas proposta por Jerne.
+
+## Classes
+
+| Class | Descrição |
+|------------------------|-------------------------------------------------------------------------------------------------------|
+| [`AiNet`](./ai-net.md) | Um algoritmo não supervisionado para agrupamentos de dados, baseado na teoria das redes imunológicas. |
diff --git a/docs/pt-br/api/ina/ai-net.md b/docs/pt-br/api/ina/ai-net.md
new file mode 100644
index 0000000..c4938dc
--- /dev/null
+++ b/docs/pt-br/api/ina/ai-net.md
@@ -0,0 +1,223 @@
+---
+id: ai-net
+sidebar_label: AiNet
+keywords:
+ - rede imunológica
+ - agrupamento
+ - compressão de dados
+ - aprendizado não supervisionado
+ - Minimum Spanning Tree
+tags:
+ - agrupamento
+ - não supervisionado
+ - rede imunológica
+---
+
+# AiNet
+
+Rede Imunológica Artificial (AiNet) para agrupamento e compressão.
+
+:::tip[Herança]
+
+Esta classe herda de [BaseClusterer](../base/base-clusterer.md).
+
+:::
+
+
+> **Módulo:** `aisp.ina`
+> **Importação:** `from aisp.ina import AiNet`
+
+---
+
+## Visão geral
+
+Esta classe implementa o algoritmo AiNet é projetado para tarefas de agrupamento
+e compressão de dados; O algoritmo é inspirado na teoria da rede imunológica, seleção clonal e maturação por afinidade para
+reduzir conjuntos de dados com muitas amostras [^1].
+No agrupamento a classe utiliza a implementação da Scipy da **Árvore geradora mínima** para separa as arestas mais
+distantes em grupos de dados [^2].
+
+---
+
+## Exemplo
+
+```python
+import numpy as np
+from aisp.ina import AiNet
+
+np.random.seed(1)
+# Gerando dados de treinamento
+a = np.random.uniform(high=0.4, size=(50, 2))
+b = np.random.uniform(low=0.6, size=(50, 2))
+x_train = np.vstack((a, b))
+# Instância do AiNet
+ai_net = AiNet(
+ N=150,
+ mst_inconsistency_factor=1,
+ seed=1,
+ affinity_threshold=0.85,
+ suppression_threshold=0.7
+)
+ai_net = ai_net.fit(x_train, verbose=True)
+x_test = [
+ [0.15, 0.45], # Esperado: rótulo 0
+ [0.85, 0.65], # Esperado: rótulo 1
+]
+y_pred = ai_net.predict(x_test)
+print(y_pred)
+```
+
+**Output**
+
+```bash
+[0 1]
+```
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Default | Descrição |
+|----------------------------|----------------------------------------------|:-------------:|------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `N` | `int` | `50` | Número de células de memória (anticorpos) para iniciar a população. |
+| `n_clone` | `int` | `10` | Número de clones gerados para cada célula de memória selecionada. |
+| `top_clonal_memory_size` | `int` | `5` | Número de anticorpos com maior afinidade que selecionados para a clonagem e mutação. |
+| `n_diversity_injection` | `int` | `5` | Número de novas células de memória aleatórias que serão inseridas para manter a diversidade. |
+| `affinity_threshold` | `float` | `0.5` | Limiar de afinidade (similaridade) parta determinar a supressão das células. |
+| `suppression_threshold` | `float` | `0.5` | Limiar de supressão das células de memórias semelhantes. |
+| `mst_inconsistency_factor` | `float` | `2.0` | Fator usado para determinar quais arestas da Árvore Geradora Mínima (MST) são consideradas inconsistentes. |
+| `max_iterations` | `int` | `10` | Número máximo de iterações de treinamento. |
+| `k` | `int` | `3` | Número de vizinhos mais próximos usados para predição de rótulos. |
+| `metric` | [`MetricType`](../utils/types.md#metrictype) | `"euclidean"` | Métrica de distância utilizada para calcular a similaridade entre as células de memória. |
+| `seed` | `Optional[int]` | `None` | Seed para geração aleatória. |
+| `use_mst_clustering` | `bool` | `True` | Quando `True`, realiza o agrupamento utilizando a MST. Se `False`, o agrupamento não é executado e o método predict lança uma exceção ModelNotFittedError. |
+| `p` | `float` | `2.0` | Parâmetro `p` utilizado na distância de Minkowski. |
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|-------------------------|-------------------------|:------:|-------------------------------------------------------------------------------|
+| `memory_network` | `Dict[int, List[Cell]]` | - | Rede imunológica que representa os clusters. |
+| `population_antibodies` | `Optional[npt.NDArray]` | - | População de anticorpos de memória. |
+| `mst` | `dict` | - | Árvore geradora minima com estatísticas (graph, mean_distance, std_distance). |
+
+---
+
+## Métodos Públicos
+
+### fit
+
+```python
+def fit(self, X: Union[npt.NDArray, list], verbose: bool = True) -> AiNet:
+ ...
+```
+
+Treina o modelo com os dados de entrada utilizando o algoritmo AiNet.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-----------------------------------------------------------------|----------------------------------------------------------|
+| `TypeError` | Se `X` não for um ndarray ou list. |
+| [`UnsupportedTypeError`](../exceptions.md#unsupportedtypeerror) | Se o tipo das características em X não forem suportados. |
+
+---
+
+### predict
+
+```python
+def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
+ ...
+```
+
+Prever os rótulos dos clusters para os dados de entrada.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|----------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada. Deve ter o mesmo número de características usadas no treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|---------------------------------------------|
+| `npt.NDArray` | Rótulos previstos para os dados de entrada. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
+| `TypeError` | Se X não for ndarray ou list. |
+| `ValueError` | Se X contiver valores diferentes de (0 e 1) ou (True e False), quando as características treinadas forem do tipo `'binary-features'` |
+| [`FeatureDimensionMismatch`](../exceptions.md#featuredimensionmismatch) | Se o número de dimensões em X não corresponder ao esperado. |
+| [`ModelNotFittedError`](../exceptions.md#modelnotfittederror) | Se o modelo ainda não tiver sido treinado e não possuir o conjunto de células de memória. |
+
+---
+
+### update_clusters
+
+```python
+def update_clusters(self, mst_inconsistency_factor: Optional[float] = None):
+ ...
+```
+
+Agrupa os clusters com base no fator de inconsistência da MST.
+
+Utiliza a Árvore Geradora Mínima (MST) criada a partir da população de anticorpos para redefinir os clusters.
+As arestas cujos pesos excedem a média somada ao valor de `mst_inconsistency_factor` multiplicado pelo desvio padrão
+dos pesos das arestas são removidas. Cada grafo conectado após essa poda é tratado como um grupo distinto.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------------------------|---------|:------:|------------------------------------------------|
+| `mst_inconsistency_factor` | `float` | `None` | Sobrescrever o fator de inconsistência da MST. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|-------------------------------------------------------------------------------|
+| `ValueError` | Se a Árvore Geradora Mínima (MST) ainda não tiver sido criada. |
+| `ValueError` | Se a população de anticorpos estiver vazia. |
+| `ValueError` | Se as estatísticas da MST (média ou desvio padrão) não estiverem disponíveis. |
+
+**Updates**
+
+| Nome | Tipo | Descrição |
+|------------------|--------------------------|---------------------------------------------------------------|
+| `memory_network` | `dict[int, npt.NDArray]` | Dicionário de rótulos de clusters para vetores de anticorpos. |
+| `labels` | `list` | Lista de rótulos de clusters. |
+
+---
+
+## Exemplos Estendidos
+
+Exemplos completos de uso estão disponíveis nos notebooks Jupyter:
+
+- [**Random Example**](../../../../examples/en/clustering/AiNet/example_with_randomly_generated_dataset.ipynb)
+- [**Geyser Dataset Example**](../../../../examples/en/clustering/AiNet/geyser_dataBase_example.ipynb)
+
+---
+
+## Referências
+
+[^1]: De Castro, Leandro & José, Fernando & von Zuben, Antonio Augusto. (2001). aiNet: An Artificial Immune Network for
+ Data Analysis.
+ Available at: 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
diff --git a/docs/pt-br/api/nsa/README.md b/docs/pt-br/api/nsa/README.md
new file mode 100644
index 0000000..cb03357
--- /dev/null
+++ b/docs/pt-br/api/nsa/README.md
@@ -0,0 +1,34 @@
+---
+id: nsa
+sidebar_label: aisp.nsa
+keywords:
+ - immune
+ - sistemas imunológicos artificiais
+ - classificação
+ - seleção negativa
+ - características binárias
+ - detecção de anomalias
+ - reconhecimento de não-próprio
+ - reconhecimento de padrões
+ - multiclasse
+ - valores reais
+ - v-detector
+---
+
+# aisp.nsa
+
+Módulo com Algoritmo de Seleção Negativa (NSA).
+
+> **Módulo:** `aisp.nsa`
+
+## Visão geral
+
+NSAs simulam o processo de maturação das células T no sistema imunológico, no qual essas células aprendem a distinguir
+entre próprio e não-próprio. Apenas as células T capazes de reconhecer elementos não-próprios são preservadas.
+
+## Classes
+
+| Class | Descrição |
+|---------------------|----------------------------------------------------------------------------------------------|
+| [`RNSA`](./rnsa.md) | Um algoritmo de aprendizado supervisionado para classificação de dados com valores reais. |
+| [`BNSA`](./bnsa.md) | Um algoritmo de aprendizado supervisionado para classificação de dados com valores binárias. |
diff --git a/docs/pt-br/api/nsa/bnsa.md b/docs/pt-br/api/nsa/bnsa.md
new file mode 100644
index 0000000..dea7417
--- /dev/null
+++ b/docs/pt-br/api/nsa/bnsa.md
@@ -0,0 +1,193 @@
+---
+id: bnsa
+sidebar_label: BNSA
+keywords:
+ - seleção negativa
+ - características binárias
+ - detecção de anomalias
+ - reconhecimento do não-próprio
+ - reconhecimento de padrões
+ - classificação
+ - multiclasses
+tags:
+ - classificação
+ - supervisionado
+ - seleção negativa
+ - características binárias
+ - detecção de anomalias
+---
+
+# BNSA
+
+Algoritmo de Seleção Negativa Binária (BNSA).
+
+:::tip[Herança]
+Esta classe herda de [BaseClassifier](../base/base-classifier.md)
+:::
+
+
+> **Módulo:** `aisp.nsa`
+> **Importação:** `from aisp.nsa import BNSA`
+
+---
+
+## Visão geral
+
+Algoritmo para classificação e detecção de anomalias baseado na distinção entre próprio e não-próprio, inspirado
+no algoritmo de seleção negativa.
+
+:::note
+
+O _**Binary Negative Selection Algorithm (BNSA)**_ é baseado na proposta original de Forrest et al. (1994) [^1],
+desenvolvido para segurança na computação. Nesta adaptação, o algoritmo usa arrays de bits e possuir suporte para
+classificação multiclasse.
+
+:::
+
+:::warning
+
+Valores altos de `aff_thresh` podem impedir que gere detectores válidos para a detecção do não-próprio.
+
+:::
+
+---
+
+## Exemplo
+
+```python
+from aisp.nsa import BNSA
+
+# Binary 'self' samples
+x_train = [
+ [0, 0, 1, 0, 1],
+ [0, 1, 1, 0, 1],
+ [0, 1, 0, 1, 0],
+ [0, 0, 1, 0, 1],
+ [0, 1, 1, 0, 1],
+ [0, 1, 0, 1, 0]
+]
+y_train = ['self', 'self', 'self', 'self', 'self', 'self']
+bnsa = BNSA(aff_thresh=0.55, seed=1)
+bnsa = bnsa.fit(x_train, y_train, verbose=False)
+# samples for testing
+x_test = [
+ ...[1, 1, 1, 1, 1], # Sample of Anomaly
+ ...[0, 1, 0, 1, 0], # self sample
+ ...]
+y_prev = bnsa.predict(X=x_test)
+print(y_prev)
+```
+
+**Output**
+
+```bash
+['non-self' 'self']
+```
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Default | Descrição |
+|-----------------------------|-----------------|:--------------------------:|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `N` | `int` | `100` | Quantidade de detectores. |
+| `aff_thresh` | `float` | `0.1` | Representa a porcentagem de similaridade entre a célula T e as amostras próprias. O valor padrão é de 10% (0,1), enquanto que o valor de 1,0 representa 100% de similaridade. |
+| `max_discards` | `int` | `1000` | Número máximo de descartes de detectores em sequência, com o objetivo de evitar um possível loop infinito caso seja definido um raio que não seja possível gerar detectores do não-próprio. |
+| `seed` | `Optional[int]` | `None` | Seed para geração aleatória. |
+| `no_label_sample_selection` | `str` | `'max_average_difference'` | Método utilizado para a escolha de rótulos para amostras classificada como não-próprio por todos os detectores. |
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|-------------|-----------------------------------------------------|:------:|-------------------------------------------------|
+| `detectors` | `Optional[Dict[str \| int, npt.NDArray[np.bool_]]]` | - | Conjunto de detectores, organizados por classe. |
+
+---
+
+## Métodos Públicos
+
+### fit
+
+```python
+def fit(
+ self,
+ X: Union[npt.NDArray, list],
+ y: Union[npt.NDArray, list],
+ verbose: bool = True,
+) -> BNSA:
+ ...
+```
+
+Treinamento de acordo com X e y, utilizando o algoritmo de seleção negativa.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `y` | `Union[npt.NDArray, list]` | - | Vetor alvo no formato (n_samples,). Deve conter o mesmo número de amostras que X. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-----------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
+| `TypeError` | Se X ou y não forem ndarrays ou tiverem tamanhos incompatíveis. |
+| `ValueError` | Se X possuir valores diferentes de (0 e 1) ou (True e False). |
+| [`MaxDiscardsReachedError`](../exceptions.md#maxdiscardsreachederror) | Se o número máximo de descartes for atingido durante a maturação. Verifique o valor do raio definido e considere reduzi-lo. |
+
+---
+
+### predict
+
+```python
+def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
+ ...
+```
+
+Prever as classes com base nos detectores gerados após o treinamento.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|----------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada. Deve ter o mesmo número de características usadas no treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|-----------------------------------------------------------------|
+| `npt.NDArray` | Array `C` (`n_samples`), contendo as classes prevista para `X`. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| `TypeError` | Se X não for ndarray ou list. |
+| `ValueError` | Se X possuir valores diferentes de (0 e 1) ou (True e False). |
+| [`FeatureDimensionMismatch`](../exceptions.md#featuredimensionmismatch) | Se o número de característica (colunas) em X não corresponder ao valor esperado. |
+| [`ModelNotFittedError`](../exceptions.md#modelnotfittederror) | Se o modelo ainda não tiver sido treinado e não possuir detectores ou classes definidas. |
+
+---
+
+## Exemplos Estendidos
+
+Exemplos completos de uso estão disponíveis nos notebooks Jupyter:
+
+- [**Mushrooms Dataset Example**](../../../../examples/en/classification/BNSA/mushrooms_dataBase_example_en.ipynb)
+- [**Random Dataset Example**](../../../../examples/en/classification/BNSA/example_with_randomly_generated_dataset-en.ipynb)
+
+---
+
+## Referências
+
+[^1]: S. Forrest, A. S. Perelson, L. Allen and R. Cherukuri, "Self-nonself discrimination in
+ a computer," Proceedings of 1994 IEEE Computer Society Symposium on Research in Security
+ and Privacy, Oakland, CA, USA, 1994, pp. 202-212,
+ doi: https://dx.doi.org/10.1109/RISP.1994.296580.
diff --git a/docs/pt-br/api/nsa/rnsa.md b/docs/pt-br/api/nsa/rnsa.md
new file mode 100644
index 0000000..a488f29
--- /dev/null
+++ b/docs/pt-br/api/nsa/rnsa.md
@@ -0,0 +1,224 @@
+---
+id: rnsa
+sidebar_label: RNSA
+keywords:
+ - seleção negativa
+ - detecção de anomalias
+ - reconhecimento do não-próprio
+ - reconhecimento de padrões
+ - classification
+ - real-valued
+ - v-detector
+ - multiclass
+tags:
+ - classification
+ - supervised
+ - negative selection
+ - real-valued
+ - anomaly detection
+---
+
+# RNSA
+
+Algoritmo de Seleção Negativa com valores reais (RNSA).
+
+:::tip[Herança]
+
+Esta classe herda de [BaseClassifier](../base/base-classifier.md)
+
+:::
+
+
+> **Módulo:** `aisp.nsa`
+> **Importação:** `from aisp.nsa import RNSA`
+
+---
+
+## Visão geral
+
+Algoritmo para classificação e detecção de anomalias baseado na distinção entre próprio e não-próprio, inspirado
+no algoritmo de seleção negativa.
+
+:::note
+
+Este algoritmo possui duas versões diferentes: uma baseada na versão canônica [^1] e outra com detectores com raio
+variável [^2]. Ambas estão adaptadas para trabalhar com múltiplas classes e possuem métodos para previsão de
+dados presentes na região não-self de todos os detectores e classes.
+
+:::
+
+:::warning
+
+Os parâmetros `r` e `r_s` podem impedir a geração de detectores válidos. Um valor para `r` muito pequeno pode limitar
+a cobertura, enquanto muito alto pode dificultar a geração de detectores validos. Da mesma forma, um `r_s` alto
+pode limitar a criação de detectores. Portanto, o ajuste adequado de `r` e `r_s` é essencial para garantir um bom
+desempenho do algoritmo.
+
+:::
+
+---
+
+## Exemplo
+
+```python
+import numpy as np
+from aisp.nsa import RNSA
+
+np.random.seed(1)
+class_a = np.random.uniform(high=0.5, size=(50, 2))
+class_b = np.random.uniform(low=0.51, size=(50, 2))
+```
+
+**Exemplo 1:** Classificação multiclasse (RNSA suporta duas ou mais classes)
+
+```python
+x_train = np.vstack((class_a, class_b))
+y_train = ['a'] * 50 + ['b'] * 50
+rnsa = RNSA(N=150, r=0.3, seed=1)
+rnsa = rnsa.fit(x_train, y_train, verbose=False)
+x_test = [
+ [0.15, 0.45], # Expected: Class 'a'
+ [0.85, 0.65], # Expected: Class 'b'
+]
+y_pred = rnsa.predict(x_test)
+print(y_pred)
+```
+
+**Output**
+
+```bash
+['a' 'b']
+```
+
+**Exemplo 2:** Detecção de anomalias (self/non-self)
+
+```python
+rnsa = RNSA(N=150, r=0.3, seed=1)
+rnsa = rnsa.fit(X=class_a, y=np.array(['self'] * 50), verbose=False)
+y_pred = rnsa.predict(class_b[:5])
+print(y_pred)
+```
+
+**Output**
+
+```bash
+['non-self' 'non-self' 'non-self' 'non-self' 'non-self']
+```
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Default | Descrição |
+|------------------|-------------------------------------------|:---------------:|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `N` | `int` | `100` | Quantidade de detectores. |
+| `r` | `float` | `0.05` | Raio do detector. |
+| `r_s` | `float` | `0.0001` | O valor de rₛ é o raio das amostras próprias dos dados de treinamento X. |
+| `k` | `int` | `1` | Quantidade de vizinhos próximos dos detectores gerados aleatoriamente para efetuar o cálculo da média da distância. |
+| `metric` | `{"euclidean", "minkowski", "manhattan"}` | `'euclidean'` | Métrica de distância usada para calcular a distância entre o detector e a amostra. |
+| `max_discards` | `int` | `1000` | Número máximo de descartes de detectores em sequência, que tem como objetivo evitar um possível loop infinito caso seja definido um raio que não seja possível gerar detectores do não-próprio. |
+| `seed` | `Optional[int]` | `None` | Seed para geração aleatória. |
+| `algorithm` | `{"default-NSA", "V-detector"}` | `'default-NSA'` | Define a versão do algoritmo. |
+| `non_self_label` | `str` | `'non-self'` | Rótulo atribuído quando há apenas uma classe de saída e a amostra não pertence a essa classe. |
+| `cell_bounds` | `bool` | `False` | Se definido como True, esta opção limita a geração dos detectores ao espaço do plano compreendido entre 0 e 1. Isso significa que qualquer detector cujo raio ultrapasse esse limite é descartado, e esta variável é usada exclusivamente no algoritmo `V-detector`. |
+| `p` | `bool` | `2.0` | Valor de `p` utilizado na distância de Minkowski. |
+
+## Atributos
+
+| Nome | Tipo | Padrão | Descrição |
+|-------------|----------------------------------------------|:------:|-------------------------------------------------|
+| `detectors` | `Optional[Dict[str \| int, list[Detector]]]` | - | Conjunto de detectores, organizados por classe. |
+
+---
+
+## Métodos Públicos
+
+### fit
+
+```python
+def fit(
+ self,
+ X: Union[npt.NDArray, list],
+ y: Union[npt.NDArray, list],
+ verbose: bool = True,
+) -> BNSA:
+ ...
+```
+
+Treinamento de acordo com X e y, utilizando o algoritmo de seleção negativa.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|----------------------------|:------:|----------------------------------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada para treinamento. Cada linha corresponde a uma amostra e cada coluna a uma característica. |
+| `y` | `Union[npt.NDArray, list]` | - | Vetor alvo no formato (n_samples,). Deve conter o mesmo número de amostras que X. |
+| `verbose` | `bool` | `True` | Se True, exibe informações sobre o progresso do treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|--------------------------------|
+| `Self` | Retorna a instancia da classe. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-----------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
+| `TypeError` | Se X ou y não forem ndarrays ou tiverem tamanhos incompatíveis. |
+| `ValueError` | Se os valores de X estiverem fora do intervalo (0.0, 1.0). |
+| [`MaxDiscardsReachedError`](../exceptions.md#maxdiscardsreachederror) | Se o número máximo de descartes for atingido durante a maturação. Verifique o valor do raio definido e considere reduzi-lo. |
+
+---
+
+### predict
+
+```python
+def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
+ ...
+```
+
+Prever as classes com base nos detectores gerados após o treinamento.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|----------------------------|:------:|----------------------------------------------------------------------------------------|
+| `X` | `Union[npt.NDArray, list]` | - | Amostras de entrada. Deve ter o mesmo número de características usadas no treinamento. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|-----------------------------------------------------------------|
+| `npt.NDArray` | Array `C` (`n_samples`), contendo as classes prevista para `X`. |
+
+**Exceções**
+
+
+| Exceção | Descrição |
+|-------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| `TypeError` | Se X não for ndarray ou list. |
+| `ValueError` | Se os valores de X estiverem fora do intervalo (0.0, 1.0). |
+| [`FeatureDimensionMismatch`](../exceptions.md#featuredimensionmismatch) | Se o número de característica (colunas) em X não corresponder ao valor esperado. |
+| [`ModelNotFittedError`](../exceptions.md#modelnotfittederror) | Se o modelo ainda não tiver sido treinado e não possuir detectores ou classes definidas. |
+
+---
+
+## Exemplos Estendidos
+
+Exemplos completos de uso estão disponíveis nos notebooks Jupyter:
+
+- [**Iris Dataset Example**](../../../../examples/en/classification/RNSA/iris_dataBase_example_en.ipynb)
+- [**Geyser Dataset Example**](../../../../examples/en/classification/RNSA/geyser_dataBase_example_en.ipynb)
+- [**Random Dataset Example**](../../../../examples/en/classification/RNSA/example_with_randomly_generated_dataset-en.ipynb)
+
+---
+
+## Referências
+
+[^1]: BRABAZON, Anthony; O'NEILL, Michael; MCGARRAGHY, Seán. Natural Computing
+ Algorithms. [S. l.]: Springer Berlin Heidelberg, 2015. DOI 10.1007/978-3-662-43631-8.
+ Disponível em: https://dx.doi.org/10.1007/978-3-662-43631-8.
+
+[^2] Ji, Z.; Dasgupta, D. (2004). Real-Valued Negative Selection Algorithm with Variable-Sized Detectors.
+ In *Lecture Notes in Computer Science*, vol. 3025. https://doi.org/10.1007/978-3-540-24854-5_30
diff --git a/docs/pt-br/api/utils/README.md b/docs/pt-br/api/utils/README.md
new file mode 100644
index 0000000..5b805d8
--- /dev/null
+++ b/docs/pt-br/api/utils/README.md
@@ -0,0 +1,28 @@
+---
+id: utils
+sidebar_label: aisp.utils
+keywords:
+ - functions
+ - helpers
+ - utils
+---
+
+# aisp.utils
+
+Funções utilitárias para auxiliar o desenvolvimento.
+
+> **Módulo:** `aisp.utils`
+> **Importação:** `from aisp import utils`
+
+## SubMódulos
+
+| Módulo | Descrição |
+|----------------------------------|------------------------------------------------------------------------------------|
+| [`display`](./display/README.md) | Funções utilitárias para exibir informações de algoritmos. |
+| [`distance`](./distance.md) | Funções utilitárias para cálculo de distância entre vetores com decoradores numba. |
+| [`metrics`](./metrics.md) | Funções utilitárias para medir acurácia e desempenho. |
+| [`multiclass`](./multiclass.md) | Funções utilitárias para lidar com dados com múltiplas classes. |
+| [`sanitizers`](./sanitizers.md) | Funções utilitárias para validação e tratamento de parâmetros. |
+| [`types`](./types.md) | Define aliases de tipos usados em todo o pacote para melhorar a legibilidade. |
+| [`validation`](./validation.md) | Contém funções responsáveis pela validação de tipos de dados. |
+
diff --git a/docs/pt-br/api/utils/display/README.md b/docs/pt-br/api/utils/display/README.md
new file mode 100644
index 0000000..20c462c
--- /dev/null
+++ b/docs/pt-br/api/utils/display/README.md
@@ -0,0 +1,23 @@
+---
+id: display
+sidebar_label: display
+keywords:
+ - tabela
+ - progresso
+---
+
+# display
+
+Funções utilitárias para exibir informações de algoritmos.
+
+> **Módulo:** `aisp.utils.display`
+> **Importação:** `from aisp.utils import display`
+
+---
+
+## Classes
+
+| Class | Descrição |
+|------------------------------------------|---------------------------------------------------------------------------------|
+| [`TableFormatter`](./table-formatter.md) | Formata dados em tabelas para exibição no console. |
+| [`ProgressTable`](./progress-table.md) | Exibe uma tabela formatada no console para acompanhar o progresso do algoritmo. |
diff --git a/docs/pt-br/api/utils/display/progress-table.md b/docs/pt-br/api/utils/display/progress-table.md
new file mode 100644
index 0000000..73c24eb
--- /dev/null
+++ b/docs/pt-br/api/utils/display/progress-table.md
@@ -0,0 +1,57 @@
+---
+id: progress-table
+sidebar_label: ProgressTable
+---
+
+# ProgressTable
+
+Exibe uma tabela formatada no console para acompanhar o progresso do algoritmo.
+
+:::tip[Herança]
+
+Esta classe herda de [TableFormatter](./table-formatter.md).
+
+:::
+
+
+> **Módulo:** `aisp.utils.display`
+> **Importação:** `from aisp.utils.display import ProgressTable`
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|---------------------|:------:|---------------------------------------------------|
+| `headers` | `Mapping[str, int]` | - | Mapeamento `{nome_da_coluna: largura_da_coluna}`. |
+| `verbose` | `bool` | `True` | Se False, não imprime nada no terminal. |
+
+---
+
+## Métodos Públicos
+
+### update
+
+```python
+def update(self, values: Mapping[str, Union[str, int, float]]) -> None:
+ ...
+```
+
+Adiciona uma nova linha de valores à tabela.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|----------------------------------------|:------:|---------------------------------------------------------------|
+| `values` | `Mapping[str, Union[str, int, float]]` | - | As chaves devem corresponder às colunas definidas em headers. |
+
+---
+
+### finish
+
+```python
+def finish(self) -> None:
+ ...
+```
+
+Finaliza a exibição da tabela, imprimindo a borda inferior e o tempo total.
diff --git a/docs/pt-br/api/utils/display/table-formatter.md b/docs/pt-br/api/utils/display/table-formatter.md
new file mode 100644
index 0000000..56aaaba
--- /dev/null
+++ b/docs/pt-br/api/utils/display/table-formatter.md
@@ -0,0 +1,84 @@
+---
+id: table-formatter
+sidebar_label: TableFormatter
+---
+
+# TableFormatter
+
+Formata dados em tabelas para exibição no console.
+
+> **Módulo:** `aisp.utils.display`
+> **Importação:** `from aisp.utils.display import TableFormatter`
+
+---
+
+## Parâmetros do Construtor
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|---------------------|:------:|--------------------------------------------------------------------------------------------------------------------|
+| `headers` | `Mapping[str, int]` | - | Mapeamento dos nomes das colunas para suas respectivas larguras, no formato `{nome_da_coluna: largura_da_coluna}`. |
+
+---
+
+## Métodos Públicos
+
+### get_header
+
+```python
+def get_header(self):
+ ...
+```
+
+Gera o cabeçalho da tabela, incluindo a borda superior, os nomes das colunas e a linha separadora.
+
+**Returns**
+
+| Tipo | Descrição |
+|-------|---------------------------------------|
+| `str` | String formatada do header da tabela. |
+
+---
+
+### get_row
+
+```python
+def get_row(self, values: Mapping[str, Union[str, int, float]]):
+ ...
+```
+
+Gera uma linha formatada para os dados da tabela.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|----------------------------------------|:------:|--------------------------------------------------------------------------------|
+| `values` | `Mapping[str, Union[str, int, float]]` | - | Dicionário com valores para cada coluna, no formato `{nome_da_coluna: valor}`. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-------|--------------------------------------|
+| `str` | String formatada da linha da tabela. |
+
+---
+
+### get_bottom
+
+```python
+def get_bottom(self, new_line: bool = False):
+ ...
+```
+
+Gera a borda inferior da tabela.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|--------|:-------:|----------------------------------------------------------------------------|
+| `new_line` | `bool` | `False` | Se `True`, adiciona uma quebra de linha antes da borda (padrão é `False`). |
+
+**Returns**
+
+| Tipo | Descrição |
+|-------|-------------------------------------|
+| `str` | String formatada da borda inferior. |
diff --git a/docs/pt-br/api/utils/distance.md b/docs/pt-br/api/utils/distance.md
new file mode 100644
index 0000000..784cb4f
--- /dev/null
+++ b/docs/pt-br/api/utils/distance.md
@@ -0,0 +1,241 @@
+---
+id: distance
+sidebar_label: distance
+keywords:
+ - hamming
+ - euclidean
+ - cityblock
+ - Manhattan
+ - minkowski
+ - distância
+---
+
+# distance
+
+Funções utilitárias para cálculo de distância entre vetores com decoradores numba.
+
+> **Módulo:** `aisp.utils.distance`
+> **Importação:** `from aisp.utils import distance`
+
+## Funções
+
+### hamming
+
+```python
+@njit([(types.boolean[:], types.boolean[:])], cache=True)
+def hamming(u: npt.NDArray[np.bool_], v: npt.NDArray[np.bool_]) -> float64:
+ ...
+```
+
+Calcula a distância de Hamming entre dois pontos.
+
+$$
+\frac{(x_1 \neq y_1) + (x_2 \neq y_2) + \cdots + (x_n \neq y_n)}{n}
+$$
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|-------------------------|:------:|--------------------------------|
+| `u` | `npt.NDArray[np.bool_]` | - | Coordenadas do primeiro ponto. |
+| `v` | `npt.NDArray[np.bool_]` | - | Coordenadas do segundo ponto. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------|-----------------------------------------|
+| `float64` | Distância de Hamming entre dois pontos. |
+
+---
+
+### euclidean
+
+```python
+@njit()
+def euclidean(u: npt.NDArray[np.float64], v: npt.NDArray[np.float64]) -> float64:
+ ...
+```
+
+Calcula a distância de Euclidean entre dois pontos.
+
+$$
+\sqrt{(X_{1} - X_{1})^2 + (Y_{2} - Y_{2})^2 + \cdots + (Y_{n} - Y_{n})^2}
+$$
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|------------------------|:------:|--------------------------------|
+| `u` | `npt.NDArray[float64]` | - | Coordenadas do primeiro ponto. |
+| `v` | `npt.NDArray[float64]` | - | Coordenadas do segundo ponto. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------|-------------------------------------------|
+| `float64` | Distância de Euclidean entre dois pontos. |
+
+---
+
+### cityblock
+
+```python
+@njit()
+def cityblock(u: npt.NDArray[float64], v: npt.NDArray[float64]) -> float64:
+ ...
+```
+
+Calcula a distância de Manhattan entre dois pontos.
+
+$$
+|X_{1} - Y_{1}| + |X_{2} - Y_{2}| + \cdots + |X_{n} - Y_{n}|
+$$
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|------------------------|:------:|--------------------------------|
+| `u` | `npt.NDArray[float64]` | - | Coordenadas do primeiro ponto. |
+| `v` | `npt.NDArray[float64]` | - | Coordenadas do segundo ponto. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------|-------------------------------------------|
+| `float64` | Distância de Manhattan entre dois pontos. |
+
+---
+
+### minkowski
+
+```python
+@njit()
+def minkowski(
+ u: npt.NDArray[float64],
+ v: npt.NDArray[float64],
+ p: float = 2.0
+) -> float64:
+ ...
+```
+
+Calcula a distância de Minkowski entre dois pontos.
+
+$$
+(|X_{1} - Y_{1}|^p + |X_{2} - Y_{2}|^p + \cdots + |X_{n} - Y_{n}|^p)^\frac{1}{p}|
+$$
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|------------------------|:------:|------------------------------------------------------------|
+| `u` | `npt.NDArray[float64]` | - | Coordenadas do primeiro ponto. |
+| `v` | `npt.NDArray[float64]` | - | Coordenadas do segundo ponto. |
+| `p` | `float` | `2.0` | Parâmetro que define o tipo de distância a ser calculada. |
+
+:::note[Parâmetro `p`]
+
+- p = 1: distância **Manhattan** - soma das diferenças
+- p = 2: distância **Euclidean** - soma dos quadrados (raiz quadrada).
+- p > 2: distância **Minkowski** com penalização crescente conforme `p` aumenta.
+
+:::
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------|-------------------------------------------|
+| `float64` | Distância de Minkowski entre dois pontos. |
+
+---
+
+### compute_metric_distance
+
+```python
+@njit([(types.float64[:], types.float64[:], types.int32, types.float64)], cache=True)
+def compute_metric_distance(
+ u: npt.NDArray[float64],
+ v: npt.NDArray[float64],
+ metric: int,
+ p: float = 2.0
+) -> float64:
+ ...
+```
+
+Calcula a distância entre dois pontos com base na métrica escolhida.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|------------------------|:------:|------------------------------------------------------------------------------------------|
+| `u` | `npt.NDArray[float64]` | - | Coordenadas do primeiro ponto. |
+| `v` | `npt.NDArray[float64]` | - | Coordenadas do segundo ponto. |
+| `metric` | `int` | - | Métrica de distância que será usada. Opções: 0 (Euclidean), 1 (Manhattan), 2 (Minkowski) |
+| `p` | `float` | `2.0` | Parâmetro que define o tipo de distância a ser calculada |
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------|-----------------------------------------------------------|
+| `float64` | Distância entre os dois pontos com a métrica selecionada. |
+
+---
+
+### min_distance_to_class_vectors
+
+```python
+@njit([(types.float64[:, :], types.float64[:], types.int32, types.float64)], cache=True)
+def min_distance_to_class_vectors(
+ x_class: npt.NDArray[float64],
+ vector_x: npt.NDArray[float64],
+ metric: int,
+ p: float = 2.0,
+) -> float:
+ ...
+```
+
+Calcula distância entre um vetor de entrada e os vetores de uma classe e retorna a distância minima.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|------------------------|:------:|---------------------------------------------------------------------------------------------------------------------------|
+| `x_class` | `npt.NDArray[float64]` | - | Array contendo os vetores da classe a serem comparados com o vetor de entrada. Formato esperado: (n_samples, n_features). |
+| `vector_x` | `npt.NDArray[float64]` | - | Vetor a ser comparado com os vetores da classe. Formato esperado: (n_features,). |
+| `metric` | `int` | - | Métrica de distância a ser usada. Opções: 0 ("euclidean"), 1 ("manhattan"), 2 ("minkowski") or ("hamming") |
+| `p` | `float` | `2.0` | Parâmetro da distância de Minkowski (usado apenas quando metric="minkowski"). |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------|--------------------------------------------------------------------------------------------------------------------------------|
+| `float` | A menor distância calculada entre o vetor de entrada e os vetores da classe. Retorna -1.0 se as dimensões forem incompatíveis. |
+
+---
+
+### get_metric_code
+
+```python
+def get_metric_code(metric: str) -> int:
+ ...
+```
+
+Obtém o valor associado a uma métrica de distância.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|-------|:------:|---------------------------------------------------------------------------------------|
+| `metric` | `str` | - | Nome da métrica. Pode ser `"euclidean"`, `"manhattan"`, `"minkowski"` or `"hamming"`. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-------|----------------------------------|
+| `int` | Número correspondente à métrica. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|-------------------------------------------|
+| `ValueError` | Se a métrica fornecida não for suportada. |
+
diff --git a/docs/pt-br/api/utils/metrics.md b/docs/pt-br/api/utils/metrics.md
new file mode 100644
index 0000000..830911a
--- /dev/null
+++ b/docs/pt-br/api/utils/metrics.md
@@ -0,0 +1,47 @@
+---
+id: metrics
+sidebar_label: metrics
+keywords:
+ - accuracy
+ - score
+---
+
+# metrics
+
+Funções utilitárias para medir acurácia e desempenho.
+
+> **Módulo:** `aisp.utils.metrics`
+> **Importação:** `from aisp.utils import metrics`
+
+## Funções
+
+### accuracy_score
+
+```python
+def accuracy_score(
+ y_true: Union[npt.NDArray, list],
+ y_pred: Union[npt.NDArray, list]
+) -> float:
+ ...
+```
+
+Calcula a acurácia com base nos rótulos reais e previstos.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|----------------------------|:------:|-------------------------------------------------------------------|
+| `y_true` | `Union[npt.NDArray, list]` | - | Rótulos reais (corretos). Devem ter o mesmo tamanho que `y_pred`. |
+| `y_pred` | `Union[npt.NDArray, list]` | - | Rótulos previstos. Devem ter o mesmo tamanho que `y_true`. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------|--------------------------------------------------------------------|
+| `float` | A proporção de previsões corretas em relação ao total de previsões |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|--------------------------------------------------------------------------|
+| `ValueError` | Se y_true ou y_pred estiverem vazios ou se não tiverem o mesmo tamanho. |
diff --git a/docs/pt-br/api/utils/multiclass.md b/docs/pt-br/api/utils/multiclass.md
new file mode 100644
index 0000000..d06c26d
--- /dev/null
+++ b/docs/pt-br/api/utils/multiclass.md
@@ -0,0 +1,82 @@
+---
+id: multiclass
+sidebar_label: multiclass
+keywords:
+ - k-nearest neighbors
+ - samples
+ - slice
+ - multiclass
+---
+
+# multiclass
+
+Funções utilitárias para lidar com dados com múltiplas classes.
+
+> **Módulo:** `aisp.utils.multiclass`
+> **Importação:** `from aisp.utils import multiclass`
+
+## Funções
+
+### slice_index_list_by_class
+
+```python
+def slice_index_list_by_class(classes: Optional[Union[npt.NDArray, list]], y: npt.NDArray) -> dict:
+ ...
+```
+
+Separa os índices das amostras por classe para iteração direcionada.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------|--------------------------------------|:------:|-----------------------------------------------------------------------------------|
+| `classes` | `Optional[Union[npt.NDArray, list]]` | - | lista com classes únicas. |
+| `y` | `npt.NDArray` | - | Recebe um array `y` (`n_samples`) om as classes de saída do array de amostra `X`. |
+
+**Returns**
+
+| Tipo | Descrição |
+|--------|---------------------------------------------------------------------------------|
+| `dict` | Um dicionário com a lista de posições do array(`y`), com as classes como chave. |
+
+**Example**
+
+```python
+import numpy as np
+from aisp.utils.multiclass import slice_index_list_by_class
+
+labels = ['a', 'b', 'c']
+y = np.array(['a', 'c', 'b', 'a', 'c', 'b'])
+slice_index_list_by_class(labels, y)
+```
+
+---
+
+### predict_knn_affinity
+
+```python
+def predict_knn_affinity(
+ X: npt.NDArray,
+ k: int,
+ all_cell_vectors: List[Tuple[Union[str, int], npt.NDArray]],
+ affinity_func: Callable[[npt.NDArray, npt.NDArray], float]
+) -> npt.NDArray:
+ ...
+```
+
+Prever classes usando k-vizinhos mais próximos e células treinadas.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|--------------------|-----------------------------------------------|:------:|-----------------------------------------------------------------|
+| `X` | `npt.NDArray` | - | Dados de entrada a serem classificados. |
+| `k` | `int` | - | Número de vizinhos mais próximos a considerar para a previsão. |
+| `all_cell_vectors` | `List[Tuple[Union[str, int], npt.NDArray]]` | - | Lista de tuplas contendo (nome_da_classe, cell(np.ndarray)). |
+| `affinity_func` | `Callable[[npt.NDArray, npt.NDArray], float]` | - | Função que recebe dois vetores e retorna um valor de afinidade. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|------------------------------------------------------------------------------------------|
+| `npt.NDArray` | Array de rótulos previstos para cada amostra em X, baseado nos k vizinhos mais próximos. |
diff --git a/docs/pt-br/api/utils/sanitizers.md b/docs/pt-br/api/utils/sanitizers.md
new file mode 100644
index 0000000..6636f66
--- /dev/null
+++ b/docs/pt-br/api/utils/sanitizers.md
@@ -0,0 +1,119 @@
+---
+id: sanitizers
+sidebar_label: sanitizers
+keywords:
+ - sanitize
+---
+
+# sanitizers
+
+Funções utilitárias para validação e tratamento de parâmetros.
+
+> **Módulo:** `aisp.utils.sanitizers`
+> **Importação:** `from aisp.utils import sanitizers`
+
+## Funções
+
+### sanitize_choice
+
+```python
+def sanitize_choice(value: T, valid_choices: Iterable[T], default: T) -> T:
+ ...
+```
+
+Retorna o valor se estiver presente no conjunto de opções válidas; caso contrário, retorna o valor padrão.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-----------------|---------------|:------:|-------------------------------------------------------------------------------|
+| `value` | `T` | - | O valor a ser verificado. |
+| `valid_choices` | `Iterable[T]` | - | Uma coleção de opções válidas. |
+| `default` | `T` | - | O valor padrão a ser retornado se `'value'` não estiver em `'valid_choices'`. |
+
+**Returns**
+
+| Tipo | Descrição |
+|------|---------------------------------------------------------|
+| `T` | O valor original, se válido, ou o valor padrão, se não. |
+
+---
+
+### sanitize_param
+
+```python
+def sanitize_param(value: T, default: T, condition: Callable[[T], bool]) -> T:
+ ...
+```
+
+Retorna o valor se ele satisfizer a condição especificada; caso contrário, retorna o valor padrão.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-------------|-----------------------|:------:|-----------------------------------------------------------------------------------------|
+| `value` | `T` | - | O valor a ser verificado. |
+| `default` | `T` | - | O valor padrão a ser retornado se a condição não for satisfeita. |
+| `condition` | `Callable[[T], bool]` | - | Uma função que recebe um valor e retorna um booleano, determinando se o valor é válido. |
+
+**Returns**
+
+| Tipo | Descrição |
+|------|------------------------------------------------------------------------------|
+| `T` | O valor original se a condição for satisfeita, ou o valor padrão se não for. |
+
+---
+
+### sanitize_seed
+
+```python
+def sanitize_seed(seed: Any) -> Optional[int]:
+ ...
+```
+
+Retorna a semente se for um inteiro não negativo; caso contrário, retorna Nenhum.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|--------|-------|:------:|---------------------------------|
+| `seed` | `Any` | - | O valor da seed a ser validado. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------------|----------------------------------------------------------------------------|
+| `Optional[int]` | A seed original se for um inteiro não negativo, ou `None` se for inválido. |
+
+---
+
+### sanitize_bounds
+
+```python
+def sanitize_bounds(
+ bounds: Any, problem_size: int
+) -> Dict[str, npt.NDArray[np.float64]]:
+ ...
+```
+
+Valida e normaliza os limites das características.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------------|-------|:------:|--------------------------------------------------------------------------------------------------------------|
+| `bounds` | `Any` | - | Os limites de entrada, que devem ser None ou um dicionário com as chaves `'low'` e `'high'`. |
+| `problem_size` | `int` | - | O tamanho esperado para as listas de limites normalizadas, correspondente ao número de features do problema. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-------------------|---------------------------------------------------------------------------|
+| `Dict[str, list]` | Dicionário `{'low': [low_1, ..., low_N], 'high': [high_1, ..., high_N]}`. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|----------------------------------------------------------------------------------------------------------------|
+| `TypeError` | Se bounds não for `None` nem um dicionário com as chaves `'low'/'high'`, ou se os valores não forem numéricos. |
+| `ValueError` | Se os iteráveis fornecidos tiverem tamanho incorreto. |
diff --git a/docs/pt-br/api/utils/types.md b/docs/pt-br/api/utils/types.md
new file mode 100644
index 0000000..6f56b58
--- /dev/null
+++ b/docs/pt-br/api/utils/types.md
@@ -0,0 +1,60 @@
+---
+id: types
+sidebar_label: types
+keywords:
+ - tipos
+ - tipagem
+ - aliases
+ - type hints
+---
+
+# types
+
+Define aliases de tipos usados em todo o pacote para melhorar a legibilidade.
+
+> **Módulo:** `aisp.utils.types`
+> **Importação:** `from aisp.utils import types`
+
+## Type aliases
+
+### FeatureType
+
+```python
+FeatureType: TypeAlias = Literal[
+ "binary-features", "continuous-features", "ranged-features"
+]
+```
+
+Tipo das características de entrada
+
+- `"binary-features"`: Valores apenas com (0 ou 1, `False` ou `True`).
+- `"continuous-features"`: Valores numéricos contínuos.
+- `"ranged-features"`: Valores entre um intervalo definido.
+
+---
+
+### FeatureTypeAll
+
+```python
+FeatureTypeAll: TypeAlias = Union[FeatureType, Literal["permutation-features"]]
+```
+
+Mesmo que `FeatureType`, mais:
+
+- `"permutation-features"`: valores representados como permutação.
+
+---
+
+### MetricType
+
+```python
+MetricType: TypeAlias = Literal["manhattan", "minkowski", "euclidean"]
+```
+
+Métrica de distância utilizada nos cálculos:
+
+- `"manhattan"`: distância de Manhattan entre dois pontos.
+- `"minkowski"`: distância de Minkowski entre dois pontos.
+- `"euclidean"`: distância de Euclidean entre dois pontos.
+
+---
\ No newline at end of file
diff --git a/docs/pt-br/api/utils/validation.md b/docs/pt-br/api/utils/validation.md
new file mode 100644
index 0000000..c8a3ba9
--- /dev/null
+++ b/docs/pt-br/api/utils/validation.md
@@ -0,0 +1,180 @@
+---
+id: validation
+sidebar_label: validation
+keywords:
+ - validação
+---
+
+# Módulo
+
+Contém funções responsáveis pela validação de tipos de dados.
+
+> **Módulo:** `aisp.utils.validation`
+> **Importação:** `from aisp.utils import validation`
+
+## Funções
+
+### detect_vector_data_type
+
+```python
+def detect_vector_data_type(vector: npt.NDArray) -> FeatureType:
+ ...
+```
+
+Detecta o tipo de dado em um determinado vetor.
+
+Esta função analisa o vetor de entrada e classifica seus dados como um dos tipos suportados:
+
+* **binário**: Valores booleanos (True/False) ou inteiro 0/1.
+* **contínuo**: Valores float dentro do intervalo normalizado [0.0, 1.0].
+* **intervalo**: Valores float fora do intervalo normalizado.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|----------|---------------|:------:|---------------------------------------------------|
+| `vector` | `npt.NDArray` | - | Um array contendo os dados a serem classificados. |
+
+**Returns**
+
+| Tipo | Descrição |
+|-----------------------------------------|-----------------------------------------------------------------------------------------------------|
+| [`FeatureType`](./types.md#featuretype) | O tipo de dado detectado no vetor: "binary-features", "continuous-features", or " ranged-features". |
+
+**Exceções**
+
+| Exceção | Descrição |
+|------------------------|----------------------------------------------------|
+| `UnsupportedTypeError` | Se o vetor contiver um tipo de dado não suportado. |
+
+---
+
+### check_array_type
+
+```python
+def check_array_type(x, name: str = "X") -> npt.NDArray:
+ ...
+```
+
+Garante que X seja um array numpy. Converte a partir de lista, se necessário.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|--------|-------|:------:|--------------------------------------------------------------------------------------|
+| `x` | `Any` | - | Array contendo as amostras e suas características. Formato: (n_samples, n_features). |
+| `name` | `str` | `'X'` | Nome da variável usado em mensagens de erro. |
+
+**Returns**
+
+| Tipo | Descrição |
+|---------------|---------------------------------|
+| `npt.NDArray` | O array convertido ou validado. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------|---------------------------------|
+| `TypeError` | Se x não for ndarray nem lista. |
+
+---
+
+### check_shape_match
+
+```python
+def check_shape_match(x: npt.NDArray, y: npt.NDArray):
+ ...
+```
+
+Garante que X e y tenham dimensões compatíveis.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|---------------|:------:|--------------------------------------------------------------------------------------|
+| `x` | `npt.NDArray` | - | Array contendo as amostras e suas características. Formato: (n_samples, n_features). |
+| `y` | `npt.NDArray` | - | Array com as classes alvo de `x`, com formato (`n_samples`). |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------|-------------------------------------------|
+| `TypeError` | Se x ou y tiverem formatos incompatíveis. |
+
+---
+
+### check_feature_dimension
+
+```python
+def check_feature_dimension(x: npt.NDArray, expected: int):
+ ...
+```
+
+Garante que o array possui o número esperado de características (features).
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------------|---------------|:------:|-----------------------------------------------------------------------------------------------------------------|
+| `x` | `npt.NDArray` | - | Array de entrada para predição, contendo as amostras e suas características. Formato:: (n_samples, n_features). |
+| `expected` | `int` | - | Número esperado de features por amostra (colunas em X). |
+
+**Exceções**
+
+| Exceção | Descrição |
+|-------------------------------------------------------------------------|------------------------------------------------------------|
+| [`FeatureDimensionMismatch`](../exceptions.md#featuredimensionmismatch) | Se o número de features em X não corresponder ao esperado. |
+
+---
+
+### check_binary_array
+
+```python
+def check_binary_array(x: npt.NDArray):
+ ...
+```
+
+Garante que X contenha apenas valores (0 e 1) or (`True` e `False`).
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|------|---------------|:------:|-----------------------------|
+| `x` | `npt.NDArray` | - | Array contendo as amostras. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|---------------------------------------------------|
+| `ValueError` | Se o array contiver valores diferentes de 0 e 1. |
+
+---
+
+### check_value_range
+
+```python
+def check_value_range(
+ x: npt.NDArray,
+ name: str = 'X',
+ min_value: float = 0.0,
+ max_value: float = 1.0
+) -> None:
+ ...
+```
+
+Garante que todos os valores do array x estejam dentro do intervalo.
+
+**Parâmetros**
+
+| Nome | Tipo | Padrão | Descrição |
+|-------------|---------------|:------:|---------------------------------|
+| `x` | `npt.NDArray` | - | Array contendo as amostras. |
+| `name` | `str` | `'X'` | Nome usado na mensagem de erro. |
+| `min_value` | `float` | `0.0` | Valor mínimo permitido. |
+| `max_value` | `float` | `1.0` | Valor máximo permitido. |
+
+**Exceções**
+
+| Exceção | Descrição |
+|--------------|--------------------------------------------------------------|
+| `ValueError` | Se o array estiver fora do intervalo (min_value, max_value). |
diff --git a/docs/pt-br/architecture.md b/docs/pt-br/architecture.md
new file mode 100644
index 0000000..1eea424
--- /dev/null
+++ b/docs/pt-br/architecture.md
@@ -0,0 +1,51 @@
+---
+id: architecture
+sidebar_position: 5
+sidebar_label: Arquitetura
+keywords:
+ - arquitetura
+---
+
+# Arquitetura do AISP
+
+O AISP (**A**rtificial **I**mmune **S**ystems **P**ackage) é um pacote dedicado à implementação de algoritmos
+inspirados no sistema imunológico dos vertebrados. Essa documentação foca na arquitetura do projeto, com o intuito de
+auxiliar contribuições e manutenção.
+A estrutura do pacote é modular, com separação clara entre as famílias de algoritmos e modulos de suporte para
+reutilização de componente pelos algoritmos.
+
+## Organização dos modulos
+
+A hierarquia do pacote esta divida em 3 núcleos principais: base, utils e famílias de algoritmos.
+O núcleo base concentra nas abstrações e modelagens imunológicas, servindo como a fundação para os algoritmos.
+Já utils reúne funções que auxiliam na implementação dos algoritmos evitando redundância de código.
+
+O núcleo das famílias de algoritmos agrupa os conforme as metáforas dos sistemas imunológicos que os define.
+
+As principais famílias de algoritmos são:
+
+- Danger Theory Algorithms (DTA) - Previsto para versões futuras do pacote
+- Clonal Selection Algorithms (CSA)
+- Immune Network Algorithms (INA)
+- Negative Selection Algorithms (NSA)
+
+Representação visual:
+
+```mermaid
+flowchart TB
+ AISP
+
+ subgraph families [Famílias de Algoritmos]
+ DTA[dta]
+ CSA[csa]
+ INA[ina]
+ NSA[nsa]
+ end
+
+ AISP --> DTA
+ AISP --> CSA
+ AISP --> INA
+ AISP --> NSA
+ AISP --> BASE[base]
+ AISP --> UTILS[utils]
+```
diff --git a/docs/pt-br/classes/Clonal Selection Algorithms/AIRS.md b/docs/pt-br/classes/Clonal Selection Algorithms/AIRS.md
deleted file mode 100644
index 02cac0e..0000000
--- a/docs/pt-br/classes/Clonal Selection Algorithms/AIRS.md
+++ /dev/null
@@ -1,280 +0,0 @@
-# AIRS (Sistema de Reconhecimento Imune Artificial)
-
-Esta classe estende a classe [**Base**](../../advanced-guides/base/classifier.md).
-
-## Construtor AIRS
-
-A classe `AIRS` realiza classificação utilizando metáforas de seleção e expansão clonal.
-
-Esta implementação é inspirada no AIRS2, uma versão simplificada do algoritmo AIRS original, introduzindo adaptações para lidar com conjuntos de dados contínuos e binários.
-
-Baseado no Algoritmo 16.5 de Brabazon et al. [1](#ref1).
-
-Estudos relacionados de destaque: [2](#ref2).
-
-**Atributos:**
-
-* **n_resources** (`float`): Quantidade total de recursos disponíveis. O padrão é 10.
-* **rate_clonal** (`float`): Número máximo de clones possíveis de uma classe. Esta quantidade é multiplicada por (estímulo da célula * taxa de hipermutação) para definir o número de clones. O padrão é 10.
-* **rate_mc_init** (`float`): Percentual de amostras usadas para inicializar as células de memórias. O padrão é 0,75.
-* **rate_hypermutation** (`float`): Taxa de clones mutados derivada de rate_clonal como um fator escalar. O padrão é 0,2.
-* **affinity_threshold_scalar** (`float`): Limiar de afinidade normalizado. O padrão é 0,75.
-* **k** (`int`): Número de vizinhos mais próximos (k-NN) que será usado para escolher um rótulo na predição. O padrão é 3.
-* **max_iters** (`int`): Número máximo de interações no processo de refinamento do conjunto ARB exposto a aᵢ. O padrão é 100.
-* **resource_amplified** (`float`): Amplificador de consumo de recursos, multiplicado com o estímulo para subtrair recursos. O padrão é 1.0 (sem amplificação).
-* **metric** (`Literal["manhattan", "minkowski", "euclidean"]`): Forma de calcular a distância entre o detector e a amostra:
- * `'euclidean'` ➜ O cálculo da distância é dado pela expressão:
- √( (x₁ - x₂)² + (y₁ - y₂)² + ... + (nₙ - nₙ)² ).
- * `'minkowski'` ➜ O cálculo da distância é dado pela expressão:
- ( |X₁ - Y₁|ᵖ + |X₂ - Y₂|ᵖ + ... + |Xₙ - Yₙ|ᵖ )¹/ᵖ.
- * `'manhattan'` ➜ O cálculo da distância é dado pela expressão:
- ( |x₁ - x₂| + |y₁ - y₂| + ... + |nₙ - nₙ| ).
- O padrão é "euclidean".
-
-* **seed** (int): Semente para geração aleatória de valores dos detectores. O padrão é None.
-* `**kwargs`:
- * **p** (`float`): Este parâmetro armazena o valor de `p` usado na distância de Minkowski.
- O padrão é `2`, que corresponde à distância euclidiana normalizada. Diferentes valores de p resultam em variantes distintas da distância de Minkowski. [Saiba mais](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.minkowski.html).
-
-**Outras variáveis inicializadas:**
-
-* **cells_memory** (`dict`): Armazena uma lista de células de memória por classe.
-* **affinity_threshold** (`dict`): Define o limiar de afinidade entre antígenos.
-* **classes** (`npt.NDArray`): Lista de classes de saída.
-
----
-
-## Métodos Públicos
-
-### Método `fit(...)`
-
-A função `fit(...)` gera detectores para os não-pertencentes em relação às amostras:
-
-```python
-def fit(
- self,
- X: Union[npt.NDArray, list],
- y: Union[npt.NDArray, list],
- verbose: bool = True,
-) -> AIRS:
-```
-
-Realiza o treinamento conforme `X` e `y`, utilizando o método Sistema de Reconhecimento Imune Artificial (`AIRS`).
-
-**Parâmetros:**
-
-* **X** (``Union[npt.NDArray, list]``): Array com as características das amostras, com **N** amostras (linhas) e **N** características (colunas), normalizado para valores entre [0, 1].
-* **y** (``Union[npt.NDArray, list]``): Array com as classes de saída correspondentes às **N** amostras relacionadas a `X`.
-* **verbose**: (``bool``, padrão=True), determina se o feedback da geração dos detectores será impresso.
-
-**Retorna:**
-
-* `AIRS`: A instância da classe.
-
----
-
-### Método `predict(...)`
-
-A função `predict(...)` realiza a predição de classes utilizando os detectores gerados:
-
-```python
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): Array com as características para predição, com **N** amostras (linhas) e **N** colunas.
-
-**Raises**
-
-* `TypeError`: Se X não for um ndarray ou uma lista.
-* `FeatureDimensionMismatch`: Se o número de características em X não corresponder ao número esperado.
-* `ModelNotFittedError`: Se o modelo ainda não tiver sido ajustado e não possuir células de memória definidas, não conseguirá realizar predições.
-
-
-**Retorna:**
-
-* **C**: Um array de predições com as classes de saída para as características fornecidas.
-
----
-
-### Método `score(...)`
-
-A função `score(...)` calcula a acurácia do modelo treinado realizando predições e calculando a precisão.
-
-```python
-def score(self, X: npt.NDArray, y: list) -> float:
-```
-
-**Retorna:**
-
-Retorna a acurácia como um `float`.
-
----
-
-## Métodos Privados
-
-### Método `_refinement_arb(...)`
-
-A função "_refinement_arb(...)" refina o conjunto ARB até que o valor médio de estímulo ultrapasse o limiar definido (`affinity_threshold_scalar`).
-
-```python
-def _refinement_arb(
- self,
- ai: npt.NDArray,
- c_match_stimulation: float,
- arb_list: List[_ARB]
-) -> _ARB:
-```
-
-**Parâmetros:**
-* **ai** (`npt.NDArray`): Antígeno atual
-* **c_match_stimulation** (``float``): Célula com o maior estímulo em relação a aᵢ.
-* **arb_list** (`List[_ARB]`): Conjunto ARB.
-
-**Retorna:**
-
-Retorna a célula (`_ARB`) com o maior estímulo ARB.
-
----
-
-### Método `_cells_affinity_threshold(...)`
-
-A função "_cells_affinity_threshold(...)" calcula o limiar de afinidade com base na afinidade média entre instâncias de treinamento, onde aᵢ e aⱼ são um par de antígenos, e a afinidade é medida pela distância (Euclidiana, Manhattan, Minkowski, Hamming).
-
-```python
-def _cells_affinity_threshold(self, antigens_list: npt.NDArray):
-```
-
-**Seguindo a fórmula:**
-
-$$
-\text{affinity}_{\text{threshold}} = \frac{
-\sum_{i=1}^{n-1} \sum_{j=i+1}^{n} \text{affinity}(a_i, a_j)}{n(n-1)/2}
-$$
-
-
-**Parâmetros:**
-
-* **antigens_list** (`npt.NDArray`): Lista de antígenos de treinamento.
-
----
-
-### Método `_affinity(...)`
-
-A função "_affinity(...)" calcula o estímulo entre dois vetores usando métricas.
-
-
-```python
-def _affinity(self, u: npt.NDArray, v: npt.NDArray) -> float:
-```
-
-**Parâmetros:**
-
-* **u** (`npt.NDArray`): Coordenadas do primeiro ponto.
-* **v** (`npt.NDArray`): Coordenadas do segundo ponto.
-
-**Retorna:**
-
-Retorna a taxa de estímulo entre os vetores.
-
----
-
-### Método `_init_memory_c(...)`
-
-A função "_init_memory_c(...)" inicializa células de memória selecionando aleatoriamente `n_antigens_selected` da lista de antígenos de treinamento.
-
-```python
-def _init_memory_c(self, antigens_list: npt.NDArray) -> List[Cell]:
-```
-
-**Parâmetros:**
-
-* **antigens_list** (`npt.NDArray`): Lista de antígenos de treinamento.
-
----
-
-
-### Method `_slice_index_list_by_class(...)`
-
-A função ``_slice_index_list_by_class(...)``, separa os índices das linhas conforme a classe de saída, para percorrer o array de amostra, apenas nas posições que a saída for a classe que está sendo treinada:
-
-
-```python
-def _slice_index_list_by_class(self, y: npt.NDArray) -> dict:
-```
-
-**Parâmetros**:
-
-* **y** (`npt.NDArray`): Recebe um array ``n_samples`` com as classes de saída do array de amostras ``X``.
-
-**Retorna:**
-
-Retorna um dicionário com as classes como chave e os índices em ``X`` das amostras.
-
----
-
-### Method `__prepare_features(...)`
-
-A função ``__prepare_features(...)`` verifica as amostras, especificando o tipo, a quantidade de características e outros parâmetros.
-
-```python
-def _prepare_features(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-* Este método atualiza os seguintes atributos:
- * ``self._feature_type``
- * ``self.metric`` (apenas para características binárias)
- * ``self._bounds`` (apenas para características com intervalo definido)
- * ``self._n_features``
-
-
-**Parameters:**
-
-* **X** (``Union[npt.NDArray, list]``): Array com as características para predição, contendo N amostras (linhas) e N colunas.
-
-Retorna os dados de entrada processados.
-
----
-
-# Classes Auxiliares
-
----
-
-## Classe _ARB (Herdada de [BCell](../../advanced-guides/base/immune/cell.md#bcell))
-
-### Construtor
-
-**Parâmetros:**
-
-* vector (`npt.NDArray`): Vetor de características da célula. Padrão é None.
-
----
-
-### Método `consume_resource(...)`
-
-```python
-def consume_resource(self, n_resource: float, amplified: float = 1) -> float:
-```
-
-**Parâmetros:**
-
-* **n_resource** (`float`) : A quantidade inicial de recursos.
-* **amplified** (`float`): Amplificador para o consumo de recursos pela célula. É multiplicado pelo estímulo da célula. O padrão é 1.
-
-**Retorna:**
-
-Retorna a quantidade restante de recursos após o consumo.
-
----
-
-# Referências
-
-
-
-> 1. BRABAZON, Anthony; O'NEILL, Michael; MCGARRAGHY, Seán. Natural Computing Algorithms. [S. l.]: Springer Berlin Heidelberg, 2015. DOI 10.1007/978-3-662-43631-8. Disponível em: [http://dx.doi.org/10.1007/978-3-662-43631-8](http://dx.doi.org/10.1007/978-3-662-43631-8).
-
-
-
-> 2. AZZOUG, Aghiles. Artificial Immune Recognition System V2.
-> Disponível em: [https://github.com/AghilesAzzoug/Artificial-Immune-System](https://github.com/AghilesAzzoug/Artificial-Immune-System)
diff --git a/docs/pt-br/classes/Clonal Selection Algorithms/Clonalg.md b/docs/pt-br/classes/Clonal Selection Algorithms/Clonalg.md
deleted file mode 100644
index 931dbe2..0000000
--- a/docs/pt-br/classes/Clonal Selection Algorithms/Clonalg.md
+++ /dev/null
@@ -1,183 +0,0 @@
-# Algoritmo de Seleção Clonal (CLONALG)
-
-## Clonalg
-
-A classe `Clonalg` é um **algoritmo de otimização** inspirado no processo biológico de seleção clonal do sistema
-imunológico. Esta implementação é projetada para minimizar ou maximizar funções de custo em diversos tipos de
-problemas, incluindo problemas binários, contínuos, com valores limitados (ranged) e de permutação.
-
-A implementação do CLONALG foi inspirada na descrição apresentada em [1](#ref1).
-
-Esta implementação do CLONALG contém algumas alterações baseadas no contexto do AISP, para aplicação geral
-a diversos problemas, que podem produzir resultados diferentes da implementação padrão ou
-específica. Esta adaptação visa generalizar o CLONALG para tarefas de minimização e
-maximização, além de suportar problemas contínuos, discretos e de permutação.
-
----
-
-### Construtor
-
-O construtor inicializa a instância do CLONALG com os principais parâmetros que definem o processo de otimização.
-
-**Atributos:**
-
-* **problem_size** (`int`): Dimensão do problema a ser otimizado.
-* **N** (`int`, padrão=50): Número de células de memória (anticorpos) na população.
-* **rate_clonal** (`float`, padrão=10): Número máximo de clones possíveis de uma célula. Este valor é multiplicado pela afinidade da célula para determinar o número de clones.
-* **rate_hypermutation** (`float`, padrão=1.0): Taxa de clones mutados, usada como fator escalar.
-* **n_diversity_injection** (`int`, padrão=5): Número de novas células de memória aleatórias injetadas para manter a diversidade.
-* **selection_size** (`int`, padrão=5): Número de melhores anticorpos selecionados para clonagem.
-* **affinity_function** (`Optional[Callable[..., npt.NDArray]]`, padrão=None): Função objetivo usada para avaliar soluções candidatas.
-* **feature_type** (`FeatureTypeAll`, padrão='ranged-features'): Tipo de amostra do problema, podendo ser `'continuous-features'`, `'binary-features'`, `'ranged-features'` ou `'permutation-features'`.
-* **bounds** (`Optional[Dict]`, padrão=None): Dicionário definindo os limites de busca para problemas `'ranged-features'`. Pode ser um único intervalo ou uma lista de intervalos para cada dimensão.
-* **mode** (`Literal["min", "max"]`, padrão="min"): Especifica se o algoritmo minimiza ou maximiza a função de custo.
-* **seed** (`Optional[int]`, padrão=None): Semente para geração de números aleatórios.
-
----
-
-## Métodos Públicos
-
-### Função `optimize(...)`
-
-```python
-def optimize(
- self,
- max_iters: int = 50,
- n_iter_no_change=10,
- verbose: bool = True
-) -> List[Antibody]:
-```
-
-Este método executa o processo de otimização e retorna a população de anticorpos.
-
-**Parâmetros:**
-
-* **max_iters** (`int`, padrão=50): Número máximo de interações.
-* **n_iter_no_change** (`int`, padrão=10): Número máximo de iterações sem melhoria na melhor solução.
-* **verbose** (`bool`, padrão=True): Flag para habilitar ou desabilitar saída detalhada durante o processo de otimização.
-
-**Retorna:**
-
-* `List[Antibody]`: A população de anticorpos após a expansão clonal.
-
----
-
-#### Função `affinity_function(...)`
-
-```python
-def affinity_function(self, solution: npt.NDArray) -> np.float64:
-```
-
-Este método avalia a afinidade de uma solução candidata. Levanta `NotImplementedError` se nenhuma função de afinidade tiver sido fornecida à instância da classe.
-
-**Parâmetros:**
-
-* **solution** (`npt.NDArray`): Solução candidata a ser avaliada.
-
-**Retorna:**
-
-* `np.float64`: Valor de afinidade associado à solução.
-
----
-
-### Métodos Privados
-
-#### Função `_select_top_antibodies(...)`
-
-```python
-def _select_top_antibodies(self, n: int, antibodies: list[tuple]) -> list[tuple]:
-```
-
-Seleciona os `n` melhores anticorpos com base em suas pontuações de afinidade, de acordo com o `mode` (`'min'` ou `'max'`).
-
-**Parâmetros:**
-
-* **n** (`int`): Número de anticorpos a serem selecionados.
-* **antibodies** (`list[Antibody]`): Lista de tuplas, onde cada tupla representa um anticorpo e sua pontuação associada.
-
-**Retorna:**
-
-* `list[Antibody]`: Lista contendo os `n` anticorpos selecionados.
-
----
-
-#### Função `_init_population_antibodies(...)`
-
-```python
-def _init_population_antibodies(self) -> npt.NDArray:
-```
-
-Inicializa aleatoriamente a população inicial de anticorpos.
-
-**Retorna:**
-
-* `npt.NDArray`: Lista com os anticorpos inicializados.
-
----
-
-#### Função `_diversity_introduction(...)`
-
-```python
-def _diversity_introduction(self):
-```
-
-Introduz novos anticorpos aleatórios na população para manter a diversidade genética e ajudar a evitar convergência prematura.
-
-**Retorna:**
-
-* `npt.NDArray`: Array contendo os novos anticorpos aleatórios.
-
----
-
-#### Função `_clone_and_mutate(...)`
-
-```python
-def _clone_and_mutate(
- self,
- antibody: npt.NDArray,
- n_clone: int,
- rate_hypermutation: float
-) -> npt.NDArray:
-```
-
-Gera clones mutados a partir de um único anticorpo. A estratégia de mutação depende do `feature_type` especificado durante a inicialização (`'binary-features'`, `'continuous-features'`, `'ranged-features'` ou `'permutation-features'`).
-
-**Parâmetros:**
-
-* **antibody** (`npt.NDArray`): Vetor original do anticorpo a ser clonado e mutado.
-* **n_clone** (`int`): Número de clones a serem gerados.
-* **rate_hypermutation** (`float`): Taxa de hipermutação.
-
-**Retorna:**
-
-* `npt.NDArray`: Array contendo os clones mutados.
-
----
-
-#### Função `_clone_and_hypermutation(...)`
-
-```python
-def _clone_and_hypermutation(
- self,
- population: list[Antibody]
-) -> list[Antibody]:
-```
-
-Clona e aplica hipermutação a uma população de anticorpos. Retorna uma lista de todos os clones e suas afinidades em relação à função de custo.
-
-**Parâmetros:**
-
-* **population** (`list[Antibody]`): Lista de anticorpos a serem avaliados e clonados.
-
-**Retorna:**
-
-* `list[Antibody]`: Lista contendo os clones mutados.
-
----
-
-## Referências
-
-
-
-> 1. BROWNLEE, Jason. Clonal Selection Algorithm. Clever Algorithms: Nature-inspired Programming Recipes., 2011.
-> Available at:
diff --git a/docs/pt-br/classes/Clonal Selection Algorithms/README.md b/docs/pt-br/classes/Clonal Selection Algorithms/README.md
deleted file mode 100644
index 7ffd57e..0000000
--- a/docs/pt-br/classes/Clonal Selection Algorithms/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# Clonal Selection Algorithm
-
-Clonal Selection Algorithms são inspirados no processo biológico de proliferação de anticorpos após a detecção de um
-antígeno. Durante esse processo, os anticorpos gerados passam por mutações, com o objetivo de melhorar sua capacidade
-de reconhecimento do patógeno.
-
-## classes
-
-1. **[Artificial Immune Recognition System (AIRS)](AIRS.md)**
-
-> O objetivo da classe AIRS é realizar classificação utilizando metáforas de seleção e expansão clonal.
-> Esta implementação é inspirada no AIRS2, uma versão simplificada do algoritmo original, com adaptações que permitem
-> lidar tanto com conjuntos de dados contínuos quanto binários.
-
-2. **[Clonal Selection Algorithm (CLONALG)](Clonalg.md)**
-
-> Implementação do algoritmo de seleção clonal para otimização, adaptado
-> para minimização e maximização das funções de custo em binário,
-> Problemas contínuos e de permutação.
----
-
-### Referência
-
-> BRABAZON, Anthony; O'NEILL, Michael; MCGARRAGHY, Seán. *Natural Computing Algorithms*. Springer Berlin Heidelberg, 2015. DOI: 10.1007/978-3-662-43631-8. Disponível em: [http://dx.doi.org/10.1007/978-3-662-43631-8](http://dx.doi.org/10.1007/978-3-662-43631-8).
diff --git a/docs/pt-br/classes/Negative Selection/BNSA.md b/docs/pt-br/classes/Negative Selection/BNSA.md
deleted file mode 100644
index ccbdd2e..0000000
--- a/docs/pt-br/classes/Negative Selection/BNSA.md
+++ /dev/null
@@ -1,111 +0,0 @@
-
-# BNSA (Algoritmo de Seleção Negativa Binária)
-
-Esta classe estende a classe [**Base**](../../advanced-guides/base/classifier.md).
-
-## Construtor BNSA
-
-A classe ``BNSA`` tem a finalidade de classificação e identificação de anomalias através do método self e not self.
-
-**Attributes:**
-
-* **N** (``int``): Quantidade de detectores. Defaults to ``100``.
-* **aff_thresh** (``float``): A variável representa a porcentagem de não similaridade entre a célula T e as amostras próprias. O valor padrão é de 10% (0.1), enquanto que o valor de 1.0 representa 100% de não similaridade.
-* **max_discards** (``int``): Este parâmetro indica o número máximo de descartes de detectores em sequência, cujo objetivo é evitar um
-possível loop infinito caso seja definido um raio que não, seja possível gerar detectores do não-próprio. Defaults to ``100``.
-* **seed** (``int``): Semente para a geração randômica dos valores nos detectores. Defaults to ``None``.
-* no_label_sample_selection (``str``): Método para a seleção de rótulos para amostras designadas como não pertencentes por todos os detectores não pertencentes. **Tipos de métodos disponíveis:**
- * (``max_average_difference``): Seleciona a classe com a maior diferença média entre os detectores.
- * (``max_nearest_difference``): Seleciona a classe com a maior diferença entre o detector mais próximo e mais distante da amostra.
-
-**Outras variáveis iniciadas:**
-
-* **detectors** (``dict``): Esta variável armazena uma lista de detectores por classe.
-* **classes** (``npt.NDArray``): lista de classes de saída.
-
-### Método `fit(...)`
-
-A função ``fit(...)`` gera os detectores para os não próprios com relação às amostras:
-
-```python
-def fit(
- self,
- X: Union[npt.NDArray, list],
- y: Union[npt.NDArray, list],
- verbose: bool = True,
-) -> BNSA:
-```
-
-Nela é realizado o treinamento de acordo com ``X`` e ``y``, usando o método de seleção negativa(``NegativeSelect``).
-
-**Os parâmetros de entrada são:**
-
-* **X** (`Union[npt.NDArray, list]`): array com as características das amostras com **N** amostras (linhas) e **N** características (colunas), normalizados para valores entre [0, 1].
-* **y** (`Union[npt.NDArray, list]`): array com as classes de saídas disposto em **N** amostras que são relacionadas ao ``X``.
-* **verbose** (`bool`): boolean com valor default ``True``, determina se o feedback da geração dos detectores será imprimido.
-
-**Exceções:**
-
-* ``TypeError``: Se X ou y não forem ndarrays, ou tiverem formas incompatíveis.
-* ``ValueError``: X contém valores que não são compostos apenas por 0 e 1.
-* ``MaxDiscardsReachedError``: O número máximo de descartes do detector foi atingido durante a maturação. Verifique o valor do raio definido e considere reduzi-lo.
-
-*Retorna a instância da classe.*
-
----
-
-### Método `predict(...)`
-
-A função ``predict(...)`` realiza a previsão das classes utilizando os detectores gerados:
-
-```python
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): array com as características para a previsão, com **N** amostras (Linhas) e **N** colunas.
-
-**Exceções:**
-
-* `TypeError`: Se X não for um ndarray ou uma lista.
-* `FeatureDimensionMismatch`: Se o número de características em X não corresponder ao número esperado.
-* `ValueError`: X contém valores que não são compostos apenas por 0 e 1.
-* `ModelNotFittedError`: Se o modelo ainda não tiver sido ajustado e não possuir células de memória definidas, não conseguirá realizar predições.
-
-**Retorna:**
-
-* ``C``: Um array de previsão com as classes de saída para as características informadas.
-
----
-
-### Método `score(...)`
-
-A função "score(...)" calcula a precisão do modelo treinado por meio da realização de previsões e do cálculo da acurácia.
-
-```python
-def score(self, X: npt.NDArray, y: list) -> float:
-```
-
-retorna a acurácia, do tipo ``float``.
-
----
-
-## Métodos privados
-
-### Método `_assign_class_to_non_self_sample(...)`
-
-Essa função determina a classe de uma amostra quando todos os detectores a classificam como não-própria. A classificação é realizada utilizando os métodos ``max_average_difference`` ou ``max_nearest_difference``.
-
-```python
-def _assign_class_to_non_self_sample(self, line: npt.NDArray, c: list):
-```
-
-**Parâmetros:**
-
-* **line** (``npt.NDArray``): Amostra a ser classificada.
-* **c** (``list``): Lista de previsões para atualizar com a nova classificação.
-
-**Retorna:**
-
-``npt.NDArray``: A lista de previsões `c` atualizada com a classe atribuída à amostra.
diff --git a/docs/pt-br/classes/Negative Selection/README.md b/docs/pt-br/classes/Negative Selection/README.md
deleted file mode 100644
index 0efc743..0000000
--- a/docs/pt-br/classes/Negative Selection/README.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Seleção Negativa
-
-A **seleção negativa** é o processo em que o sistema imunológico faz a maturação das células-T conhecidas também por linfócitos-T, no qual tornam-as aptas na detecção dos não-próprios. Assim, o Algoritmo de seleção negativa (NSA), utilizam-se de hiperesferas simbolizando os detectores em um espaço de dados N-dimensional. [[1]](#1)
-
-## classes
-
-1. **[Binary version:](BNSA.md)**
-
-> O algoritmo binário adaptado para múltiplas classes neste projeto tem como base a versão proposta por [Forrest et al. (1994)](#2), originalmente desenvolvida para segurança computacional.
-
-2. **[Real-Valued version:](RNSA.md)**
-
->Este algoritmo possui duas versões diferentes: uma baseada na versão canônica [[1]](#1) e outra com detectores de raio variável [[3]](#3). Ambas estão adaptadas para trabalhar com múltiplas classes e possuem métodos para previsão de dados presentes na região não-self de todos os detectores e classes.
-
-## Referências
-
----
-
-##### 1
->
-> BRABAZON, Anthony; O'NEILL, Michael; MCGARRAGHY, Seán. Natural Computing Algorithms. [S. l.]: Springer Berlin Heidelberg, 2015. DOI 10.1007/978-3-662-43631-8. Disponível em: .
-
-##### 2
->
-> S. Forrest, A. S. Perelson, L. Allen and R. Cherukuri, "Self-nonself discrimination in a computer," Proceedings of 1994 IEEE Computer Society Symposium on Research in Security and Privacy, Oakland, CA, USA, 1994, pp. 202-212, doi: .
-
-##### 3
->
-> JI, Zhou; DASGUPTA, Dipankar. Real-Valued Negative Selection Algorithm with Variable-Sized Detectors. Genetic and Evolutionary Computation - GECCO 2004. [S. l.]: Springer Berlin Heidelberg, 2004. DOI 10.1007/978-3-540-24854-5_30. Disponível em: .
diff --git a/docs/pt-br/classes/Negative Selection/RNSA.md b/docs/pt-br/classes/Negative Selection/RNSA.md
deleted file mode 100644
index 769e325..0000000
--- a/docs/pt-br/classes/Negative Selection/RNSA.md
+++ /dev/null
@@ -1,217 +0,0 @@
-# RNSA (Algoritmo de Seleção Negativa de Valor Real)
-
-Esta classe estende a classe [**Base**](../../advanced-guides/base/classifier.md).
-
-## Construtor RNSA
-
-A classe ``RNSA`` tem a finalidade de classificação e identificação de anomalias através do método self e not self .
-
-**Attributes:**
-
-* **N** (``int``): Quantidade de detectores. Defaults to ``100``.
-* **r** (``float``): Raio do detector. Defaults to ``0.05``.
-* **k** (``int``): Quantidade de vizinhos próximos dos detectores gerados aleatoriamente para efetuar o cálculo da média da distância. Defaults to ``1``.
-* **metric** (``str``): Forma para se calcular a distância entre o detector e a amostra:
-
- * ``'euclidiana'`` ➜ O cálculo da distância dá-se pela expressão: √((X₁ - X₂)² + (Y₁ - Y₂)² + ... + (Yn - Yn)²).
- * ``'minkowski'`` ➜ O cálculo da distância dá-se pela expressão: (|X₁ - Y₁|p + |X₂ - Y₂|p + ... + |Xn - Yn|p) ¹/ₚ, Neste projeto ``p == 2``.
- * ``'manhattan'`` ➜ O cálculo da distância dá-se pela expressão: ( |X₁ - X₂| + |Y₁ - Y₂| + ... + |Yn - Yn₂|).
-
- Defaults to ``'euclidean'``.
-
-* **max_discards** (``int``): Este parâmetro indica o número máximo de descartes de detectores em sequência, que tem como objetivo evitar um
-possível loop infinito caso seja definido um raio que não seja possível gerar detectores do não-próprio.
-
-* **seed** (``int``): Semente para a geração randômica dos valores nos detectores. Defaults to ``None``.
-* **algorithm** (``str``), Definir a versão do algoritmo:
-
- * ``'default-NSA'``: Algoritmo padrão com raio fixo.
- * ``'V-detector'``: Este algoritmo é baseado no artigo "[Real-Valued Negative Selection Algorithm with Variable-Sized Detectors](https://doi.org/10.1007/978-3-540-24854-5_30)", de autoria de Ji, Z., Dasgupta, D. (2004), e utiliza um raio variável para a detecção de anomalias em espaços de características.
-
- Defaults to ``'default-NSA'``.
-
-* **r_s** (``float``): O valor de ``rₛ`` é o raio das amostras próprias da matriz ``X``.
-* ``**kwargs``:
- * *non_self_label* (``str``): Esta variável armazena o rótulo que será atribuído quando os dados possuírem
- apenas uma classe de saída, e a amostra for classificada como não pertencente a essa classe. Defaults to ``'non-self'``.
- * *cell_bounds* (``bool``): Se definido como ``True``, esta opção limita a geração dos detectores ao espaço do plano
- compreendido entre 0 e 1. Isso significa que qualquer detector cujo raio ultrapasse esse limite é descartado,
- e esta variável é usada exclusivamente no algoritmo ``V-detector``.
-
-**Outras variáveis iniciadas:**
-
-* **detectors** (``dict``): Esta variável armazena uma lista de detectores por classe.
-
-* **classes** (``npt.NDArray``): lista de classes de saída.
-
----
-
-## Método `fit(...)`
-
-A função ``fit(...)`` gera os detectores para os não próprios com relação às amostras:
-
-```python
-def fit(
- self,
- X: Union[npt.NDArray, list],
- y: Union[npt.NDArray, list],
- verbose: bool = True,
-) -> RNSA:
-```
-
-Nela é realizado o treinamento de acordo com ``X`` e ``y``, usando o método de seleção negativa(``NegativeSelect``).
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): array com as características das amostras com **N** amostras (linhas) e **N** características (colunas), normalizados para valores entre [0, 1].
-* **y** (`Union[npt.NDArray, list]`): array com as classes de saídas disposto em **N** amostras que são relacionadas ao ``X``.
-* **verbose** (`bool`): boolean com valor default ``True``, determina se o feedback da geração dos detectores será impresso.
-
-**Exceções:**
-
-* ``TypeError``: Se X ou y não forem ndarrays, ou tiverem formas incompatíveis.
-* ``MaxDiscardsReachedError``: O número máximo de descartes do detector foi atingido durante
-a maturação. Verifique o valor do raio definido e considere reduzi-lo.
-
-*Retorna a instância da classe.*
-
----
-
-### Método `predict(...)`
-
-A função ``predict(...)`` realiza a previsão das classes utilizando os detectores gerados:
-
-```python
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): array com as características para a previsão, com **N** amostras (Linhas) e **N** colunas.
-
-**Exceções:**
-
-* ``TypeError``: Se X não for um ndarray ou lista.
-* ``FeatureDimensionMismatch``: Se o número de características em X não corresponder ao número esperado.
-* ``MaxDiscardsReachedError``: O número máximo de descartes do detector foi atingido durante a maturação. Verifique o valor do raio definido e considere reduzi-lo.
-
-
-**Retorna:**
-
-* C (``npt.NDArray``): Um array de previsão com as classes de saída para as características informadas.
-
----
-
-### Método `score(...)`
-
-A função "score(...)" calcula a precisão do modelo treinado por meio da realização de previsões e do cálculo da acurácia.
-
-```python
-def score(self, X: npt.NDArray, y: list) -> float:
-```
-
-retorna a acurácia, do tipo ``float``.
-
----
-
-## Métodos privados
-
----
-
-### Método `_checks_valid_detector(...)`
-
-A função ``def _checks_valid_detector(...)`` verifica se o detector possui raio ``r`` válido para o não-próprio da classe:
-
-```python
-def _checks_valid_detector(
- self,
- x_class: npt.NDArray,
- vector_x: npt.NDArray
-) -> Union[bool, tuple[bool, float]]:
-```
-
-**Parâmetros:**
-
-* **X**(`npt.NDArray`): array com as características das amostras com **N** amostras (linhas) e **N** características (colunas), normalizados para valores entre [0, 1].
-* **vector_x**(`npt.NDArray`): Detector candidato gerado aleatoriamente.
-
-**Retorna:**
-
-* **Validity** (``bool``): Retorna se o detector é válido ou não.
-
----
-
-### Método `_compare_KnearestNeighbors_List(...)`
-
-A função ``def _compare_KnearestNeighbors_List(...)`` compara a distância dos k-vizinhos mais próximo, para isso se a distância da nova amostra for menor, substitui ``k-1`` e ordena em ordem crescente:
-
-```python
-def _compare_knearest_neighbors_list(self, knn: list, distance: float) -> None:
-```
-
-**Parâmetros**
-* **knn** (`list`): Lista das distâncias dos k vizinhos mais próximos.
-* **distance** (`float`): Distância a ser verificada.
-
-**Retorna:** uma lista com as distâncias dos k-vizinhos mais próximo.
-
----
-
-### Método `_compare_sample_to_detectors(...)`
-
-Função para comparar uma amostra com os detectores, verificando se a amostra é própria.
-
-Nesta função, quando possui ambiguidade de classes, retorna a classe que possuir a média de distância maior entre os detectores.
-
-```python
-def _compare_sample_to_detectors(self, line: npt.NDArray) -> Optional[str]:
-```
-
-**Parâmetros:**
-
-* **line** (`npt.NDArray`): vetor com N-características
-
-**Retorna:**
-
-A classe prevista com os detectores ou None se a amostra não se qualificar a nenhuma classe.
-
----
-
-### Método `_detector_is_valid_to_Vdetector(...)`
-
-Verifique se a distância entre o detector e as amostras, descontando o raio das amostras, é maior do que o raio mínimo.
-
-```python
-def _detector_is_valid_to_vdetector(
- self,
- distance: float,
- vector_x: npt.NDArray
-) -> Union[bool, tuple[bool, float]]:
-```
-
-**Parâmetros:**
-
-* **distance** (``float``): distância mínima calculada entre todas as amostras.
-* **vector_x** (``npt.NDArray``): vetor x candidato do detector gerado aleatoriamente, com valores entre 0 e 1.
-
-**Retorna:**
-
-* ``False``: caso o raio calculado seja menor do que a distância mínima ou ultrapasse a borda do espaço, caso essa opção esteja habilitada.
-* ``True`` e a distância menos o raio das amostras, caso o raio seja válido.
-
----
-
-### Método `_distance(...)`
-
-A função ``def _distance(...)`` calcula a distância entre dois pontos utilizando a técnica definida em ``metric``, no qual são: ``'euclidiana', 'minkowski', ou 'manhattan'``
-
-```python
-def _distance(self, u: npt.NDArray, v: npt.NDArray):
-```
-**Parameters**
-* **u** (`npt.NDArray`): Coordenadas do primeiro ponto.
-* **v** (`npt.NDArray`): Coordenadas do segundo ponto.
-
-**Retorna:**
-
-Retorna a distância (``float``) entre os dois pontos.
diff --git a/docs/pt-br/classes/Network Theory Algorithms/AiNet.md b/docs/pt-br/classes/Network Theory Algorithms/AiNet.md
deleted file mode 100644
index cc51379..0000000
--- a/docs/pt-br/classes/Network Theory Algorithms/AiNet.md
+++ /dev/null
@@ -1,271 +0,0 @@
-# AiNet (Artificial Immune Network)
-
-Esta classe estende a classe [**Base**](../../advanced-guides/base/clusterer.md).
-
-## Construtor AiNet
-
-A classe `AiNet` implementa o algoritmo de Rede Imune Artificial para **compressão** e **clustering**.
-Ela utiliza princípios da teoria de redes imunes, seleção clonal e maturação por afinidade para comprimir conjuntos de dados e encontrar clusters.
-
-Para clustering, pode opcionalmente utilizar uma **Árvore Geradora Mínima (MST)** para separar nós distantes em grupos.
-
-**Atributos:**
-
-* **N** (`int`): Número de células de memória (anticorpos) na população. Padrão: 50.
-* **n_clone** (`int`): Número de clones gerados por célula de memória selecionada. Padrão: 10.
-* **top_clonal_memory_size** (`Optional[int]`): Número de anticorpos de maior afinidade selecionados para clonagem. Padrão: 5.
-* **n_diversity_injection** (`int`): Número de novos anticorpos aleatórios injetados para manter a diversidade. Padrão: 5.
-* **affinity_threshold** (`float`): Limite para seleção/supressão de células. Padrão: 0.5.
-* **suppression_threshold** (`float`): Limite para remoção de células de memória semelhantes. Padrão: 0.5
-* **mst_inconsistency_factor** (`float`): Fator para determinar arestas inconsistentes na MST. Padrão: 2.0.
-* **max_iterations** (`int`): Número máximo de iterações de treinamento. Padrão: 10.
-* **k** (`int`): Número de vizinhos mais próximos usados para predição de rótulos. Padrão: 3.
-* **metric** (Literal["manhattan", "minkowski", "euclidean"]): Forma de calcular a distância entre o detector e a amostra:
-
- * `'euclidean'` ➜ Distância dada pela expressão:
- √( (x₁ - x₂)² + (y₁ - y₂)² + ... + (yn - yn)²).
- * `'minkowski'` ➜ Distância dada pela expressão:
- ( |X₁ - Y₁|ᵖ + |X₂ - Y₂|ᵖ + ... + |Xn - Yn|ᵖ )^(¹/ₚ).
- * `'manhattan'` ➜ Distância dada pela expressão:
- ( |x₁ - x₂| + |y₁ - y₂| + ... + |yn - yn|).
- Padrão: "euclidean".
-
-* **seed** (`Optional[int]`): Semente para geração de números aleatórios. Padrão: None.
-* **use_mst_clustering** (`bool`): Define se o clustering baseado em MST deve ser utilizado. Padrão: True.
-* **kwargs**:
-
- * **p** (`float`): Parâmetro para distância de Minkowski. Padrão: 2.
-
-**Outras variáveis inicializadas:**
-
-* **_population_antibodies** (``Optional[npt.NDArray]``): Conjunto atual de anticorpos.
-* **_memory_network** (``Dict[int, List[Cell]]``): Dicionário que mapeia clusters para anticorpos.
-* **_mst_structure** (``Optional[npt.NDArray]``): Estrutura de adjacência da MST.
-* **_mst_mean_distance** (``Optional[float]``): Média das distâncias das arestas da MST.
-* **_mst_std_distance** (``Optional[float]``): Desvio padrão das distâncias das arestas da MST.
-* **labels** (``Optional[npt.NDArray]``): Lista de rótulos dos clusters.
-
----
-
-## Métodos Públicos
-
-### Método `fit(...)`
-
-Treina o modelo AiNet com os dados de entrada:
-
-```python
-def fit(self, X: Union[npt.NDArray, list], verbose: bool = True) -> AiNet:
-```
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): Matriz com amostras (linhas) e atributos (colunas).
-* **verbose** (`bool`): Booleano, padrão True, habilita feedback de progresso.
-
-**Exceções**
-
-* `TypeError`: Se X não for um ndarray ou uma lista.
-* `UnsupportedTypeError`: Se o tipo de dados do vetor não for suportado.
-
-*Retorna a instância da classe.*
-
----
-
-### Método `predict(...)`
-
-Prediz os rótulos dos clusters para novas amostras:
-
-```python
-def predict(self, X: Union[npt.NDArray, list]) -> npt.NDArray:
-```
-
-**Parâmetros:**
-
-* **X** (`Union[npt.NDArray, list]`): Matriz de atributos de entrada.
-
-**Exceções**
-
-* `TypeError`: Se X não for um ndarray ou uma lista.
-* `ValueError`: X contém valores que não são compostos apenas por 0 e 1.
-* `FeatureDimensionMismatch`: Se o número de características em X não corresponder ao número esperado.
-* `ModelNotFittedError`: Se o modelo ainda não tiver sido ajustado e não possuir células de memória definidas, não conseguirá realizar predições.
-
-**Retorna:**
-
-* **Predictions**: Matriz de rótulos de clusters, ou None caso o clustering esteja desabilitado.
-
----
-
-### Método `update_clusters(...)`
-
-Particiona os clusters utilizando a MST:
-
-```python
-def update_clusters(self, mst_inconsistency_factor: Optional[float] = None):
-```
-
-**Parâmetros:**
-
-* **mst_inconsistency_factor** (`Optional[float]`): Valor opcional (float) para sobrescrever o fator de inconsistência da MST.
-
-**Atualiza:**
-
-* **_memory_network**: Dicionário de rótulos de clusters para vetores de anticorpos.
-* **labels**: Lista de rótulos de clusters.
-
----
-
-## Métodos Privados
-
-### Método `_init_population_antibodies(...)`
-
-Inicializa a população de anticorpos aleatoriamente.
-
-```python
-def _init_population_antibodies(self) -> npt.NDArray:
-```
-
-**Retorna:** Anticorpos inicializados (`npt.NDArray`).
-
----
-
-### Método` _select_and_clone_population(...)`
-
-Seleciona os melhores anticorpos e gera clones mutados:
-
-```python
-def _select_and_clone_population(self, antigen: npt.NDArray, population: npt.NDArray) -> list:
-```
-
-**Parâmetros:**
-
-* **antigen** (`npt.NDArray`): Vetor representando o antígeno para o qual as afinidades serão calculadas.
-* **population** (`npt.NDArray`): Matriz de anticorpos a serem avaliados e clonados.
-
-**Retorna:** Lista de clones mutados.
-
----
-
-### Método `_clonal_suppression(...)`
-
-Suprime clones redundantes com base em limiares:
-
-```python
-def _clonal_suppression(self, antigen: npt.NDArray, clones: list):
-```
-
-**Parâmetros:**
-
-* **antigen** (`npt.NDArray`): Vetor representando o antígeno.
-* **clones** (`list`): Lista de clones candidatos a serem suprimidos.
-
-**Retorna:** Lista de clones não redundantes e de alta afinidade.
-
----
-
-### Método `_memory_suppression(...)`
-
-Remove anticorpos redundantes da memória:
-
-```python
-def _memory_suppression(self, pool_memory: list) -> list:
-```
-
-**Parâmetros:**
-
-* **pool_memory** (`list`): Lista de anticorpos atualmente na memória.
-
-**Retorna:**
-
-Memória filtrada (`list`).
-
----
-
-### Método `_diversity_introduction(...)`
-
-Introduz novos anticorpos para manter a diversidade.
-
-```python
-def _diversity_introduction(self) -> npt.NDArray:
-```
-
-**Retorna:** Conjunto de novos anticorpos (`npt.NDArray`).
-
----
-
-### Método `_affinity(...)`
-
-Calcula o estímulo entre dois vetores:
-
-```python
-def _affinity(self, u: npt.NDArray, v: npt.NDArray) -> float:
-```
-
-**Parâmetros:**
-
-* **u** (`npt.NDArray`): Vetor representando o primeiro ponto.
-* **v** (`npt.NDArray`): Vetor representando o segundo ponto.
-
-**Retorna:** Valor de afinidade (`float`) no intervalo [0,1].
-
----
-
-### Método `_calculate_affinities(...)`
-
-Calcula a matriz de afinidades entre um vetor de referência e vetores-alvo:
-
-```python
-def _calculate_affinities(self, u: npt.NDArray, v: npt.NDArray) -> npt.NDArray:
-```
-
-**Parâmetros:**
-
-* **u** (`npt.NDArray`): Vetor de referência (`npt.NDArray`) de formato `(n_features,)`.
-* **v** (`npt.NDArray`): Vetores-alvo (`npt.NDArray`) de formato `(n_samples, n_features)`.
-
-**Retorna:** Vetor de afinidades (`npt.NDArray`) com formato `(n_samples,)`.
-
----
-
-### Método `_clone_and_mutate(...)`
-
-Gera clones mutados:
-
-```python
-def _clone_and_mutate(self, antibody: npt.NDArray, n_clone: int) -> npt.NDArray:
-```
-
-**Parâmetros:**
-
-* **antibody** (`npt.NDArray`): Vetor de anticorpo original a ser clonado e mutado.
-* **n_clone** (`int`): Número de clones a serem gerados.
-
-**Retorna:** Matriz de clones mutados (`npt.NDArray`) de formato `(n_clone, len(antibody))`.
-
----
-
-### Método `_build_mst(...)`
-
-Constrói a MST e armazena estatísticas:
-
-```python
-def _build_mst(self):
-```
-
-**Exceções:** ValueError se a população de anticorpos estiver vazia.
-
-**Atualiza variáveis internas:**
-
-* **_mst_structure**: Estrutura de adjacência da MST.
-* **_mst_mean_distance**: Distância média das arestas.
-* **_mst_std_distance**: Desvio padrão das distâncias das arestas da MST.
-
----
-
-## Referências
-
-> 1. De Castro, Leandro & José, Fernando & von Zuben, Antonio Augusto. (2001). aiNet: An Artificial Immune Network for Data Analysis.
-> 2. Disponível em: [https://www.researchgate.net/publication/228378350_aiNet_An_Artificial_Immune_Network_for_Data_Analysis](https://www.researchgate.net/publication/228378350_aiNet_An_Artificial_Immune_Network_for_Data_Analysis)
-
-> 2. SciPy Documentation. *Minimum Spanning Tree*.
-> Disponível em: [https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csgraph.minimum_spanning_tree](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csgraph.minimum_spanning_tree)
diff --git a/docs/pt-br/classes/Network Theory Algorithms/README.md b/docs/pt-br/classes/Network Theory Algorithms/README.md
deleted file mode 100644
index 4faa031..0000000
--- a/docs/pt-br/classes/Network Theory Algorithms/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# Immune Network Theory
-
-Esta técnica foi introduzida por **Niels Jerne (1974)** e modela o sistema imunológico como uma rede dinâmica,
-na qual as células e moléculas, capazes de reconhecer umas às outras.
-
-## Classes
-
-1. **[AiNet](AiNet.md)**
-
-> Rede Imune Artificial para tarefas de clustering e compressão não-supervisionada.
-
----
-
-## Referências
-
-> BRABAZON, Anthony; O'NEILL, Michael; MCGARRAGHY, Seán. *Natural Computing Algorithms*. Springer Berlin Heidelberg, 2015. DOI: 10.1007/978-3-662-43631-8. Disponível em: [http://dx.doi.org/10.1007/978-3-662-43631-8](http://dx.doi.org/10.1007/978-3-662-43631-8).
diff --git a/docs/pt-br/faq.md b/docs/pt-br/faq.md
new file mode 100644
index 0000000..62dfde6
--- /dev/null
+++ b/docs/pt-br/faq.md
@@ -0,0 +1,142 @@
+---
+id: faq
+sidebar_position: 6
+sidebar_label: FAQ
+keywords:
+ - FAQ
+ - Perguntas Frequentes
+ - Dúvidas
+ - Ajuda
+---
+
+# Perguntas Frequentes
+
+Soluções rápidas para possíveis dúvidas sobre o aisp.
+
+## Uso geral
+
+### Qual algoritmo devo escolher?
+
+Depende do tipo de problema:
+
+- **Detecção de anomalias**: Use `RNSA` ou `BNSA`.
+ - RNSA para problemas com dados contínuos.
+ - BNSA para problemas com dados binários.
+- **Classificação**: Use `AIRS`, `RNSA` ou `BNSA`.
+ - O `RNSA` e `BNSA`, foram implementados para serem aplicados a classificação multiclasse.
+ - O `AIRS` é mais robusto para dados com ruídos.
+- **Otimização**: Use `Clonalg`.
+ - A implementação pode ser aplicada à otimização (min/max) de funções objetivas.
+- **Clustering/Agrupamento**: Use `AiNet`.
+ - Separa grupos de dados automaticamente.
+ - Não requer numero de grupos predefinidos.
+
+---
+
+### Como normalizar meus dados para utilizar o algoritmo `RNSA`?
+
+O RNSA trabalha exclusivamente com dados normalizados no intervalo entre (0.0, 1.0). Portanto, antes de aplicá-lo,
+é necessário normalizar os dados se não estiver neste intervalo. Uma forma simples é fazer utilizando as
+ferramentas de normalização do **scikit-learn**, como o
+[`MinMaxScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html).
+
+#### Exemplo
+
+Neste exemplo, `X` representa os dados de entrada não normalizados.
+
+```python
+from sklearn.preprocessing import MinMaxScaler
+
+scaler = MinMaxScaler()
+
+x_norm = scaler.fit_transform(X)
+
+# Treinando o modelo com os dados normalizados.
+rnsa = RNSA(N=100, r=0.1)
+rnsa.fit(x_norm, y)
+```
+
+---
+
+## Configuração de Parâmetros
+
+### Como escolher o numero de detectores (`N`) no `RNSA` ou `BNSA`?
+
+O número de detectores afeta diretamente a performance:
+
+- Um número reduzido de detectores pode não cobrir adequadamente o espaço não-próprio.
+- Um número muito alto de detectores pode aumentar o tempo de treinamento e pode causar overfitting.
+
+**Recomendações**:
+
+- Teste diferentes valores para o número de detectores até encontrar um equilíbrio adequado entre tempo de treinamento
+ e desempenho do modelo.
+- Utilize validação cruzada para identificar o valor que apresenta os melhores resultados de forma consistente.
+
+---
+
+### Qual raio (`r` ou `aff_thresh`) devo utilizar no `BNSA` ou `RNSA`?
+
+O raio dos detectores depende da distribuição dos dados:
+
+- Raio muito pequeno, podem não detectar anomalias.
+- Raio muito grandes, podem sobrepor o self e nunca gerar detectores validos.
+
+---
+
+### O que é o parâmetro `r_s` no `RNSA`?
+
+O `r_s` é o raio da amostra self. Ele define uma região ao redor de cada amostra de treinamento.
+
+---
+
+### Clonalg: Como definir a função objetivo?
+
+A função objetiva deve seguir o padrão da
+[classe base](https://github.com/AIS-Package/aisp/blob/main/aisp/base/core/_optimizer.py#L140).
+Ela deve receber uma solução como entrada e retornar um valor do custo (ou afinidade).
+
+```python
+def affinity_function(self, solution: Any) -> float:
+ pass
+```
+
+Existem duas formas de definir a função objetivo no Clonalg.
+
+```python
+def sphere(solution):
+ return np.sum(solution ** 2)
+```
+
+1. Definindo a função diretamente no construtor da classe
+
+```python
+clonalg = Clonalg(
+ problem_size=2,
+ affinity_function=sphere
+)
+```
+
+2. Utilizando o registrador de funções
+
+```python
+clonalg = Clonalg(
+ problem_size=2,
+)
+
+clonalg.register("affinity_function", sphere)
+```
+
+## Informações adicionais
+
+### Onde encontrar mais exemplos?
+
+- [Exemplos em Jupyter Notebooks](../../examples/pt-br).
+
+### Como contribuir para o projeto?
+
+Veja o [Guia de Contribuição](../../CONTRIBUTING.md) no GitHub.
+
+### Ainda tem dúvidas?
+
+- Abra uma [**Issue no GitHub**](https://github.com/AIS-Package/aisp/issues)
diff --git a/docs/pt-br/index.md b/docs/pt-br/index.md
deleted file mode 100644
index a8cddb4..0000000
--- a/docs/pt-br/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
-## **ÍNDICE**
-
----
-
-### Classe do módulo:
-
-> 1. [**Seleção negativa**](classes/Negative%20Selection/README.md)
-> 2. **Teoria do Perigo**
-> 3. [**Algoritmo de Seleção Clonal.**](classes/Clonal%20Selection%20Algorithms/README.md)
-> 4. [**Teoria da Rede Imune**](classes/Network%20Theory%20Algorithms/README.md)
\ No newline at end of file