machinegnostics 0.0.1__py3-none-any.whl

machinegnostics/magcal/scale_optimization.py

@@ -0,0 +1,185 @@
+'''
+ManGo - Machine Gnostics Library
+Copyright (C) 2025  ManGo Team
+
+Author: Nirmal Parmar
+'''
+
+import numpy as np
+from scipy.optimize import minimize
+from typing import Union
+from machinegnostics.magcal.characteristics import GnosticsCharacteristics
+
+class ScaleOptimization(GnosticsCharacteristics):
+    """
+    A class to perform scale optimization on a given matrix. This class is for internal use.
+
+    Parameters
+    ----------
+    R : np.ndarray
+        The input matrix for the scale optimization.
+    eps : float, optional
+        A small value to avoid division by zero (default is np.finfo(float).max).
+    c : str [in {'i', 'j'}]
+        The type of scale optimization to perform. 'i' for estimation and 'j' for quantification.
+        c2 ∈{1,−1}and hc be the irrelevance, either hj (quantifying, c2 = 1) or hi (estimating, c2=−1)
+    eps : float, optional
+        A small value to avoid division by zero (default is np.finfo(float).eps).
+
+    Attributes
+    ----------
+    q : np.ndarray
+        The input matrix.
+    q1 : np.ndarray
+        The inverse of the input matrix, with protection against division by zero.
+    """
+    
+    def __init__(self, 
+                 X: np.ndarray, 
+                 y: np.ndarray, 
+                 c: str, 
+                 eps: float = np.finfo(float).eps):
+        """
+        Initializes the ScaleOptimization class.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            The input matrix for the scale optimization.
+        y : np.ndarray
+            The target values for the optimization.
+        c : str [in {'i', 'j'}]
+            The type of scale optimization to perform. 'i' for estimation and 'j' for quantification.
+        eps : float, optional
+            A small value to avoid division by zero (default is np.finfo(float).max).
+        """
+    
+    def _F(self, C, x)-> float:
+        """
+        Computes the predicted values based on the coefficients C and input features x_obs.
+
+        Parameters
+        ----------
+        C : np.ndarray
+            Coefficients for the regression model.
+        x_obs : np.ndarray
+            Observed input features.
+
+        Returns
+        -------
+        np.ndarray
+            Predicted values.
+        """
+        return np.dot(x, C)
+    
+    def _recompute_q(self, Z, z0, S)-> np.ndarray:
+        """
+        Computes the q values for optimization.
+
+        Parameters
+        ----------
+        Z_obs : np.ndarray
+            Observed target values.
+        z0 : np.ndarray
+            Predicted target values.
+        S : float
+            Scale parameter.
+
+        Returns
+        -------
+        np.ndarray
+            Computed q values.
+        """
+        q = np.abs(Z / z0) / (S+self.eps) # to avoid division by zero
+        q1 = 1 / q
+        q1 = np.where(q1 != 0, q1, np.finfo(float).max)
+        return q, q1
+    
+    def _recompute_h(self, q, q1, c:str)-> np.ndarray:
+        """
+        Computes the h values for optimization.
+
+        Parameters
+        ----------
+        q : np.ndarray
+            Computed q values.
+        c : str [in {'i', 'j'}]
+            The type of scale optimization to perform. 'i' for estimation and 'j' for quantification.
+
+        Returns
+        -------
+        np.ndarray
+            Computed h values.
+        """
+        if c == 'i':
+            return self._hi(q, q1)
+        elif c == 'j':
+            return self._fj(q, q1)
+        else:
+            raise ValueError("Invalid value for c. Must be 'i' or 'j'.")
+        
+    def _criterion(self, C, S, x, Z):
+        """
+        Computes the criterion function for optimization.
+
+        Parameters
+        ----------
+        C : np.ndarray
+            Coefficients for the regression model.
+        S : float
+            Scale parameter.
+        x : np.ndarray
+            Input features.
+        Z : np.ndarray
+            Target values.
+
+        Returns
+        -------
+        float
+            Computed criterion value.
+        """
+        z0 = self._F(C, x)
+        q, q1 = self._recompute_q(Z, z0, S)
+        h = self._recompute_h(q, q1, self.c) 
+        # Compute the criterion value (e.g., sum of squares)
+        D_hi = h ** 2 # simple quadratic loss
+        return np.sum(D_hi)
+    
+    def _optimize(self, x, Z):
+        """
+        Optimizes the scale parameter S and coefficients C.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input features.
+        Z : np.ndarray
+            Target values.
+
+        Returns
+        -------
+        tuple
+            Optimized coefficients C and scale parameter S.
+        """
+        # Initial guess for C and S
+        C0 = np.ones(x.shape[1])
+        S0 = 1.0
+
+        # Define the objective function to minimize
+        def objective(params):
+            C = params[:-1]
+            S = np.abs(params[-1])
+            return self._criterion(C, S, x, Z)
+
+        # Initial guess for parameters
+        initial_params = np.concatenate((C0, [S0]))
+
+        # Perform optimization
+        result = minimize(objective, initial_params, method='BFGS',)
+
+        # Extract optimized coefficients and scale parameter
+        optimized_params = result.x
+        C_opt = optimized_params[:-1]
+        S_opt = optimized_params[-1]
+
+        return C_opt, S_opt

machinegnostics/magcal/scale_param.py

@@ -0,0 +1,313 @@
+'''
+ManGo - Machine Gnostics Library
+Copyright (C) 2025  ManGo Team
+
+Author: Nirmal Parmar
+
+ideas:
+- LocS
+- GlobS
+- VarS
+'''
+import numpy as np
+from machinegnostics.magcal import GnosticsCharacteristics
+from scipy.optimize import minimize_scalar
+import logging
+from machinegnostics.magcal.util.logging import get_logger
+
+class ScaleParam():
+    """
+    A Machine Gnostic class to compute and optimize scale parameter for different gnostic distribution functions.
+    
+    This class provides methods to calculate scale parameters used in gnostic analysis, including
+    local scale parameters and variable scale parameters for kernel-based estimations.
+    
+    The scale parameter affects the shape and characteristics of gnostic distributions, controlling
+    how the distributions respond to variations in the input data.
+    
+    Notes
+    -----
+    The scale parameter is a critical component in Machine Gnostics that influences the behavior
+    of distribution functions, particularly their sensitivity to outliers and their overall shape.
+    
+    The class implements multiple scale parameter calculation strategies:
+    - Local scale: Optimizes scale for individual data points
+    - Variable scale: Creates a vector of scale parameters for kernel-based estimation
+    """
+    
+
+    def __init__(self, verbose: bool = False):
+        self.logger = get_logger('ScaleParam', level=logging.WARNING if not verbose else logging.INFO)
+        self.logger.info("ScaleParam initialized.")
+
+    def _gscale_loc(self, F):
+        """
+        Calculate the local scale parameter for a given fidelity parameter F.
+        
+        This method uses the Newton-Raphson method to solve for the scale parameter that satisfies
+        the relationship between F and the scale. It supports both scalar and array-like inputs.
+        
+        Parameters
+        ----------
+        F : float or array-like
+            Input parameter (e.g., fidelity of data) at Scale = 1.
+            
+        Returns
+        -------
+        float or ndarray
+            The calculated local scale parameter(s). Will be the same shape as input F.
+            
+        Notes
+        -----
+        The Newton-Raphson method is used with initial values based on the magnitude of F:
+        - For F < (2/π) * √2/3: Initial S = π
+        - For F < 2/π: Initial S = 3π/4
+        - For F < (2/π) * √2: Initial S = π/2
+        - Otherwise: Initial S = π/4
+        
+        The method iteratively refines this estimate until convergence.
+        """
+        self.logger.info("Calculating local scale parameter...")
+        m2pi = 2 / np.pi
+        sqrt2 = np.sqrt(2)
+        epsilon = 1e-5
+
+        def _single_scale(f):
+            if f < m2pi * sqrt2 / 3:
+                S = np.pi
+            elif f < m2pi:
+                S = 3 * np.pi / 4
+            elif f < m2pi * sqrt2:
+                S = np.pi / 2
+            else:
+                S = np.pi / 4
+            for _ in range(100):
+                delta = (np.sin(S) - S * f) / (np.cos(S) - f)
+                S -= delta
+                if abs(delta) < epsilon:
+                    break
+            return S * m2pi
+        self.logger.info("Local scale parameter calculation complete.")
+
+        # Check if F is scalar
+        if np.isscalar(F):
+            return _single_scale(F)
+        else:
+            F = np.asarray(F)
+            return np.array([_single_scale(f) for f in F])
+
+
+    # def var_s(self, Z, W=None, S=1):
+    #     """
+    #     Calculates vector of scale parameters for each kernel.
+        
+    #     Parameters:
+    #     Z (array-like): Data vector
+    #     W (array-like, optional): Weight vector
+    #     S (float, optional): Scalar scale factor (default is 1)
+        
+    #     Returns:
+    #     numpy.ndarray: Scale vector (same length as Z)
+    #     """
+    #     Z = np.asarray(Z).reshape(-1, 1)
+
+    #     if W is None:
+    #         W = np.ones_like(Z) / len(Z)
+    #     else:
+    #         W = np.asarray(W).reshape(-1, 1)
+    #         if len(Z) != len(W):
+    #             raise ValueError("Z and W must be of the same length")
+    #         W = W / np.sum(W)
+
+    #     Sz = np.zeros_like(Z, dtype=float)
+
+    #     for k in range(len(W)):
+    #         V = Z / Z[k]
+    #         V = V ** (2/S) + 1.0 / (V ** (2/S))
+    #         Sz[k] = self._gscale_loc(np.sum(2.0 / V * W))
+
+    #     Sx = S * Sz / np.mean(Sz)
+    #     return Sx
+
+    def var_s(self, Z, W=None, S=1):
+        """
+        Calculate a vector of scale parameters for each kernel in the distribution.
+        
+        This method computes individualized scale parameters for each data point, allowing
+        for adaptive scaling in gnostic estimations. It handles numerical edge cases to
+        ensure stability.
+        
+        Parameters
+        ----------
+        Z : array-like
+            Data vector containing the values for which to calculate scale parameters.
+        W : array-like, optional
+            Weight vector for each data point. If not provided, uniform weights are used.
+        S : float, optional
+            Base scalar scale factor, default is 1.
+            
+        Returns
+        -------
+        ndarray
+            Vector of scale parameters, one for each element in Z.
+            
+        Raises
+        ------
+        ValueError
+            If Z and W are provided but have different lengths.
+            
+        Notes
+        -----
+        The method calculates relative relationships between data points and applies
+        the local scale parameter calculation for each point. For each data point k,
+        it computes a ratio V of all data points relative to Z[k], then calculates
+        a transformation of this ratio to determine the local scale parameter.
+        
+        The implementation includes safeguards against division by zero and handles
+        edge cases to ensure numerical stability. In case of invalid calculations,
+        it falls back to the default scale parameter.
+        """
+        self.logger.info("Calculating local scale parameters...")
+        Z = np.asarray(Z).reshape(-1, 1)
+    
+        if W is None:
+            W = np.ones_like(Z) / len(Z)
+        else:
+            W = np.asarray(W).reshape(-1, 1)
+            if len(Z) != len(W):
+                raise ValueError("Z and W must be of the same length")
+            W = W / np.sum(W)
+    
+        Sz = np.zeros_like(Z, dtype=float)
+        
+        # Small value to prevent division by zero
+        eps = np.finfo(float).eps * 100
+    
+        for k in range(len(W)):
+            # Skip calculation if Z[k] is too close to zero
+            if abs(Z[k]) < eps:
+                Sz[k] = S  # Use default S value
+                continue
+                
+            # Safe division with epsilon to prevent division by zero
+            V = Z / (Z[k] + (Z[k]==0)*eps)
+            V = V ** 2 + 1.0 / (V ** 2 + eps)
+            
+            # Calculate sum and ensure it's valid
+            sum_val = np.sum(2.0 / V * W)
+            if np.isnan(sum_val) or np.isinf(sum_val):
+                Sz[k] = S  # Use default S value
+            else:
+                Sz[k] = self._gscale_loc(sum_val)
+        
+        # Check for any remaining NaN values and replace them
+        Sz[np.isnan(Sz)] = S
+        self.logger.info("Local scale parameters calculation complete.")
+        return Sz
+
+    def estimate_global_scale_egdf(self, Fk, Ek, tolerance=0.1):
+        """
+        Estimate the optimal global scale parameter S_optimize to find minimum S where fidelity is maximized.
+        
+        Parameters
+        ----------
+        Fk : array-like
+            Fidelity values for the data points.
+        Ek : array-like
+            Weighted empirical distribution function values for the data points.
+        tolerance : float, optional
+            Convergence tolerance for fidelity change (default is 0.01).
+    
+        Returns
+        -------
+        float
+            The optimal global scale parameter S_optimize (minimum S where fidelity is maximized).
+    
+        Notes
+        -----
+        This function finds the minimum scale parameter S where fidelity is maximized,
+        with early stopping when fidelity change is less than the specified tolerance.
+        """
+        self.logger.info("Estimating global scale parameter...")
+        Fk = np.asarray(Fk)
+        Ek = np.asarray(Ek)
+    
+        if len(Fk) != len(Ek):
+            raise ValueError("Fk and Ek must have the same length.")
+    
+        def compute_fidelity(S):
+            """Compute average fidelity for a given S"""
+            # Add small epsilon to prevent division by zero
+            eps = np.finfo(float).eps
+            term1 = (Fk / (Ek + eps)) ** (2 / S)
+            term2 = (Ek / (Fk + eps)) ** (2 / S)
+            fidelities = 2 / (term1 + term2)
+            return np.mean(fidelities)
+    
+        # Search through S values from minimum to maximum
+        s_values = np.linspace(0.05, 100, 1000)  # Fine grid for accurate search
+        
+        max_fidelity = -np.inf
+        optimal_s = None
+        previous_fidelity = None
+        
+        for s in s_values:
+            current_fidelity = compute_fidelity(s)
+            
+            # Check convergence condition first
+            if previous_fidelity is not None:
+                fidelity_change = abs(current_fidelity - previous_fidelity)
+                if fidelity_change < tolerance:
+                    # Converged - return the minimum S where we achieved max fidelity
+                    if optimal_s is not None:
+                        final_fidelity = compute_fidelity(optimal_s)
+                        print(f"Converged at S={optimal_s:.4f} with fidelity={final_fidelity:.4f}")
+                        return optimal_s
+                    else:
+                        # First iteration, use current S
+                        print(f"Converged at S={s:.4f} with fidelity={current_fidelity:.4f}")
+                        return s
+            
+            # Update maximum fidelity and optimal S (prefer minimum S for same fidelity)
+            if current_fidelity > max_fidelity:
+                max_fidelity = current_fidelity
+                optimal_s = s
+            
+            previous_fidelity = current_fidelity
+        self.logger.info("Global scale parameter estimation complete.")
+        # If no convergence found, return the S with maximum fidelity
+        if optimal_s is not None:
+            final_fidelity = compute_fidelity(optimal_s)
+            self.logger.warning(f"No convergence found. Returning S={optimal_s:.4f} with max fidelity={final_fidelity:.4f}")
+            return optimal_s
+        else:
+            self.logger.error("Failed to find optimal scale parameter.")
+            raise RuntimeError("Failed to find optimal scale parameter.")
+        
+    # def _gscale_loc(self, F):
+    #     '''
+    #     For internal use only
+
+    #     calculates the local scale parameter for given calculated F at Scale = 1.
+    #     S with be in the same shape as F.
+    #     Solve for scale parameter using Newton-Raphson."
+    #     '''
+    #     m2pi = 2 / np.pi
+    #     sqrt2 = np.sqrt(2)
+        
+    #     if F < m2pi * sqrt2 / 3:
+    #         S = np.pi
+    #     elif F < m2pi:
+    #         S = 3 * np.pi / 4
+    #     elif F < m2pi * sqrt2:
+    #         S = np.pi / 2
+    #     else:
+    #         S = np.pi / 4
+
+    #     epsilon = 1e-5
+    #     for _ in range(100):
+    #         delta = (np.sin(S) - S * F) / (np.cos(S) - F)
+    #         S -= delta
+    #         if abs(delta) < epsilon:
+    #             break
+    #     return S * m2pi

machinegnostics/magcal/util/dis_docstring.py

@@ -0,0 +1,18 @@
+def disable_parent_docstring(func):
+    """
+    Decorator to disable (remove) the inherited docstring from a parent class method.
+    After applying this decorator, the function's __doc__ will be set to None.
+
+    Usage:
+
+    ```python
+    @disable_parent_docstring
+    def my_method(self, *args, **kwargs):
+        # Your method implementation here
+        pass
+    ```    
+    This is useful when you want to override a method from a parent class
+    but do not want to inherit its docstring, allowing you to provide a new one or leave it empty.
+    """
+    func.__doc__ = None
+    return func

machinegnostics/magcal/util/logging.py

@@ -0,0 +1,24 @@
+import logging
+
+def get_logger(name: str, level: int = logging.WARNING) -> logging.Logger:
+    """
+    Create and configure a logger with the given name and level.
+
+    Args:
+        name (str): Name of the logger, typically `__name__`.
+        level (int): Logging level (e.g., logging.DEBUG, logging.INFO).
+
+    Returns:
+        logging.Logger: Configured logger instance.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if not logger.hasHandlers():
+        handler = logging.StreamHandler()
+        handler.setLevel(level)
+        formatter = logging.Formatter('%(asctime)s | %(name)s | %(levelname)s | %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    return logger

machinegnostics/magcal/util/min_max_float.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+def np_max_float():
+    """
+    Returns the maximum float value that can be represented in NumPy.
+    
+    Returns
+    -------
+    float
+        The maximum float value.
+    """
+    return np.finfo(float).max
+
+def np_min_float():
+    """
+    Returns the minimum float value that can be represented in NumPy.
+    
+    Returns
+    -------
+    float
+        The minimum float value.
+    """
+    return np.finfo(float).min
+
+def np_eps_float():
+    """
+    Returns the smallest positive float value that can be represented in NumPy.
+    
+    Returns
+    -------
+    float
+        The smallest positive float value.
+    """
+    return np.finfo(float).eps

machinegnostics/metrics/__init__.py

@@ -0,0 +1,28 @@
+# metrics functions
+from machinegnostics.metrics.mae import mean_absolute_error
+from machinegnostics.metrics.rmse import root_mean_squared_error
+from machinegnostics.metrics.mse import mean_squared_error
+from machinegnostics.metrics.r2 import r2_score, adjusted_r2_score
+from machinegnostics.metrics.robr2 import robr2
+from machinegnostics.metrics.gmmfe import gmmfe
+from machinegnostics.metrics.divi import divI
+from machinegnostics.metrics.evalmet import evalMet
+from machinegnostics.metrics.hc import hc
+from machinegnostics.metrics.f1_score import f1_score
+from machinegnostics.metrics.precision import precision_score
+from machinegnostics.metrics.recall import recall_score
+from machinegnostics.metrics.cls_report import classification_report
+from machinegnostics.metrics.accuracy import accuracy_score
+from machinegnostics.metrics.conf_matrix import confusion_matrix
+from machinegnostics.metrics.variance import variance
+from machinegnostics.metrics.auto_covariance import auto_covariance
+from machinegnostics.metrics.cross_variance import cross_covariance
+from machinegnostics.metrics.correlation import correlation
+from machinegnostics.metrics.auto_correlation import auto_correlation
+from machinegnostics.metrics.mean import mean
+from machinegnostics.metrics.median import median
+from machinegnostics.metrics.std import std
+
+
+# class
+from machinegnostics.metrics.mg_r2 import EvaluationMetrics

machinegnostics/metrics/accu.py

@@ -0,0 +1,61 @@
+import numpy as np
+
+def accuracy_score(y_true:np.ndarray, y_pred:np.ndarray) -> float:
+    """
+    Computes the classification accuracy.
+
+    The classification accuracy is the ratio of correctly predicted class labels to the total number of predictions. 
+    It is a commonly used metric for evaluating the performance of classification models. The accuracy score ranges 
+    from 0 to 1, where:
+    - 1 indicates perfect accuracy (all predictions are correct).
+    - 0 indicates no correct predictions.
+
+    Parameters
+    ----------
+    y_true : array-like
+        True class labels. Must be a 1D array-like object (e.g., list, tuple, or numpy array) containing the ground truth labels.
+    y_pred : array-like
+        Predicted class labels. Must be a 1D array-like object (e.g., list, tuple, or numpy array) containing the predicted labels.
+
+    Returns
+    -------
+    float
+        The classification accuracy as a float value between 0 and 1.
+
+    Raises
+    ------
+    ValueError
+        - If `y_true` and `y_pred` have different lengths.
+        - If `y_true` or `y_pred` are empty.
+    TypeError
+        - If `y_true` or `y_pred` are not array-like (e.g., list, tuple, or numpy array).
+
+    Notes
+    -----
+    - The function converts `y_true` and `y_pred` to numpy arrays internally for efficient computation.
+    - The comparison `y_true == y_pred` is performed element-wise, and the mean of the resulting boolean array is computed to determine accuracy.
+
+    - The function does not handle multi-class classification or multi-label classification scenarios. It assumes binary classification.
+
+    - Made for research purposes, and may not be suitable for production use without further validation and testing.
+
+    """
+    # Validate input types
+    if not isinstance(y_true, (list, tuple, np.ndarray)):
+        raise TypeError("y_true must be array-like (list, tuple, or numpy array).")
+    if not isinstance(y_pred, (list, tuple, np.ndarray)):
+        raise TypeError("y_pred must be array-like (list, tuple, or numpy array).")
+
+    # Convert to numpy arrays and flatten
+    y_true = np.asarray(y_true).flatten()
+    y_pred = np.asarray(y_pred).flatten()
+
+    # Check for matching shapes
+    if y_true.shape != y_pred.shape:
+        raise ValueError(f"Shape mismatch: y_true shape {y_true.shape} != y_pred shape {y_pred.shape}")
+
+    # Check for empty arrays
+    if y_true.size == 0:
+        raise ValueError("y_true and y_pred must not be empty.")
+
+    return float(np.mean(y_true == y_pred))