mlquantify 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

mlquantify/mixture/_utils.py

@@ -6,7 +6,7 @@ import numpy as np
 # =====================================================
 
 def getHist(scores, nbins):
-    """
+    r"""
     Calculate histogram-like bin probabilities for a given set of scores.
 
     This function divides the score range into equal bins and computes the proportion 
@@ -42,7 +42,7 @@ def getHist(scores, nbins):
 
 
 def ternary_search(left: float, right: float, func, tol: float = 1e-4) -> float:
-    """
+    r"""
     Ternary search to find the minimum of a unimodal function in [left, right].
 
     Parameters
@@ -53,8 +53,8 @@ def ternary_search(left: float, right: float, func, tol: float = 1e-4) -> float:
         Right bound.
     func : callable
         Function to minimize.
-    tol : float
-        Tolerance for termination.
+    tol : float, optional
+        Tolerance for termination. Default is 1e-4.
 
     Returns
     -------
@@ -73,10 +73,23 @@ def ternary_search(left: float, right: float, func, tol: float = 1e-4) -> float:
 
 
 def topsoe(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Topsoe distance between two probability distributions.
 
-    D_T(p, q) = sum( p*log(2p/(p+q)) + q*log(2q/(p+q)) )
+    .. math::
+        D_T(p, q) = \sum \left( p \log \frac{2p}{p + q} + q \log \frac{2q}{p + q} \right)
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First probability distribution.
+    q : np.ndarray
+        Second probability distribution.
+
+    Returns
+    -------
+    float
+        The Topsoe distance.
     """
     p = np.maximum(p, 1e-20)
     q = np.maximum(q, 1e-20)
@@ -84,10 +97,23 @@ def topsoe(p: np.ndarray, q: np.ndarray) -> float:
 
 
 def probsymm(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Probabilistic Symmetric distance.
 
-    D_PS(p, q) = sum( (p - q) * log(p / q) )
+    .. math::
+        D_{PS}(p, q) = \sum (p - q) \log \frac{p}{q}
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First probability distribution.
+    q : np.ndarray
+        Second probability distribution.
+
+    Returns
+    -------
+    float
+        The Probabilistic Symmetric distance.
     """
     p = np.maximum(p, 1e-20)
     q = np.maximum(q, 1e-20)
@@ -95,10 +121,23 @@ def probsymm(p: np.ndarray, q: np.ndarray) -> float:
 
 
 def hellinger(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Hellinger distance between two probability distributions.
 
-    H(p, q) = (1/sqrt(2)) * sqrt( sum( (sqrt(p) - sqrt(q))^2 ) )
+    .. math::
+        H(p, q) = \frac{1}{\sqrt{2}} \sqrt{\sum \left( \sqrt{p} - \sqrt{q} \right)^2}
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First probability distribution.
+    q : np.ndarray
+        Second probability distribution.
+
+    Returns
+    -------
+    float
+        The Hellinger distance.
     """
     p = np.maximum(p, 1e-20)
     q = np.maximum(q, 1e-20)
@@ -106,7 +145,19 @@ def hellinger(p: np.ndarray, q: np.ndarray) -> float:
 
 
 def sqEuclidean(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Squared Euclidean distance between two vectors.
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First vector.
+    q : np.ndarray
+        Second vector.
+
+    Returns
+    -------
+    float
+        The squared Euclidean distance.
     """
     return np.sum((p - q) ** 2)

mlquantify/model_selection/_protocol.py

@@ -15,7 +15,7 @@ import numpy as np
 
     
 class BaseProtocol(ProtocolMixin, BaseQuantifier):
-    """Base class for evaluation protocols.
+    r"""Base class for evaluation protocols.
     
     Parameters
     ----------
@@ -76,7 +76,7 @@ class BaseProtocol(ProtocolMixin, BaseQuantifier):
                  
 
     def split(self, X: np.ndarray, y: np.ndarray):
-        """
+        r"""
         Split the data into samples for evaluation.
 
         Parameters
@@ -117,7 +117,7 @@ class BaseProtocol(ProtocolMixin, BaseQuantifier):
 
 
 class APP(BaseProtocol):
-    """
+    r"""
     Artificial Prevalence Protocol (APP) for exhaustive prevalent batch evaluation.
     
     Generates batches with artificially imposed prevalences across all possible 
@@ -185,7 +185,7 @@ class APP(BaseProtocol):
             
 
 class NPP(BaseProtocol):
-    """
+    r"""
     Natural Prevalence Protocol (NPP) that samples data without imposing prevalence constraints.
     
     This protocol simply samples batches randomly with replacement, 
@@ -230,7 +230,7 @@ class NPP(BaseProtocol):
             
 
 class UPP(BaseProtocol):
-    """
+    r"""
     Uniform Prevalence Protocol (UPP) for uniform sampling of artificial prevalences.
     
     Similar to APP, but uses uniform prevalence distribution generation
@@ -310,7 +310,7 @@ class UPP(BaseProtocol):
 
 
 class PPP(BaseProtocol):
-    """
+    r"""
     Personalized Prevalence Protocol (PPP) for targeted prevalence batch generation.
     
     Generates batches with user-specified prevalence distributions, allowing for

mlquantify/model_selection/_search.py

@@ -18,7 +18,7 @@ from mlquantify.model_selection import (
 )
 
 class GridSearchQ(MetaquantifierMixin, BaseQuantifier):
-    """
+    r"""
     Grid Search for Quantifiers with evaluation protocols.
 
     This class automates the hyperparameter search over a grid of parameter

mlquantify/neighbors/_base.py

@@ -13,94 +13,64 @@ from mlquantify.utils._validation import validate_prevalences
 EPS = 1e-12
 
 class BaseKDE(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
-    r"""
-    Base class for KDEy quantification methods.
-    
-    KDEy methods model the class-conditional densities of posterior probabilities
-    using Kernel Density Estimation (KDE) in the probability simplex space.
-    Given a probabilistic classifier's posterior outputs, each class distribution
-    is approximated as a smooth density function via KDE. Class prevalences in
-    the test set are estimated as the mixture weights of these densities that best 
-    explain the test posterior distribution.
-    
-    Formally, KDEy approximates the test posterior distribution as:
+    r"""Base class for KDEy quantification methods.
 
-    \[
-    p_{test}(x) \approx \sum_{k=1}^K \alpha_k p_k(x),
-    \]
+    KDEy models the class-conditional densities of posterior probabilities using Kernel Density Estimation (KDE)
+    on the probability simplex. Given posterior outputs from a probabilistic classifier, each class distribution
+    is approximated as a smooth KDE. Test set class prevalences correspond to mixture weights that best explain 
+    the overall test posterior distribution.
 
-    where \( p_k(x) \) is the KDE of the posterior scores of class \( k \) on training data,
-    and \( \alpha_k \) are the unknown class prevalences to be estimated under:
+    Mathematically, the test posterior distribution is approximated as:
 
-    \[
-    \alpha_k \geq 0, \quad \sum_{k=1}^K \alpha_k = 1.
-    \]
-    
-    The quantification task is then to find the vector \( \boldsymbol{\alpha} = (\alpha_1,\dots,\alpha_K) \)
-    minimizing an objective function defined on the mixture density and the test posteriors,
-    subject to the simplex constraints on \( \boldsymbol{\alpha} \).
+    .. math::
+
+        p_{\mathrm{test}}(x) \approx \sum_{k=1}^K \alpha_k p_k(x),
+
+    where \(p_k(x)\) is the KDE of class \(k\) posteriors from training data, and \(\alpha_k\) are the unknown class 
+    prevalences subject to:
+
+    .. math::
+
+        \alpha_k \geq 0, \quad \sum_{k=1}^K \alpha_k = 1.
+
+    The quantification minimizes an objective \(\mathcal{L}\) over \(\boldsymbol{\alpha} = (\alpha_1, \dots, \alpha_K)\) in the simplex:
+
+    .. math::
+
+        \min_{\boldsymbol{\alpha} \in \Delta^{K-1}} \mathcal{L} \left( \sum_{k=1}^K \alpha_k p_k(x), \hat{p}(x) \right),
+
+    where \(\hat{p}(x)\) is the test posterior distribution (empirical KDE or direct predictions).
+
+    This problem is typically solved using numerical constrained optimization methods.
 
     Attributes
     ----------
     learner : estimator
-        The underlying probabilistic classifier yielding posterior predictions.
+        Probabilistic classifier generating posterior predictions.
     bandwidth : float
-        Bandwidth (smoothing parameter) for the KDE models.
+        KDE bandwidth (smoothing parameter).
     kernel : str
-        Kernel type used in KDE (e.g., 'gaussian').
+        KDE kernel type (e.g., 'gaussian').
     _precomputed : bool
-        Indicates whether KDE models have been fitted on training data.
+        Indicates if KDE models have been fitted.
     best_distance : float or None
-        Stores the best value of the objective (distance or loss) achieved.
-
-    Methods
-    -------
-    fit(X, y, learner_fitted=False)
-        Fits KDE models for each class using posterior predictions of the learner.
-    predict(X)
-        Aggregates learner’s posterior predictions on X to estimate class prevalences.
-    aggregate(predictions, train_predictions, train_y_values)
-        Core estimation method that validates inputs, ensures KDE precomputation,
-        and calls `_solve_prevalences` implemented by subclasses.
-    _fit_kde_models(train_predictions, train_y_values)
-        Fits KDE model per class on training data posteriors.
-    _solve_prevalences(predictions)
-        Abstract method to estimate prevalence vector \( \boldsymbol{\alpha} \) for given posteriors.
-        Must be implemented by subclasses.
+        Best objective value found during estimation.
 
     Examples
     --------
-    To implement a new KDEy quantifier, subclass BaseKDE and implement the method
-    `_solve_prevalences`, which receives posterior predictions and returns a tuple
-
-    (estimated prevalences \(\boldsymbol{\alpha}\), objective value).
+    Subclasses should implement `_solve_prevalences` method returning estimated prevalences and objective value:
 
     >>> class KDEyExample(BaseKDE):
     ...     def _solve_prevalences(self, predictions):
-    ...         # Example: simple uniform prevalences, replace with actual optimization
     ...         n_classes = len(self._class_kdes)
     ...         alpha = np.ones(n_classes) / n_classes
-    ...         obj_val = 0.0  # Replace with actual objective computation
+    ...         obj_val = 0.0  # Placeholder, replace with actual objective
     ...         return alpha, obj_val
 
-    Mathematical formulation for prevalence estimation typically involves optimizing:
-
-    \[
-    \min_{\boldsymbol{\alpha} \in \Delta^{K-1}} \mathcal{L} \bigg( \sum_{k=1}^K \alpha_k p_k(x), \hat{p}(x) \bigg),
-    \]
-
-    where \(\hat{p}(x)\) is the test posterior distribution (empirical KDE or direct predictions),
-    \(\Delta^{K-1}\) is the probability simplex defined by the constraints on \(\boldsymbol{\alpha}\),
-    and \(\mathcal{L}\) is an appropriate divergence or loss function, e.g., negative log-likelihood,
-    Hellinger distance, or Cauchy–Schwarz divergence.
-
-    This optimization is typically solved numerically with constrained methods such as
-    sequential quadratic programming or projected gradient descent.
-
     References
     ----------
-    [1] Moreo, A., et al. (2023). Kernel Density Quantification methods and applications.
-        In *Learning to Quantify*, Springer.
+    .. [1] Moreo, A., et al. (2023). Kernel Density Quantification methods and applications.
+    In *Learning to Quantify*, Springer.
     """
 
     _parameter_constraints = {

mlquantify/neighbors/_classes.py

@@ -10,7 +10,7 @@ from mlquantify.utils._validation import validate_prevalences
 
 
 class PWK(BaseQuantifier):
-    """
+    r"""
     Probabilistic Weighted k-Nearest Neighbor (PWK) Quantifier.
 
     This quantifier leverages the PWKCLF classifier to perform quantification by estimating 
@@ -47,15 +47,6 @@ class PWK(BaseQuantifier):
     learner : PWKCLF
         Underlying probabilistic weighted k-NN classifier.
 
-    Methods
-    -------
-    fit(X, y)
-        Fits the quantifier by training the internal PWKCLF and wrapping it with 
-        Classify & Count quantification.
-    predict(X)
-        Predicts class prevalences for input data using the trained model.
-    classify(X)
-        Returns label predictions by applying the trained PWKCLF classifier.
 
     Examples
     --------

mlquantify/neighbors/_classification.py

@@ -5,8 +5,7 @@ from sklearn.neighbors import NearestNeighbors
 
 
 class PWKCLF:
-    """
-    Probabilistic Weighted k-Nearest Neighbor Classifier (PWKCLF).
+    r"""Probabilistic Weighted k-Nearest Neighbor Classifier (PWKCLF).
 
     A weighted k-nearest neighbor classifier that assigns class probabilities to 
     instances based on neighbor counts weighted by class-specific inverse frequency 
@@ -29,22 +28,16 @@ class PWKCLF:
     y_train : ndarray
         Labels of training samples.
 
-    Methods
-    -------
-    fit(X, y)
-        Fits the k-NN structure and computes class weights.
-    predict(X)
-        Predicts class labels by weighted voting among neighbors.
 
     Notes
     -----
     The class weights are defined as:
 
-    \[
-    w_c = \left( \frac{N_c}{\min_{c'} N_{c'}} \right)^{-\frac{1}{\alpha}},
-    \]
+    .. math::
+
+        w_c = \left( \frac{N_c}{\min_{c'} N_{c'}} \right)^{-\frac{1}{\alpha}},
 
-    where \( N_c \) is the count of class \( c \) in the training set.
+    where :math:`N_c` is the count of class :math:`c` in the training set.
 
     This weighting scheme reduces bias towards majority classes by downweighting them
     in the voting process.

mlquantify/neighbors/_kde.py

@@ -16,17 +16,16 @@ from scipy.optimize import minimize
 # ============================================================
 
 def _optimize_on_simplex(objective, n_classes, x0=None):
-    """
-    Optimize an objective function over the probability simplex.
+    r"""Optimize an objective function over the probability simplex.
     
     This function performs constrained optimization to find the mixture weights
-    \( \alpha \) on the simplex \( \Delta^{n-1} = \{ \alpha \in \mathbb{R}^n : \alpha_i \geq 0, \sum_i \alpha_i = 1 \} \)
+    :math:`\alpha` on the simplex :math:`\Delta^{n-1} = \{ \alpha \in \mathbb{R}^n : \alpha_i \geq 0, \sum_i \alpha_i = 1 \}`
     that minimize the given objective function.
 
     Parameters
     ----------
     objective : callable
-        Function from \( \mathbb{R}^n \to \mathbb{R} \) to minimize.
+        Function from :math:`\mathbb{R}^n \to \mathbb{R}` to minimize.
     n_classes : int
         Dimensionality of the simplex (number of classes).
     x0 : array-like, optional
@@ -59,7 +58,7 @@ def _optimize_on_simplex(objective, n_classes, x0=None):
 # ============================================================
 
 class KDEyML(BaseKDE):
-    """KDEy Maximum Likelihood quantifier.
+    r"""KDEy Maximum Likelihood quantifier.
     
     Models class-conditional densities of posterior probabilities via Kernel Density
     Estimation (KDE) and estimates class prevalences by maximizing the likelihood of 
@@ -80,13 +79,13 @@ class KDEyML(BaseKDE):
     """
 
     def _precompute_training(self, train_predictions, train_y_values):
-        """
+        r"""
         Fit KDE models on class-specific training posterior predictions.
         """
         super()._fit_kde_models(train_predictions, train_y_values)
 
     def _solve_prevalences(self, predictions):
-        """
+        r"""
         Estimate class prevalences by maximizing log-likelihood under KDE mixture.
         
         Parameters
@@ -208,8 +207,7 @@ class KDEyHD(BaseKDE):
 # ============================================================
 
 class KDEyCS(BaseKDE):
-    """
-    KDEy Cauchy-Schwarz Divergence quantifier.
+    r"""KDEy Cauchy-Schwarz Divergence quantifier.
     
     Uses a closed-form solution for minimizing the Cauchy-Schwarz (CS) divergence between
     Gaussian Mixture Models representing class-conditional densities fitted via KDE.

mlquantify/neighbors/_utils.py

@@ -11,17 +11,16 @@ EPS = 1e-12
 # ============================================================
 
 def gaussian_kernel(X, Y, bandwidth):
-    """
-    Compute the Gaussian kernel matrix K(x, y) with specified bandwidth.
+    r"""Compute the Gaussian kernel matrix K(x, y) with specified bandwidth.
 
     This kernel matrix represents the similarity between each pair of points in X and Y,
     computed using the Gaussian (RBF) kernel function:
 
-    \[
-    K(x, y) = \frac{1}{(2 \pi)^{D/2} h^D} \exp\left(- \frac{\|x - y\|^2}{2 h^2}\right)
-    \]
+    .. math::
+
+        K(x, y) = \frac{1}{(2 \pi)^{D/2} h^D} \exp\left(- \frac{\|x - y\|^2}{2 h^2}\right)
 
-    where \( h \) is the bandwidth (smoothing parameter), and \( D \) is the dimensionality
+    where :math:`h` is the bandwidth (smoothing parameter), and :math:`D` is the dimensionality
     of the input feature space.
 
     Parameters
@@ -31,7 +30,7 @@ def gaussian_kernel(X, Y, bandwidth):
     Y : array-like of shape (n_samples_Y, n_features) or None
         Input data points for kernel computation. If None, defaults to X.
     bandwidth : float
-        Kernel bandwidth parameter \( h \).
+        Kernel bandwidth parameter :math:`h`.
 
     Returns
     -------
@@ -50,14 +49,13 @@ def gaussian_kernel(X, Y, bandwidth):
 
 
 def negative_log_likelihood(mixture_likelihoods):
-    """
-    Compute the negative log-likelihood of given mixture likelihoods in a numerically stable way.
+    r"""Compute the negative log-likelihood of given mixture likelihoods in a numerically stable way.
+
+    Given mixture likelihood values :math:`p_i` for samples, the negative log-likelihood is:
 
-    Given mixture likelihood values \( p_i \) for samples, the negative log-likelihood is:
+    .. math::
 
-    \[
-    - \sum_i \log(p_i)
-    \]
+        - \sum_i \log(p_i)
 
     Numerical stability is achieved by clipping likelihoods below a small epsilon.
 
@@ -76,14 +74,13 @@ def negative_log_likelihood(mixture_likelihoods):
 
 
 def _simplex_constraints(n):
-    """
-    Define constraints and bounds for optimization over the probability simplex.
+    r"""Define constraints and bounds for optimization over the probability simplex.
+
+    The simplex is defined as all vectors :math:`\alpha \in \mathbb{R}^n` such that:
 
-    The simplex is defined as all vectors \( \alpha \in \mathbb{R}^n \) such that:
+    .. math::
 
-    \[
-    \alpha_i \geq 0, \quad \sum_{i=1}^n \alpha_i = 1
-    \]
+        \alpha_i \geq 0, \quad \sum_{i=1}^n \alpha_i = 1
 
     Parameters
     ----------
@@ -103,8 +100,7 @@ def _simplex_constraints(n):
 
 
 def _optimize_on_simplex(objective, n, x0=None):
-    """
-    Minimize an objective function over the probability simplex.
+    r"""Minimize an objective function over the probability simplex.
 
     This function solves for mixture weights \( \boldsymbol{\alpha} \) that minimize the 
     objective function under the constraints \(\alpha_i \geq 0\) and \(\sum_i \alpha_i = 1\).

mlquantify/utils/_validation.py

@@ -274,7 +274,7 @@ def validate_data(quantifier,
         else:
             out = X, y
     elif not no_val_X and no_val_y:
-        out = check_array(X, input_name="X", **check_params)
+        out = check_array(X, input_name="X", dtype=None, **check_params)
     elif no_val_X and not no_val_y:
         out = _check_y(y, **check_params)
     else:
@@ -286,12 +286,12 @@ def validate_data(quantifier,
             check_X_params, check_y_params = validate_separately
             if "estimator" not in check_X_params:
                 check_X_params = {**default_check_params, **check_X_params}
-            X = check_array(X, input_name="X", **check_X_params)
+            X = check_array(X, input_name="X", dtype=None, **check_X_params)
             if "estimator" not in check_y_params:
                 check_y_params = {**default_check_params, **check_y_params}
             y = check_array(y, input_name="y", **check_y_params)
         else:
-            X, y = check_X_y(X, y, **check_params)
+            X, y = check_X_y(X, y, dtype=None, **check_params)
         out = X, y
         
     return out

mlquantify/utils/prevalence.py

@@ -3,7 +3,7 @@ import pandas as pd
 from collections import defaultdict
 
 
-def get_prev_from_labels(y) -> dict:
+def get_prev_from_labels(y, format="dict") -> dict:
     """
     Get the real prevalence of each class in the target array.
     
@@ -19,6 +19,9 @@ def get_prev_from_labels(y) -> dict:
     """
     if isinstance(y, np.ndarray):
         y = pd.Series(y)
+    if format == "array":
+        prevalences = y.value_counts(normalize=True).sort_index().values
+        return prevalences
     real_prevs = y.value_counts(normalize=True).to_dict()
     real_prevs = dict(sorted(real_prevs.items()))
     return real_prevs

{mlquantify-0.1.9.dist-info → mlquantify-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlquantify
-Version: 0.1.9
+Version: 0.1.11
 Summary: Quantification Library
 Home-page: https://github.com/luizfernandolj/QuantifyML/tree/master
 Maintainer: Luiz Fernando Luth Junior
@@ -30,7 +30,7 @@ Dynamic: maintainer
 Dynamic: requires-dist
 Dynamic: summary
 
-<h1 align="center">MLQuantify</h1>
+<img src="assets/logo_mlquantify-white.svg" alt="mlquantify logo">
 <h4 align="center">A Python Package for Quantification</h4>
 
 ___
@@ -41,7 +41,7 @@ ___
 
 ## Latest Release
 
-- **Version 0.1.3**: Inicial beta version. For a detailed list of changes, check the [changelog](#).
+- **Version 0.1.11**: Inicial beta version. For a detailed list of changes, check the [changelog](#).
 - In case you need any help, refer to the [User Guide](https://luizfernandolj.github.io/mlquantify/user_guide.html).
 - Explore the [API documentation](https://luizfernandolj.github.io/mlquantify/api/index.html) for detailed developer information.
 - See also the library in the pypi site in [pypi mlquantify](https://pypi.org/project/mlquantify/)
@@ -73,7 +73,6 @@ ___
 | **Model Selection** | Criteria and processes used to select the best model, such as grid-search for the case of quantification|
 | **Evaluation Metrics** | Specific metrics used to evaluate quantification performance, (e.g., AE, MAE, NAE, SE, KLD, etc.). |
 | **Evaluation Protocols** | Evaluation protocols used, based on sampling generation (e.g., APP, NPP, etc.).. |
-| **Plotting Results** | Tools and techniques used to visualize results, such as the protocol results.|
 | **Comprehensive Documentation** | Complete documentation of the project, including code, data, and results. |
 
 ___
@@ -84,8 +83,8 @@ This code first loads the breast cancer dataset from _sklearn_, which is then sp
 
 ```python
 from mlquantify.methods import EMQ
-from mlquantify.evaluation.measures import absolute_error, mean_absolute_error
-from mlquantify.utils import get_real_prev
+from mlquantify.metrics import MAE, NRAE
+from mlquantify.utils import get_prev_from_labels
 
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.datasets import load_breast_cancer
@@ -103,14 +102,14 @@ model.fit(X_train, y_train)
 
 #Predict the class prevalence for X_test
 pred_prevalence = model.predict(X_test)
-real_prevalence = get_real_prev(y_test)
+real_prevalence = get_prev_from_labels(y_test)
 
 #Get the error for the prediction
-ae = absolute_error(real_prevalence, pred_prevalence)
-mae = mean_absolute_error(real_prevalence, pred_prevalence)
+mae = MAE(real_prevalence, pred_prevalence)
+nrae = NRAE(real_prevalence, pred_prevalence)
 
-print(f"Absolute Error -> {ae}")
 print(f"Mean Absolute Error -> {mae}")
+print(f"Normalized Relative Absolute Error -> {nrae}")
 ```
 
 ___
@@ -129,13 +128,6 @@ ___
 
 ## Documentation
 
-##### API is avaliable [here](https://luizfernandolj.github.io/mlquantify/api/index.html)
-
-- [Methods](https://github.com/luizfernandolj/mlquantify/wiki/Methods)
-- [Model Selection](https://github.com/luizfernandolj/mlquantify/wiki/Model-Selection)
-- [Evaluation](https://github.com/luizfernandolj/mlquantify/wiki/Evaluation)
-- [Plotting](https://github.com/luizfernandolj/mlquantify/wiki/Plotting)
-- [Utilities](https://github.com/luizfernandolj/mlquantify/wiki/Utilities)
-
+##### API is avaliable [here](https://luizfernandolj.github.io/mlquantify/api/)
 
 ___