machinegnostics 0.0.1__py3-none-any.whl

machinegnostics/metrics/robr2.py

@@ -0,0 +1,119 @@
+'''
+ManGo - Machine Gnostics Library
+Copyright (C) 2025  ManGo Team
+
+Author: Nirmal Parmar
+'''
+import logging
+from machinegnostics.magcal.util.logging import get_logger
+import numpy as np
+from machinegnostics.magcal.criteria_eval import CriteriaEvaluator
+
+def robr2(y: np.ndarray, y_fit: np.ndarray, w: np.ndarray = None, verbose: bool = False) -> float:
+    """
+    Compute the Robust R-squared (RobR2) value for evaluating the goodness of fit between observed data and model predictions.
+
+    The Robust R-squared (RobR2) is a statistical metric that measures the proportion of variance in the observed data 
+    explained by the fitted data, with robustness to outliers. Unlike the classical R-squared metric, RobR2 incorporates 
+    weights and is less sensitive to outliers, making it suitable for datasets with noise or irregularities.
+
+    Parameters
+    ----------
+    y : np.ndarray
+        The observed data (ground truth). Must be a 1D array of numerical values.
+    y_fit : np.ndarray
+        The fitted data (model predictions). Must be a 1D array of the same shape as `y`.
+    w : np.ndarray, optional
+        Weights for the data points. Must be a 1D array of the same shape as `y` if provided. Defaults to `None`, in which 
+        case equal weights are assumed.
+    verbose : bool, optional
+        If True, enables detailed logging for debugging purposes. Default is False.
+
+    Returns
+    -------
+    float
+        The computed Robust R-squared (RobR2) value. The value ranges from 0 to 1, where:
+        - 1 indicates a perfect fit.
+        - 0 indicates no explanatory power of the model.
+
+    Raises
+    ------
+    ValueError
+        If `y` and `y_fit` do not have the same shape.
+    ValueError
+        If `w` is provided and does not have the same shape as `y`.
+    ValueError
+        If `y` or `y_fit` are not 1D arrays.
+
+    Notes
+    -----
+    - The Robust R-squared (RobR2) is calculated using the formula:
+      RobR2 = 1 - (Σ(w_i * (e_i - ē)²) / Σ(w_i * (y_i - ȳ)²))
+      where:
+        - e_i = y_i - y_fit_i (residuals)
+        - ē = weighted mean of residuals
+        - ȳ = weighted mean of observed data
+        - w_i = weights for each data point
+    - This metric is robust to outliers due to the use of weights and is particularly useful for noisy datasets.
+    - If weights are not provided, equal weights are assumed for all data points.
+
+    References
+    ----------
+    - Kovanic P., Humber M.B (2015) The Economics of Information - Mathematical Gnostics for Data Analysis, Chapter 19.3.4
+    - Robust R-squared (RobR2) is defined in Equation 19.7 of the reference.
+
+    Example
+    -------
+    >>> import numpy as np
+    >>> from mango.metrics import robr2
+    >>> y = np.array([1.0, 2.0, 3.0, 4.0])
+    >>> y_fit = np.array([1.1, 1.9, 3.2, 3.8])
+    >>> w = np.array([1.0, 1.0, 1.0, 1.0])
+    >>> result = robr2(y, y_fit, w)
+    >>> print(result)
+
+    Comparison with Classical R-squared
+    -----------------------------------
+    The classical R-squared metric assumes equal weights and is sensitive to outliers. RobR2, on the other hand, 
+    incorporates weights and is robust to outliers, making it more reliable for datasets with irregularities or noise.
+    """
+    logger = get_logger('RobR2', level=logging.WARNING if not verbose else logging.INFO)
+    logger.info("Calculating Robust R-squared...")
+
+    # Check if y and y_fit are of the same shape
+    if y.shape != y_fit.shape:
+        logger.error("y and y_fit must have the same shape")
+        raise ValueError("y and y_fit must have the same shape")
+    
+    # Check with w shape
+    if w is not None and y.shape != w.shape:
+        logger.error("y and w must have the same shape")
+        raise ValueError("y and w must have the same shape")
+    
+    # 1D array check
+    if y.ndim != 1 or y_fit.ndim != 1:
+        logger.error("y and y_fit must be 1D arrays")
+        raise ValueError("y and y_fit must be 1D arrays")
+    
+    # Convert to numpy arrays and flatten
+    y_true = np.asarray(y).flatten()
+    y_pred = np.asarray(y_fit).flatten()
+
+    # dimensions of y and y_fit validation
+    if y_true.ndim != 1 or y_pred.ndim != 1:
+        logger.error("y and y_fit must be 1D arrays")
+        raise ValueError("y and y_fit must be 1D arrays")
+    
+    # inf and nan check
+    if np.any(np.isnan(y_true)) or np.any(np.isnan(y_pred)):
+        logger.error("y and y_fit must not contain NaN values")
+        raise ValueError("y and y_fit must not contain NaN values")
+    
+    # CE
+    logger.info("Initializing CriteriaEvaluator...")
+    ce = CriteriaEvaluator(y=y, y_fit=y_fit, w=w, verbose=verbose)
+
+    # Compute the robust R-squared
+    robr2_value = ce._robr2()
+    logger.info(f"Gnostic Robust R-squared calculated.")
+    return robr2_value

machinegnostics/metrics/std.py

@@ -0,0 +1,144 @@
+'''
+Gnostic standard deviation of given sample
+
+method: std()
+
+Authors: Nirmal Parmar
+Machine Gnostics
+'''
+
+import logging
+from machinegnostics.magcal.util.logging import get_logger
+import numpy as np
+from machinegnostics.metrics.mean import mean
+from machinegnostics.metrics.variance import variance
+from machinegnostics.magcal import EGDF
+
+def std(data: np.ndarray,
+        case: str = 'i',
+        S: float = 'auto',
+        z0_optimize: bool = True,
+        data_form: str = 'a',
+        tolerance: float = 1e-6,
+        verbose: bool = False) -> tuple:
+    """
+    Calculate the standard deviation of the given data.
+
+    The Gnostic standard deviation metric is based on the principles of gnostic theory, which
+    provides robust estimates of data relationships. This metric leverages the concepts
+    of estimating irrelevances and fidelities, and quantifying irrelevances and fidelities, which are robust measures of data uncertainty. These irrelevances are aggregated differently.
+
+    Parameters:
+    -----------
+    data : np.ndarray
+        Input data array.
+    case : str, optional
+        Case for irrelevance calculation ('i' or 'j'). Default is 'i'. 
+        'i' for estimating variance, 'j' for quantifying variance.
+    Scaling parameter for ELDF. Default is 1. Can be 'auto' to optimize using EGDF.
+            Suggested range is [0.01, 2].
+    z0_optimize : bool, optional
+        Whether to optimize z0 in ELDF. Default is True.    
+    data_form : str, optional
+        Data form for ELDF. Default is 'a'. 'a' for additive, 'm' for multiplicative.
+    tolerance : float, optional
+        Tolerance for ELDF fitting. Default is 1e-6.
+    verbose : bool, optional
+        If True, enables detailed logging for debugging purposes. Default is False.
+
+    Returns:
+    --------
+    tuple
+        Lower and upper bounds of the standard deviation.
+
+    Example:
+    --------
+    >>> import machinegnostics as mg
+    >>> import numpy as np
+    >>> data = np.array([1, 2, 3, 4, 5])
+    >>> mg.std(data)
+    (2.9403976979154143, 3.0599336862362043)
+    """
+    logger = get_logger('std', level=logging.WARNING if not verbose else logging.INFO)
+    logger.info("Calculating standard deviation...")
+
+    # Validate input
+    if not isinstance(data, np.ndarray):
+        logger.error("Input must be a numpy array.")
+        raise TypeError("Input must be a numpy array.")
+    if data.ndim != 1:
+        logger.error("Input data must be a one-dimensional array.")
+        raise ValueError("Input data must be a one-dimensional array.")
+    if len(data) == 0:
+        logger.error("Input data array is empty.")
+        raise ValueError("Input data array is empty.")
+    if np.any(np.isnan(data)):
+        logger.error("Input data contains NaN values.")
+        raise ValueError("Input data contains NaN values.")
+    if np.any(np.isinf(data)):
+        logger.error("Input data contains Inf values.")
+        raise ValueError("Input data contains Inf values.")
+    # Check for valid case
+    if case not in ['i', 'j']:
+        logger.error("Case must be 'i' for estimating variance or 'j' for quantifying variance.")
+        raise ValueError("Case must be 'i' for estimating variance or 'j' for quantifying variance.")
+    # arg validation
+    if isinstance(S, str):
+        if S != 'auto':
+            logger.error("S must be a float or 'auto'.")
+            raise ValueError("S must be a float or 'auto'.")
+    elif not isinstance(S, (int, float)):
+        logger.error("S must be a float or 'auto'.")
+        raise TypeError("S must be a float or 'auto'.")
+    # S proper value [0,2] suggested
+    if isinstance(S, (int)):
+        if S < 0 or S > 2:
+            logger.warning("S must be in the range [0, 2].")
+    # Check for valid data_form
+    if data_form not in ['a', 'm']:
+        logger.error("data_form must be 'a' for additive or 'm' for multiplicative.")
+        raise ValueError("data_form must be 'a' for additive or 'm' for multiplicative.")
+    
+    # mean
+    logger.info("Calculating mean...")
+    m = mean(data, S=S, z0_optimize=z0_optimize, data_form=data_form, tolerance=tolerance)
+
+    # variance
+    logger.info("Calculating variance...")
+    v = np.abs(variance(data, case=case, S=S, z0_optimize=z0_optimize, data_form=data_form, tolerance=tolerance))
+
+    # if is str
+    if isinstance(S, str):
+        if S == 'auto':
+            logger.info("Optimizing S using EGDF...")
+            egdf = EGDF(z0_optimize=z0_optimize, data_form=data_form, tolerance=tolerance, verbose=verbose)
+            egdf.fit(data=data, plot=False)
+            S = egdf.S_opt
+            # S value limits [0.01, 1e3]
+            S = np.clip(S, 0.01, 1e3)
+    # std
+    if case.lower() == 'i':
+        logger.info("Calculating standard deviation the estimating geometry...")
+        std_value_ub = m * ((1 + np.sqrt(v)) / ( 1 - np.sqrt(v)))**(S/2)
+        std_value_lb = m * ((1 - np.sqrt(v)) / ( 1 + np.sqrt(v)))**(S/2)
+        if 1 - np.sqrt(v) <= 0:
+            logger.warning("Encountered negative sqrt value!")
+            return 0, 0
+
+    elif case.lower() == 'j':
+        logger.info("Calculating standard deviation the quantifying geometry...")
+
+        std_value_ub = m * ((np.sqrt(v)) + ( 1 + np.sqrt(v)))**(S/2)
+        # safe v
+        if 1 - np.sqrt(v) < 0:
+            logger.warning("Encountered negative sqrt value, returning 0,0. Use case 'i' for estimating geometry.")
+            return 0, std_value_ub
+        
+        std_value_lb = m * ((np.sqrt(v)) + ( 1 - np.sqrt(v)))**(S/2)
+
+    else:
+        raise ValueError("case must be either 'i' or 'j'. i for estimating variance, j for quantifying variance.")
+    
+    logger.info("Gnostic standard deviation calculation completed.")
+
+    return float(std_value_lb), float(std_value_ub)

machinegnostics/metrics/variance.py

@@ -0,0 +1,101 @@
+'''
+Gnostic Variance of given sample data
+
+method: variance()
+
+Authors: Nirmal Parmar
+Machine Gnostics
+'''
+import numpy as np
+import logging
+from machinegnostics.metrics.mean import mean
+from machinegnostics.magcal import ELDF, QLDF
+from machinegnostics.magcal.util.logging import get_logger
+
+def variance(data: np.ndarray,
+             case: str = 'i', 
+             S: float = 1, 
+             z0_optimize: bool = True, 
+             data_form: str = 'a',
+             tolerance: float = 1e-6,
+             verbose: bool = False) -> float:
+    """
+    Calculate the gnostic variance of the given data.
+
+    The Gnostic variance metric is based on the principles of gnostic theory, which
+    provides robust estimates of data relationships. This metric leverages the concepts
+    of estimating irrelevances and quantifying irrelevances, which are robust measures
+    of data uncertainty. These irrelevances are aggregated differently.
+
+    Parameters:
+    -----------
+    data : np.ndarray
+        Input data array.
+    case : str, optional
+        Case for irrelevance calculation ('i' or 'j'). Default is 'i'. 
+        'i' for estimating variance, 'j' for quantifying variance.
+    S : float, optional
+        Scaling parameter for ELDF. Default is 1.
+    z0_optimize : bool, optional
+        Whether to optimize z0 in ELDF. Default is True.
+    data_form : str, optional
+        Data form for ELDF. Default is 'a'. 'a' for additive, 'm' for multiplicative.
+    tolerance : float, optional
+        Tolerance for ELDF fitting. Default is 1e-6.
+
+    Returns:
+    --------
+    float
+        Gnostic variance of the data.
+
+    Example:
+    --------
+    >>> import machinegnostics as mg
+    >>> import numpy as np
+    >>> data = np.array([1, 2, 3, 4, 5])
+    >>> mg.variance(data)
+    0.002685330177795109
+    """
+    logger = get_logger('variance', level=logging.WARNING if not verbose else logging.INFO)
+
+    logger.info("Calculating gnostic variance...")
+    # Validate input
+    if not isinstance(data, np.ndarray):
+        logger.error("Input must be a numpy array.")
+        raise TypeError("Input must be a numpy array.")
+    if data.ndim != 1:
+        logger.error("Input data must be a one-dimensional array.")
+        raise ValueError("Input data must be a one-dimensional array.")
+    if len(data) == 0:
+        logger.error("Input data array is empty.")
+        raise ValueError("Input data array is empty.")
+    if np.any(np.isnan(data)):
+        logger.error("Input data contains NaN values.")
+        raise ValueError("Input data contains NaN values.")
+    if np.any(np.isinf(data)):
+        logger.error("Input data contains Inf values.")
+        raise ValueError("Input data contains Inf values.")
+    # Check for valid case
+    if case not in ['i', 'j']:
+        logger.error("Case must be 'i' for estimating variance or 'j' for quantifying variance.")
+        raise ValueError("Case must be 'i' for estimating variance or 'j' for quantifying variance.")
+    
+    if case == 'i':
+        logger.info("Using ELDF for variance calculation...")
+        # Compute eldf
+        eldf = ELDF(homogeneous=True, S=S, z0_optimize=z0_optimize, tolerance=tolerance, data_form=data_form, wedf=False, flush=False)
+        eldf.fit(data, plot=False)
+        hi = eldf.hi
+        hc = np.mean(hi**2)
+    
+    if case == 'j':
+        logger.info("Using QLDF for variance calculation...")
+        # Compute qldf
+        qldf = QLDF(homogeneous=True, S=S, z0_optimize=z0_optimize, tolerance=tolerance, data_form=data_form, wedf=False, flush=False)
+        qldf.fit(data)
+        hj = qldf.hj
+        hc = np.mean(hj**2)
+
+    logger.info(f"Gnostic variance calculated.")
+
+    return float(hc)

machinegnostics/models/__init__.py

@@ -0,0 +1,2 @@
+from machinegnostics.models.cross_validation import CrossValidator
+from machinegnostics.models.data_split import train_test_split

machinegnostics/models/classification/__init__.py

@@ -0,0 +1 @@
+from machinegnostics.models.classification.mg_log_reg import LogisticRegressor

machinegnostics/models/classification/layer_history_log_reg.py

@@ -0,0 +1,121 @@
+import numpy as np
+from machinegnostics.models.classification.layer_param_log_reg import ParamLogisticRegressorBase
+from dataclasses import dataclass
+
+class HistoryRobustRegressor(ParamLogisticRegressorBase):
+    """
+    History class for the Logistic Regressor model.
+    
+    This class extends HistoryBase and ParamRobustRegressorBase to maintain a history
+    of model parameters and gnostic loss values during training iterations.
+    
+    Parameters needed to record history:
+        - h_loss: Gnostic loss value at each iteration
+        - iteration: The iteration number
+        - weights: Model weights at each iteration
+        - coefficients: Model coefficients at each iteration
+        - degree: Degree of polynomial features used in the model
+        - rentropy: Entropy of the model at each iteration
+        - fi, hi, fj, hj, infoi, infoj, pi, pj, ei, ej: Additional gnostic information if calculated
+    """
+    
+    def __init__(self,
+                 degree: int = 1,
+                 max_iter: int = 100,
+                 tol: float = 1e-3,
+                 early_stopping: bool = True,
+                 verbose: bool = False,
+                 scale: 'str | int | float' = 'auto',
+                 data_form: str = 'a',
+                 gnostic_characteristics:bool=True,
+                 history: bool = True,
+                 proba:str = 'gnostic'):
+        super().__init__(
+            degree=degree,
+            max_iter=max_iter,
+            tol=tol,
+            early_stopping=early_stopping,
+            verbose=verbose,
+            scale=scale,
+            data_form=data_form,
+            gnostic_characteristics=gnostic_characteristics,
+            proba=proba
+        )
+        
+        self.degree = degree
+        self.max_iter = max_iter
+        self.tol = tol
+        self.early_stopping = early_stopping
+        self.verbose = verbose
+        self.scale = scale
+        self.data_form = data_form
+        self.gnostic_characteristics = gnostic_characteristics
+        self.history = history
+        self.proba = proba
+        self.params = [
+            {
+                'iteration': 0,
+                'loss': None,
+                'weights': None,
+                'coefficients': None,
+                'degree': self.degree,
+                'rentropy': None,
+                'fi': None,
+                'hi': None,
+                'fj': None,
+                'hj': None,
+                'infoi': None,
+                'infoj': None,
+                'pi': None,
+                'pj': None,
+                'ei': None,
+                'ej': None
+            }
+        ]
+
+        # logger
+        self.logger.info("HistoryRobustRegressor initialized.")
+    
+    def _fit(self, X: np.ndarray, y: np.ndarray):
+        """
+        Fit the model to the data and record history.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            Input features.
+        y : np.ndarray
+            Target values.
+        """
+        self.logger.info("Starting fit process for HistoryRobustRegressor.")
+        # Call the parent fit method to perform fitting
+        super()._fit(X, y)
+
+        # Record the initial state in history as a dict
+        params_dict = {}
+
+        if self.gnostic_characteristics:
+            params_dict['iteration'] = self._iter + 1
+            params_dict['loss'] = self.loss
+            params_dict['weights'] = self.weights.copy() if self.weights is not None else None
+            params_dict['coefficients'] = self.coefficients.copy() if self.coefficients is not None else None
+            params_dict['degree'] = self.degree
+            params_dict['rentropy'] = self.re
+            params_dict['fi'] = self.fi
+            params_dict['hi'] = self.hi
+            params_dict['fj'] = self.fj
+            params_dict['hj'] = self.hj
+            params_dict['infoi'] = self.infoi
+            params_dict['infoj'] = self.infoj
+            params_dict['pi'] = self.pi
+            params_dict['pj'] = self.pj
+            params_dict['ei'] = self.ei
+            params_dict['ej'] = self.ej
+        else:
+            params_dict['iteration'] = 0
+            params_dict['loss'] = None
+            params_dict['weights'] = self.weights.copy() if self.weights is not None else None
+            params_dict['coefficients'] = self.coefficients .copy() if self.coefficients is not None else None
+            params_dict['degree'] = self.degree
+
+        self.params.append(params_dict)

machinegnostics/models/classification/layer_io_process_log_reg.py

@@ -0,0 +1,98 @@
+import numpy as np
+from machinegnostics.magcal.layer_io_process_base import DataProcessLayerBase
+from machinegnostics.models.classification.layer_mlflow_log_reg import InterfaceLogisticRegressor
+from machinegnostics.magcal import disable_parent_docstring
+
+@disable_parent_docstring
+class DataProcessLogisticRegressor(DataProcessLayerBase, InterfaceLogisticRegressor):
+    """
+    Data processing layer for the Robust Regressor model.
+    Handles data preprocessing specific to the Robust Regressor model.
+    """
+    @disable_parent_docstring
+    def __init__(self,
+                 degree: int = 1,
+                 max_iter: int = 100,
+                 tol: float = 1e-3,
+                 early_stopping: bool = True,
+                 verbose: bool = False,
+                 scale: str | int | float = 'auto',
+                 data_form: str = 'a',
+                 gnostic_characteristics: bool = True,
+                 history: bool = True,
+                 proba: str = 'gnostic',
+                 **kwargs):
+        super().__init__(
+            degree=degree,
+            max_iter=max_iter,
+            tol=tol,
+            early_stopping=early_stopping,
+            verbose=verbose,
+            scale=scale,
+            data_form=data_form,
+            gnostic_characteristics=gnostic_characteristics,
+            history=history,
+            proba=proba,
+            **kwargs
+        )
+
+        # logger
+        self.logger.info("DataProcessLogisticRegressor initialized.")
+
+        # --- argument checks ---
+        if not isinstance(degree, int) or degree < 1:
+            raise ValueError("Degree must be a positive integer.")
+        if not isinstance(max_iter, int) or max_iter < 1:
+            raise ValueError("max_iter must be a positive integer.")
+        if not isinstance(tol, (float, int)) or tol <= 0:
+            raise ValueError("tol must be a positive float or int.")
+        if not isinstance(scale, (str, int, float)):
+            raise ValueError("scale must be a string, int, or float.")
+        if isinstance(scale, (int, float)) and (scale < 0 or scale > 2):
+            raise ValueError("scale must be between 0 and 2 if it is a number.")
+        if data_form not in ['a', 'm']:
+            raise ValueError("data_form must be either 'a' (additive) or 'm' (multiplicative).")
+        if proba not in ['gnostic', 'sigmoid']:
+            raise ValueError("proba must be either 'gnostic' or 'sigmoid'.")
+        self.degree = degree
+        self.max_iter = max_iter
+        self.tol = tol
+        self.early_stopping = early_stopping
+        self.verbose = verbose
+        self.scale = scale
+        self.data_form = data_form
+        self.gnostic_characteristics = gnostic_characteristics
+        self.history = history
+        self.params = []
+
+    @disable_parent_docstring
+    def _fit(self, X, y):
+        """
+        Fit the model to the data and preprocess it.
+        """
+        self.logger.info("Starting fit process for DataProcessLogisticRegressor.")
+        X, y = self._fit_io(X, y)
+        # Call the fit method from the next class in the MRO
+        return super()._fit(X, y)
+
+    @disable_parent_docstring
+    def _predict(self, X) -> np.ndarray:
+        """
+        Predict using the model after preprocessing the input data.
+        """
+        self.logger.info("Making predictions with DataProcessLogisticRegressor.")
+        X = self._predict_io(X)
+        y_pred = super()._predict(X)
+        # y_pred = self._convert_output(y_pred, self.data_form)
+        return y_pred
+    
+    @disable_parent_docstring
+    def _predict_proba(self, X) -> np.ndarray:
+        """
+        Predict probabilities using the model after preprocessing the input data.
+        """
+        self.logger.info("Calculating predicted probabilities with DataProcessLogisticRegressor.")
+        X = self._predict_io(X)
+        y_proba = super()._predict_proba(X)
+        # y_proba = self._convert_output(y_proba, self.data_form)
+        return y_proba