machinegnostics 0.0.1__py3-none-any.whl

machinegnostics/models/regression/layer_param_rob_reg.py

@@ -0,0 +1,212 @@
+'''
+Machine Gnostics - Machine Gnostics Library
+Copyright (C) 2025  Machine Gnostics Team
+
+This work is licensed under the terms of the GNU General Public License version 3.0.
+
+Author: Nirmal Parmar
+Date: 2025-05-31
+
+Description:
+Regressor param base class that can be used for robust regression models.
+- linear regression
+- polynomial regression
+
+'''
+
+import numpy as np
+from machinegnostics.magcal import (ScaleParam, 
+                                    GnosticsWeights, 
+                                    ParamBase)
+from machinegnostics.magcal.util.min_max_float import np_max_float, np_min_float
+import logging
+
+class ParamRobustRegressorBase(ParamBase):
+    """
+    Parameters for the Robust Regressor model.
+    
+    Attributes
+    ----------
+    scale_param : ScaleParam
+        Scaling parameters for the model.
+    gnostics_weights : GnosticsWeights
+        Weights for the model.
+    """
+    
+    def __init__(self,
+                 degree: int = 1,
+                 max_iter: int = 100,
+                 tol: float = 1e-3,
+                 mg_loss: str = 'hi',
+                 early_stopping: bool = True,
+                 verbose: bool = False,
+                 scale: 'str | int | float' = 'auto',
+                 data_form: str = 'a',
+                 gnostic_characteristics:bool=True,
+                 history: bool = True):
+        super().__init__(
+            degree=degree,
+            max_iter=max_iter,
+            tol=tol,
+            mg_loss=mg_loss,
+            early_stopping=early_stopping,
+            verbose=verbose,
+            scale=scale,
+            data_form=data_form,
+            gnostic_characteristics=gnostic_characteristics
+        )
+        self.degree = degree
+        self.max_iter = max_iter
+        self.tol = tol
+        self.mg_loss = mg_loss
+        self.early_stopping = early_stopping
+        self.verbose = verbose
+        self.scale = scale
+        self.data_form = data_form
+        self.gnostic_characteristics = gnostic_characteristics
+        # history option
+        if history:
+            self._history = []
+            # default history content
+            self._history.append({
+                'iteration': 0,
+                'h_loss': None,
+                'coefficients': None,
+                'rentropy': None,
+                'weights': None,
+            })
+        else:
+            self._history = None
+        
+        self.logger.info("ParamRobustRegressorBase initialized.")
+    
+    def _fit(self, X: np.ndarray, y: np.ndarray):
+        """
+        Fit the model to the data.
+        
+        Parameters
+        ----------
+        X : np.ndarray
+            Input features.
+        y : np.ndarray
+            Target values.
+        """
+        self.logger.info("Starting fit process for ParamRobustRegressorBase.")
+        # Generate polynomial features
+        X_poly = self._generate_polynomial_features(X)
+        
+        # Initialize weights
+        self.weights = self._weight_init(d=y, like='one')
+        
+        # Initialize coefficients to zeros
+        self.coefficients = np.zeros(X_poly.shape[1])
+        
+        for self._iter in range(self.max_iter):
+            self._iter += 1
+            self._prev_coef = self.coefficients.copy()
+            
+            try:
+                # Weighted least squares
+                self.coefficients = self._weighted_least_squares(X_poly, y, self.weights)
+                
+                # Update weights using gnostic approach
+                y0 = X_poly @ self.coefficients
+                residuals = y0 - y
+                
+                # mg data conversion                
+                z_y = self._data_conversion(y)
+                z_y0 = self._data_conversion(y0)
+                zz = z_y0 / z_y
+                z = self._data_conversion(residuals)
+
+                # gnostic weights
+                gw = GnosticsWeights()
+                gw = gw._get_gnostic_weights(z)
+                new_weights = self.weights * gw
+
+                # Compute scale and loss
+                if self.scale == 'auto':
+                    scale = ScaleParam()
+                    # avoid division by zero
+                    zz = np.where(zz == 0, np_min_float(), zz)  # Replace zero with a very small value
+                    # local scale 
+                    s = scale._gscale_loc((2 / (zz + 1/zz)))
+                else:
+                    s = self.scale
+                # NOTE z, z_y z_y0 gives different results
+                # z and z_y gives good results
+                self.loss, self.re, self.hi, self.hj, self.fi, self.fj, \
+                self.pi, self.pj, self.ei, self.ej, self.infoi, self.infoj  = self._gnostic_criterion(z=z_y0, z0=z_y, s=s)
+
+                self.weights = new_weights / np.sum(new_weights) # NOTE : Normalizing weights
+                                                
+                # print loss
+                if self.verbose:
+                    self.logger.info(f'Iteration: {self._iter} - Machine Gnostic loss - {self.mg_loss} : {np.round(self.loss, 4)}, rentropy: {np.round(self.re, 4)}')
+
+                # capture history and append to history
+                # minimal history capture
+                if self._history is not None:
+                    self._history.append({
+                        'iteration': self._iter,
+                        'h_loss': self.loss,
+                        'coefficients': self.coefficients.copy(),
+                        'rentropy': self.re,
+                        'weights': self.weights.copy()
+                    })
+
+                # Check convergence with early stopping and rentropy
+                # if entropy value is increasing, stop
+                if self.early_stopping and self._history is not None:
+                    if len(self._history) > 1:
+                        prev_loss = self._history[-2]['h_loss']
+                        prev_re = self._history[-2]['rentropy']
+                        if (prev_loss is not None) and (prev_re is not None):
+                            if (np.abs(self.loss - prev_loss) < self.tol) or (np.abs(self.re - prev_re) < self.tol):
+                                if self.verbose:
+                                    self.logger.info(f"Convergence reached at iteration {self._iter} with loss/rentropy change below tolerance.")
+                                break
+            
+            except (ZeroDivisionError, np.linalg.LinAlgError) as e:
+                if self.verbose:
+                    self.logger.warning(f"Warning: {str(e)}. Using previous coefficients.")
+                self.coefficients = self._prev_coef
+                break
+
+    def _predict(self, X: np.ndarray) -> np.ndarray:
+        """
+        Internal prediction method for base class.
+        
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Input features to predict for.
+            
+        Returns
+        -------
+        ndarray of shape (n_samples,)
+            Predicted values.
+        """ 
+        self.logger.info("Starting prediction for ParamRobustRegressorBase.")
+        # copy iteration for last iteration
+        
+        if self.coefficients is None:
+            self.logger.error("Model has not been fitted yet.")
+            raise ValueError("Model has not been fitted yet.")
+        
+        # Process input and generate features
+        X_poly = self._generate_polynomial_features(X)
+        
+        # Validate dimensions
+        n_features_model = X_poly.shape[1]
+        if n_features_model != len(self.coefficients):
+            self.logger.error(
+                f"Feature dimension mismatch. Model expects {len(self.coefficients)} "
+                f"features but got {n_features_model} after polynomial expansion."
+            )
+            raise ValueError(
+                f"Feature dimension mismatch. Model expects {len(self.coefficients)} "
+                f"features but got {n_features_model} after polynomial expansion."
+            )
+        
+        return X_poly @ self.coefficients

machinegnostics/models/regression/mg_lin_reg.py

@@ -0,0 +1,253 @@
+'''
+Machine Gnostics - Machine Gnostics Library
+Copyright (C) 2025  Machine Gnostics Team
+
+This work is licensed under the terms of the GNU General Public License version 3.0.
+
+Author: Nirmal Parmar
+
+Description:
+This module implements a robust linear regression model using mathematical gnostics principles.
+
+'''
+
+import numpy as np
+from machinegnostics.models.regression.layer_io_process_rob_rig import DataProcessRobustRegressor
+from machinegnostics.metrics import robr2
+from machinegnostics.magcal import disable_parent_docstring
+
+class LinearRegressor(DataProcessRobustRegressor):
+    """
+    Robust Linear Regression using Mathematical Gnostics principles.
+
+    This regressor fits a linear model to data using robust, gnostic loss functions
+    and adaptive sample weights. It is designed to be resilient to outliers and non-Gaussian noise,
+    making it suitable for scientific and engineering applications where data quality may vary.
+
+    Key Features
+    ------------
+    - Robust to outliers: Uses gnostic loss functions and adaptive sample weights.
+    - Iterative optimization: Supports early stopping and convergence tolerance.
+    - Tracks detailed history: Optionally records loss, weights, entropy, and gnostic characteristics at each iteration.
+    - Compatible with numpy arrays for input/output.
+
+    Parameters
+    ----------
+    scale : {'auto', int, float}, default='auto'
+        Scaling method or value for input features.
+    max_iter : int, default=100
+        Maximum number of optimization iterations.
+    tol : float, default=1e-8
+        Tolerance for convergence.
+    mg_loss : str, default='hi'
+        Loss function to use ('hi', 'fi', etc.).
+    early_stopping : bool, default=True
+        Whether to stop early if convergence is detected.
+    verbose : bool, default=False
+        If True, prints progress and diagnostics during fitting.
+    data_form : str, default='a'
+        Internal data representation format.
+    gnostic_characteristics : bool, default=True
+        If True, computes and records gnostic properties (fi, hi, etc.).
+    history : bool, default=True
+        If True, records the optimization history for analysis.
+
+    Attributes
+    ----------
+    coefficients : np.ndarray
+        Fitted linear coefficients.
+    weights : np.ndarray
+        Final sample weights after robust fitting.
+    params : list of dict
+        List of parameter snapshots (loss, weights, gnostic properties) at each iteration.
+    _history : list
+        Internal optimization history (if enabled).
+    All configuration parameters as set at initialization.
+
+    Methods
+    -------
+    fit(X, y)
+        Fit the linear regressor to input features X and targets y.
+    predict(X)
+        Predict target values for new input features X.
+    score(X, y, case='i')
+        Compute the robust R2 score for input features X and true targets y.
+
+    Example
+    -------
+    >>> from machinegnostics.models.regression import LinearRegressor
+    >>> model = LinearRegressor(max_iter=100, verbose=True)
+    >>> model.fit(X_train, y_train)
+    >>> y_pred = model.predict(X_test)
+    >>> r2 = model.score(X_test, y_test)
+
+    Notes
+    -----
+    - This model is part of the Machine Gnostics library, which implements advanced machine learning techniques
+      based on mathematical gnostics principles.
+    - For more information, visit: https://machinegnostics.info/
+    """
+    @disable_parent_docstring
+    def __init__(
+        self, 
+        scale: str | int | float = 'auto',
+        max_iter: int = 100,
+        tol: float = 1e-3,
+        mg_loss: str = 'hi',
+        early_stopping: bool = True,
+        verbose: bool = False,
+        data_form: str = 'a',
+        gnostic_characteristics: bool = True,
+        history: bool = True
+    ):
+        """
+        Initialize a LinearRegressor instance with robust, gnostic regression settings.
+
+        Parameters
+        ----------
+        scale : {'auto', int, float}, default='auto'
+            Scaling method or value for input features.
+        max_iter : int, default=100
+            Maximum number of optimization iterations.
+        tol : float, default=1e-8
+            Tolerance for convergence.
+        mg_loss : str, default='hi'
+            Loss function to use ('hi', 'fi', etc.).
+        early_stopping : bool, default=True
+            Whether to stop early if convergence is detected.
+        verbose : bool, default=False
+            If True, prints progress and diagnostics during fitting.
+        data_form : str, default='a'
+            Internal data representation format.
+        gnostic_characteristics : bool, default=True
+            If True, computes and records gnostic properties (fi, hi, etc.).
+        history : bool, default=True
+            If True, records the optimization history for analysis.
+
+        Notes
+        -----
+        All configuration parameters are stored as attributes for later reference.
+        """
+        super().__init__(
+            max_iter=max_iter,
+            tol=tol,
+            mg_loss=mg_loss,
+            early_stopping=early_stopping,
+            verbose=verbose,
+            scale=scale,
+            data_form=data_form,
+            gnostic_characteristics=gnostic_characteristics,
+            history=history
+        )
+        # # Optionally, set self.degree here as well for safety:
+        self.degree = 1  # Default to linear regression
+        self.max_iter = max_iter
+        self.tol = tol
+        self.mg_loss = mg_loss
+        self.early_stopping = early_stopping
+        self.verbose = verbose
+        self.scale = scale
+        self.data_form = data_form
+        self.gnostic_characteristics = gnostic_characteristics
+        self._record_history = history
+        self.params = []
+        # history option
+        if history:
+            self._history = []
+        else:
+            self._history = None
+        
+        # logger
+        self.logger.info("LinearRegressor initialized.")
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """
+        Fit the robust linear regressor model to the provided data.
+
+        This method performs robust linear regression using the specified gnostic loss function,
+        iteratively optimizing the model coefficients and sample weights to minimize the influence of outliers.
+        If history tracking is enabled, it records loss, weights, and gnostic properties at each iteration.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            Input features of shape (n_samples, n_features).
+        y : np.ndarray
+            Target values of shape (n_samples,).
+
+        Returns
+        -------
+        self : LinearRegressor
+            Returns the fitted model instance for chaining or further use.
+
+        Notes
+        -----
+        - After fitting, the model's coefficients and sample weights are available in the `coefficients` and `weights` attributes.
+        - If `history=True`, the optimization history is available in the `params` and `_history` attributes.
+
+        Example
+        -------
+        >>> model = LinearRegressor(max_iter=100, verbose=True)
+        >>> model.fit(X_train, y_train)
+        >>> print(model.coefficients)
+        >>> print(model.weights)
+        """
+        self.logger.info("Starting fit process for LinearRegressor.")
+        # Call the fit method from DataProcessRobustRegressor
+        super()._fit(X, y)
+    
+    def predict(self, model_input: np.ndarray) -> np.ndarray:
+        """
+        Predict target values using the fitted linear regressor model.
+
+        Parameters
+        ----------
+        model_input : np.ndarray
+            Input features for prediction, shape (n_samples, n_features).
+
+        Returns
+        -------
+        y_pred : np.ndarray
+            Predicted target values, shape (n_samples,).
+
+        Example
+        -------
+        >>> model = LinearRegressor(max_iter=100, verbose=True)
+        >>> model.fit(X_train, y_train)
+        >>> y_pred = model.predict(X_test)
+        """
+        self.logger.info("Making predictions with LinearRegressor.")
+        # Call the predict method from DataProcessRobustRegressor
+        return super()._predict(model_input)
+    
+    def score(self, X: np.ndarray, y: np.ndarray, case:str = 'i') -> float:
+        """
+        Compute the robust (gnostic) R2 score for the linear regressor model.
+
+        Parameters
+        ----------
+        X : np.ndarray
+            Input features for scoring, shape (n_samples, n_features).
+        y : np.ndarray
+            True target values, shape (n_samples,).
+        case : str, default='i'
+            Specifies the case or variant of the R2 score to compute.
+
+        Returns
+        -------
+        score : float
+            Robust R2 score of the model on the provided data.
+        
+        Example
+        -------
+        >>> model = LinearRegressor(max_iter=100, verbose=True)
+        >>> model.fit(X_train, y_train)
+        >>> r2 = model.score(X_test, y_test)
+        >>> print(f"Robust R2 score: {r2}")
+        """
+        self.logger.info("Calculating robust R2 score with LinearRegressor.")
+        # prediction
+        y_pred = self.predict(X)
+        # Call the score method from DataProcessRobustRegressor
+        r2 = robr2(y, y_pred, w=self.weights)
+        return r2