machinegnostics 0.0.1__py3-none-any.whl

machinegnostics/models/classification/layer_mlflow_log_reg.py

@@ -0,0 +1,107 @@
+'''
+ManGo - 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-10-01
+Description: Machine Gnostics logic for robust regression model and wrapping it with mlflow
+'''
+
+import os
+import joblib
+import mlflow
+import numpy as np
+from machinegnostics.models.classification.layer_history_log_reg import HistoryRobustRegressor
+
+class InterfaceLogisticRegressor(HistoryRobustRegressor, mlflow.pyfunc.PythonModel):
+    """
+    _LogisticRegressor: MLflow-wrapped Gnostic Logistic Regression
+
+    Developer Notes:
+    ----------------
+    - Inherits from _LogisticRegressorParamBase for core logic and mlflow.pyfunc.PythonModel for MLflow integration.
+    - Supports saving/loading via joblib for reproducibility and deployment.
+    - Handles numpy arrays, pandas DataFrames, and pyspark DataFrames for prediction.
+    - Use fit(X, y) for training and predict(X) or predict_proba(X) for inference.
+    - Use save_model(path) and load_model(path) for model persistence.
+    """
+    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
+
+        # logger
+        self.logger.info("InterfaceLogisticRegressor initialized.")
+
+
+    def _fit(self, X, y):
+        """
+        Fit the logistic regression model using the parent class logic.
+        """
+        self.logger.info("Starting fit process for InterfaceLogisticRegressor.")
+        super()._fit(X, y)
+
+        self.coefficients = self.coefficients
+        self.weights = self.weights
+        return self
+
+    def _predict(self, model_input) -> np.ndarray:
+        """
+        Predict class labels for input data.
+        Accepts numpy arrays, pandas DataFrames, or pyspark DataFrames.
+        """
+        self.logger.info("Making predictions with InterfaceLogisticRegressor.")
+        return super()._predict(model_input)
+
+    def _predict_proba(self, model_input) -> np.ndarray:
+        """
+        Predict probabilities for input data.
+        Accepts numpy arrays, pandas DataFrames, or pyspark DataFrames.
+        """
+        self.logger.info("Calculating predicted probabilities with InterfaceLogisticRegressor.")
+        return super()._predict_proba(model_input)
+
+    def save_model(self, path):
+        """
+        Save the trained model to disk using joblib.
+        """
+        self.logger.info(f"Saving model to {path}.")
+        os.makedirs(path, exist_ok=True)
+        joblib.dump(self, os.path.join(path, "model.pkl"))
+
+    @classmethod
+    def load_model(cls, path):
+        """
+        Load a trained model from disk using joblib.
+        """
+        return joblib.load(os.path.join(path, "model.pkl"))

machinegnostics/models/classification/layer_param_log_reg.py

@@ -0,0 +1,275 @@
+'''
+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 classification models.
+- logical 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
+
+class ParamLogisticRegressorBase(ParamBase):
+    """
+    Parameters for the Logistic 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,
+                 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.proba = proba
+        self.mg_loss = 'hi'
+        # history option
+        if history:
+            self._history = []
+            # default history content
+            self._history.append({
+                'iteration': 0,
+                'log_loss': None,
+                'coefficients': None,
+                'rentropy': None,
+                'weights': None,
+            })
+        else:
+            self._history = None
+
+        # logger
+        self.logger.info("ParamLogisticRegressorBase 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 Logistic Regressor.")
+        # Generate polynomial features
+        X_poly = self._generate_polynomial_features(X)
+
+        n_samples, n_features = X_poly.shape
+        
+        # Initialize weights
+        self.weights = np.ones(n_samples)
+        
+        # Initialize coefficients to zeros
+        self.coefficients = np.zeros(n_features)
+        
+        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 = self._data_conversion(residuals)
+                z_y = self._data_conversion(y)
+                z_y0 = self._data_conversion(y0)
+
+                # gnostic weights
+                gw = GnosticsWeights()
+                gw = gw._get_gnostic_weights(z)
+                new_weights = self.weights * gw
+                W = np.diag(new_weights)
+
+                # Compute scale and loss
+                if self.scale == 'auto':
+                    scale = ScaleParam()
+                    zz = z_y0 - z_y
+                    # 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
+                
+                # gnostic probabilities
+                if self.proba == 'gnostic':
+                    # Gnostic probability calculation
+                    p, info, re = self._gnostic_prob(z=z) # NOTE currently using p from local S, means ELDF. this can be improved in the future
+                elif self.proba == 'sigmoid':
+                    # Sigmoid probability calculation
+                    p = self._sigmoid(y0)
+                    _, info, re = self._gnostic_prob(z=z)
+
+                # self.coefficients = self._wighted_least_squares_log_reg(p, 
+                #                                                         y0, 
+                #                                                         X_poly,
+                #                                                         y, 
+                #                                                         W=W, 
+                #                                                         n_features=n_features, 
+                #                                                         )
+                # IRLS update
+                try:
+                    XtW = X_poly.T @ W
+                    XtWX = XtW @ X_poly + 1e-8 * np.eye(n_features)
+                    XtWy = XtW @ (y0 + (y - p) / (p * (1 - p) + 1e-8))
+                    self.coefficients = np.linalg.solve(XtWX, XtWy)
+                except np.linalg.LinAlgError:
+                    self.coefficients = np.linalg.pinv(XtWX) @ XtWy
+
+                # --- Log loss calculation ---
+                proba_pred = np.clip(p, 1e-8, 1-1e-8)
+                self.log_loss = -np.mean(y * np.log(proba_pred) + (1 - y) * np.log(1 - proba_pred))
+
+                # history update for gnostic vs sigmoid
+                re = np.mean(re)
+                info = np.mean(info)
+
+                if self.gnostic_characteristics:
+                    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
+
+                
+                # capture history and append to history
+                # minimal history capture
+                if self._history is not None:
+                    self._history.append({
+                        'iteration': self._iter,
+                        'log_loss': self.log_loss,
+                        'coefficients': self.coefficients.copy(),
+                        'rentropy': re,
+                        'weights': self.weights.copy(),
+                    })
+
+                # Check convergence with early stopping and rentropy
+                # if entropy value is increasing, stop
+                
+                # --- Unified convergence check: stop if mean rentropy or log_loss change is within tolerance ---
+                if self._iter > 0 and self.early_stopping:
+                    prev_hist = self._history[-2] if len(self._history) > 1 else None
+                    curr_re = np.mean(re)
+                    curr_log_loss = self.log_loss
+                    prev_re_val = np.mean(prev_hist['rentropy']) if prev_hist and prev_hist['rentropy'] is not None else None
+                    prev_log_loss_val = prev_hist['log_loss'] if prev_hist and prev_hist['log_loss'] is not None else None
+
+                    re_converged = prev_re_val is not None and np.abs(curr_re - prev_re_val) < self.tol
+                    log_loss_converged = prev_log_loss_val is not None and np.abs(curr_log_loss - prev_log_loss_val) < self.tol
+
+                    if re_converged or log_loss_converged:
+                        if self.verbose:
+                            self.logger.info(f"Converged at iteration {self._iter} (early stop):")
+                            if re_converged:
+                                self.logger.info(f"mean rentropy change below tolerance (rentropy={np.abs(curr_re - prev_re_val):.6e}).")
+                            if log_loss_converged:
+                                self.logger.info(f"log_loss change below tolerance (log_loss={np.abs(curr_log_loss - prev_log_loss_val):.6e}).")
+                        break
+                if self.verbose:
+                    self.logger.info(f"Iteration {self._iter}, Log Loss: {self.log_loss:.6f}, mean residual entropy: {np.mean(re):.6f}")
+
+            except (ZeroDivisionError, np.linalg.LinAlgError) as e:
+                # Handle exceptions during fitting
+                self.coefficients = self._prev_coef
+                self.weights = self.weights.copy()
+                if self.verbose:
+                    self.logger.error(f"Error during fitting at iteration {self._iter}: {e}")
+                break         
+
+    def _predict(self, X: np.ndarray, threshold=0.5) -> np.ndarray:
+        """
+        Predict class labels for the input data.
+        
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Input features to predict class labels for.
+        threshold : float, optional (default=0.5)
+            Threshold for classifying probabilities into binary classes.
+            
+        Returns
+        -------
+        ndarray of shape (n_samples,)
+            Predicted class labels (0 or 1).
+        """
+        self.logger.info("Making predictions with Logistic Regressor.")
+        proba = self._predict_proba(X)
+        return (proba >= threshold).astype(int)  
+    
+    def _predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """
+        Predict probabilities for the input data.
+        
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Input features to predict probabilities for.
+            
+        Returns
+        -------
+        ndarray of shape (n_samples,)
+            Predicted probabilities.
+        """
+        self.logger.info("Calculating predicted probabilities with Logistic Regressor.")
+        if self.coefficients is None:
+            raise ValueError("Model is not fitted yet. Call 'fit' before 'predict_proba'.")
+        
+        X_poly = self._generate_polynomial_features(X)
+        linear_pred = X_poly @ self.coefficients
+        
+        # gnostic vs sigmoid probability calculation
+        if self.proba == 'gnostic':
+            # Gnostic probability calculation
+            proba, info, re = self._gnostic_prob(-linear_pred)
+        elif self.proba == 'sigmoid':
+            # Sigmoid probability calculation
+            proba = self._sigmoid(linear_pred)
+        else:
+            self.logger.error("Invalid probability method. Must be 'gnostic' or 'sigmoid'.")
+            raise ValueError("Invalid probability method. Must be 'gnostic' or 'sigmoid'.")
+        
+        return proba

machinegnostics/models/classification/mg_log_reg.py

@@ -0,0 +1,273 @@
+'''
+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 logistic regression model using mathematical gnostics principles.
+'''
+
+import numpy as np
+import pandas as pd
+from machinegnostics.models.classification.layer_io_process_log_reg import DataProcessLogisticRegressor
+from machinegnostics.metrics import f1_score
+from machinegnostics.magcal import disable_parent_docstring
+from typing import Union
+
+class LogisticRegressor(DataProcessLogisticRegressor):
+    """
+    LogisticRegressor implements a logistic regression model based on Mathematical Gnostics principles.
+
+    This class prepared with Machine Gnostic framework, feature-rich logistic regression
+    implementation. It supports polynomial feature expansion, custom loss functions, early stopping, 
+    gnostic-based probability estimation, and detailed training history tracking.
+
+    Key Features:
+        - Polynomial feature expansion up to a user-specified degree.
+        - Choice of probability estimation method: 'gnostic' (default) or standard 'sigmoid'.
+        - Calculation of gnostic characteristics for advanced model diagnostics.
+        - Early stopping based on convergence of loss or entropy.
+        - Verbose logging for monitoring training progress.
+        - Optional scaling and data processing modes.
+        - Maintains a history of model parameters and losses for analysis.
+
+    Parameters
+    ----------
+    degree : int, default=1
+        Degree of polynomial features to use for input expansion.
+    max_iter : int, default=100
+        Maximum number of iterations for the optimization algorithm.
+    tol : float, default=1e-3
+        Tolerance for convergence. Training stops if the change in loss or entropy is below this value.
+    mg_loss : str, default='hi'
+        Type of gnostic loss to use (e.g., 'hi', 'hj', etc.).
+    early_stopping : bool, default=True
+        Whether to stop training early if convergence is detected.
+    verbose : bool, default=False
+        If True, prints detailed logs during training.
+    scale : str | int | float, default='auto'
+        Scaling method for input features. Can be a string identifier or a numeric value.
+    data_form : str, default='a'
+        Data processing form: 'a' for additive, 'm' for multiplicative.
+    gnostic_characteristics : bool, default=True
+        If True, calculates and stores gnostic characteristics during training.
+    history : bool, default=True
+        If True, maintains a history of model parameters and losses.
+    proba : str, default='gnostic'
+        Probability estimation method: 'gnostic' for gnostic-based, 'sigmoid' for standard logistic regression.
+
+    Attributes
+    ----------
+    coefficients : np.ndarray
+        Fitted model coefficients after training.
+    weights : np.ndarray
+        Sample weights used during training.
+    _history : list
+        List of dictionaries containing training history (loss, coefficients, entropy, etc.).
+    params : list
+        List of model parameters (for compatibility and inspection).
+
+    Methods
+    -------
+    fit(X, y)
+        Fit the logistic regression model to the data.
+    predict(model_input)
+        Predict class labels for new data.
+    predict_proba(model_input)
+        Predict class probabilities for new data.
+    score(X, y)
+        Compute the F1 score of the model on given data.
+
+    Examples
+    --------
+    >>> from machinegnostics.models.classification.mg_log_reg import LogisticRegressor
+    >>> model = LogisticRegressor(degree=2, max_iter=200, verbose=True)
+    >>> model.fit(X_train, y_train)
+    >>> y_pred = model.predict(X_test)
+    >>> print("F1 Score:", model.score(X_test, y_test))
+
+    Notes
+    -----
+    - The model supports both binary and multiclass classification tasks.
+    - More information on gnostic characteristics can be found in the Machine Gnostics documentation.
+    - For more information, visit: https://machinegnostics.info/
+    """
+    
+    @disable_parent_docstring
+    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,
+                 proba:str = 'gnostic'):
+        """
+        Initialize the LogisticRegressor with specified parameters.
+
+        Parameters:
+            - degree: Degree of polynomial features.
+            - max_iter: Maximum number of iterations for convergence.
+            - tol: Tolerance for stopping criteria.
+            - early_stopping: Whether to stop training early if convergence is reached.
+            - verbose: Whether to print detailed logs during training.
+            - scale: Scaling method for input features.
+            - data_form: Form of data processing ('a' for additive, 'm' for multiplicative).
+            - gnostic_characteristics: Whether to calculate gnostic characteristics.
+            - history: Whether to maintain a history of model parameters and losses.
+            - proba: Probability estimation method ('gnostic' or 'sigmoid').
+        
+        """
+        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,
+            proba=proba
+        )
+        
+        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
+        self.history = history
+        self.proba = proba
+        self.params = []
+        self._history = []
+
+        # logger
+        self.logger.info("LogisticRegressor initialized.")
+    
+    def fit(self, X, y):
+        """
+        Fit the LogisticRegressor model to the training data.
+
+        This method trains the logistic regression model using the provided input features and target labels.
+        It supports polynomial feature expansion, gnostic or sigmoid probability estimation, and early stopping
+        based on convergence criteria. Training history, including loss and coefficients, is stored if enabled.
+
+        Parameters
+        ----------
+        X : array-like or DataFrame
+            Input features for training. Can be a NumPy array, pandas DataFrame, or compatible type.
+        y : array-like
+            Target labels for training. Should be a 1D array or Series of binary class labels (0 or 1).
+
+        Returns
+        -------
+        self : LogisticRegressor
+            Returns the fitted model instance for chaining.
+        
+        Raises
+        ------
+        ValueError
+            If input shapes are incompatible or training fails due to numerical issues.
+
+        Examples
+        --------
+        >>> model = LogisticRegressor(degree=2, max_iter=200)
+        >>> model.fit(X_train, y_train)
+        """
+        self.logger.info("Starting fit process for LogisticRegressor.")
+        super()._fit(X, y)
+        
+        self.coefficients = self.coefficients
+        self.weights = self.weights
+        return self
+    
+    def predict(self, model_input) -> np.ndarray:
+        """
+        Predict class labels for new input data.
+
+        This method predicts binary class labels (0 or 1) for the provided input data using the trained model.
+        It supports input as NumPy arrays, pandas DataFrames, or PySpark DataFrames (if supported by the parent class).
+        The prediction threshold is typically 0.5 unless otherwise specified in the parent class.
+
+        Parameters
+        ----------
+        model_input : array-like or DataFrame
+            Input data for prediction. Can be a NumPy array, pandas DataFrame, or compatible type.
+
+        Returns
+        -------
+        np.ndarray
+            Array of predicted class labels (0 or 1).
+
+        Examples
+        --------
+        >>> y_pred = model.predict(X_test)
+        """
+        self.logger.info("Making predictions with LogisticRegressor.")
+        return super()._predict(model_input)
+    
+    def predict_proba(self, model_input) -> np.ndarray:
+        """
+        Predict class probabilities for new input data.
+
+        This method returns the predicted probabilities for each input sample belonging to the positive class (label 1).
+        It supports input as NumPy arrays, pandas DataFrames, or PySpark DataFrames (if supported by the parent class).
+        The probability estimation method is determined by the `proba` parameter set during initialization
+        ('gnostic' for gnostic-based probabilities or 'sigmoid' for standard logistic regression probabilities).
+
+        Parameters
+        ----------
+        model_input : array-like or DataFrame
+            Input data for probability prediction. Can be a NumPy array, pandas DataFrame, or compatible type.
+
+        Returns
+        -------
+        np.ndarray
+            Array of predicted probabilities for the positive class (values between 0 and 1).
+
+        Examples
+        --------
+        >>> y_proba = model.predict_proba(X_test)
+        >>> print(y_proba[:5])
+        """
+        self.logger.info("Calculating predicted probabilities with LogisticRegressor.")
+        return super()._predict_proba(model_input)
+
+    def score(self, X, y) -> float:
+        """
+        Compute the F1 score of the model on the provided test data.
+
+        This method evaluates the performance of the trained model by computing the F1 score,
+        which is the harmonic mean of precision and recall, on the given input features and true labels.
+
+        Parameters
+        ----------
+        X : array-like or DataFrame
+            Input features for evaluation.
+        y : array-like
+            True binary labels for evaluation.
+
+        Returns
+        -------
+        float
+            F1 score of the model predictions on the provided data.
+
+        Examples
+        --------
+        >>> score = model.score(X_test, y_test)
+        >>> print("F1 Score:", score)
+        """
+        self.logger.info("Calculating F1 score for LogisticRegressor.")
+        y_pred = self.predict(X)
+        return f1_score(y, y_pred)