.
-
----
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/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..2f529aa
--- /dev/null
+++ b/docs/pt-br/api/base/base-classifier.md
@@ -0,0 +1,128 @@
+---
+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]` | - | Dados de entrada utilizados para o treinamento. |
+| `y` | `Union[npt.NDArray, list]` | - | Rótulos correspondentes as características dos dados de entrada. |
+| `verbose` | `bool` | `True` | Indica se as mensagens de progresso do treinamento deve ser exibido. |
+
+**Returns**
+
+``BaseClassifier`` - 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]` | - | Dados de entrada que serão previstos pelo modelo. |
+
+**Returns**
+
+`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**
+
+`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..ce84a13
--- /dev/null
+++ b/docs/pt-br/api/base/base-clusterer.md
@@ -0,0 +1,116 @@
+---
+id: base-clusterer
+sidebar_label: BaseClusterer
+keywords:
+ - base
+ - clusterer
+ - clusterer interface
+ - cluster labels
+ - fit
+ - predict
+ - fit_predict
+tags:
+ - clusterer
+ - clustering
+---
+
+# 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]` | - | Dados de entrada utilizados para o treinamento. |
+| `verbose` | `bool` | `True` | Indica se as mensagens de progresso do treinamento deve ser exibido. |
+
+**Returns**
+
+``BaseClassifier`` - 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]` | - | Dados de entrada para os quais as previsões serão geradas. |
+
+**Returns**
+
+`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]` | - | Conjunto de características com dimensões (n_samples, n_features). |
+| `verbose` | `bool` | `True` | Indica se as mensagens de progresso do treinamento deve ser exibido. |
+
+**Returns**
+
+`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..ac1ebc5
--- /dev/null
+++ b/docs/pt-br/api/base/base-optimizer.md
@@ -0,0 +1,157 @@
+---
+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**
+
+``BaseClassifier`` - Retorna a instância 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**
+
+`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**
+
+`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**
+
+`TypeError` - Lançado quando não é uma função valida.
+
+`AttributeError` - Lançado quando o `alias` esta protegido e não pode ser modificado, ou se 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..1f8a027
--- /dev/null
+++ b/docs/pt-br/api/base/immune/cell/b-cell.md
@@ -0,0 +1,61 @@
+---
+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**
+
+`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..9665313
--- /dev/null
+++ b/docs/pt-br/api/base/immune/mutation.md
@@ -0,0 +1,138 @@
+---
+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**
+
+`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**
+
+`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**
+
+`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**
+
+`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..9e7c140
--- /dev/null
+++ b/docs/pt-br/api/base/immune/populations.md
@@ -0,0 +1,52 @@
+---
+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. |
+
+**Exceções**
+
+`ValueError` - Lançado caso o número de características seja menor ou igual a zero.
+
+**Returns**
+
+`npt.NDArray` - Array de dimensão (n_samples, n_features) contendo os anticorpos gerados.
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/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
diff --git a/pyproject.toml b/pyproject.toml
index a46c054..81fb952 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
[project]
name = "aisp"
-version = "0.5.3"
+version = "0.5.4"
authors = [
{ name="João Paulo da Silva Barros", email="jpsilvabarr@gmail.com" },
]