machinegnostics 0.0.1__py3-none-any.whl

machinegnostics/models/cross_validation.py

@@ -0,0 +1,118 @@
+import numpy as np
+import logging
+from machinegnostics.magcal.util.logging import get_logger
+
+class CrossValidator:
+    """
+    A custom implementation of k-Fold Cross-Validation for evaluating machine learning models.
+
+    Parameters
+    ----------
+    model : object
+        A machine learning model that implements `fit(X, y)` and `predict(X)` methods.
+        
+    X : array-like of shape (n_samples, n_features)
+        Feature matrix.
+
+    y : array-like of shape (n_samples,)
+        Target labels.
+
+    k : int, default=5
+        Number of folds to use in cross-validation.
+
+    shuffle : bool, default=True
+        Whether to shuffle the dataset before splitting into folds.
+
+    random_seed : int or None, default=None
+        Seed used to shuffle the data. Ignored if `shuffle=False`.
+    
+    verbose : bool, default=False
+        If True, enables detailed logging.
+
+    Attributes
+    ----------
+    folds : list of tuple
+        List of (train_indices, test_indices) for each fold.
+
+    Example
+    -------
+    >>> from machinegnostics.models import CrossValidator
+    >>> from machinegnostics.models import LinearRegressor
+    >>> from sklearn.metrics import mean_squared_error
+    >>> X = np.random.rand(100, 10)
+    >>> y = np.random.rand(100)
+    >>> model = LinearRegression()
+    >>> cv = CrossValidator(model, X, y, k=5, shuffle=True, random_seed=42)
+    >>> scores = cv.evaluate(mean_squared_error)
+    >>> print("Cross-Validation Scores:", scores)
+    >>> print("Mean Score:", np.mean(scores))
+    """
+
+    def __init__(self, model , X:np.ndarray, y:np.ndarray, k=5, shuffle=True, random_seed=None, verbose: bool = False):
+        self.model = model
+        self.X = np.array(X)
+        self.y = np.array(y)
+        self.k = k
+        self.shuffle = shuffle
+        self.random_seed = random_seed
+        self.verbose = verbose
+
+        self.logger = get_logger('CrossValidator', level=logging.WARNING if not verbose else logging.INFO)
+
+    def split(self):
+        """
+        Split the dataset into k folds.
+
+        Returns
+        -------
+        folds : list of tuple
+            A list of (train_indices, test_indices) for each fold.
+        """
+        self.logger.info("Starting k-Fold split...")
+        n_samples = len(self.X)
+        indices = np.arange(n_samples)
+
+        if self.shuffle:
+            rng = np.random.default_rng(self.random_seed)
+            rng.shuffle(indices)
+
+        fold_sizes = np.full(self.k, n_samples // self.k, dtype=int)
+        fold_sizes[:n_samples % self.k] += 1
+
+        current = 0
+        folds = []
+        for fold_size in fold_sizes:
+            start, stop = current, current + fold_size
+            test_idx = indices[start:stop]
+            train_idx = np.concatenate([indices[:start], indices[stop:]])
+            folds.append((train_idx, test_idx))
+            current = stop
+        self.logger.info("Completed k-Fold split.")
+        return folds
+
+    def evaluate(self, scoring_func):
+        """
+        Perform k-fold cross-validation and return the evaluation scores.
+
+        Parameters
+        ----------
+        scoring_func : callable
+            A function that takes `y_true` and `y_pred` and returns a numeric score (e.g., accuracy_score).
+
+        Returns
+        -------
+        scores : list of float
+            Evaluation scores for each fold.
+        """
+        self.logger.info("Starting cross-validation evaluation...")
+        scores = []
+        for train_idx, test_idx in self.split():
+            X_train, y_train = self.X[train_idx], self.y[train_idx]
+            X_test, y_test = self.X[test_idx], self.y[test_idx]
+
+            self.model.fit(X_train, y_train)
+            y_pred = self.model.predict(X_test)
+            score = scoring_func(y_test, y_pred)
+            scores.append(score)
+        self.logger.info("Completed cross-validation evaluation.")
+        return scores

machinegnostics/models/data_split.py

@@ -0,0 +1,106 @@
+import numpy as np
+import logging
+from machinegnostics.magcal.util.logging import get_logger
+
+def train_test_split(X:np.ndarray, y=None, test_size=0.25, shuffle=True, random_seed=None, verbose: bool = False):
+    """
+    Splits arrays or matrices into random train and test subsets.
+
+    Parameters
+    ----------
+    X : array-like (list, tuple, or np.ndarray)
+        Feature data to be split. Must be indexable and of consistent length.
+    
+    y : array-like or None, optional (default=None)
+        Target data to be split alongside X. Must be same length as X.
+
+    test_size : float or int, optional (default=0.25)
+        If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split.
+        If int, represents the absolute number of test samples.
+
+    shuffle : bool, optional (default=True)
+        Whether or not to shuffle the data before splitting.
+
+    random_seed : int or None, optional (default=None)
+        Controls the shuffling applied to the data before splitting.
+
+    verbose : bool, optional (default=False)
+        If True, enables detailed logging.
+
+    Returns
+    -------
+    X_train, X_test : np.ndarray
+        Train-test split of X.
+    
+    y_train, y_test : np.ndarray or None
+        Train-test split of y. If y is None, these will also be None.
+
+    Raises
+    ------
+    ValueError
+        If inputs are invalid or test_size is not appropriate.
+
+    Example
+    -------
+    >>> import numpy as np
+    >>> from machinegnostics.models import train_test_split
+    >>> X = np.arange(20).reshape(10, 2)
+    >>> y = np.arange(10)
+    >>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, shuffle=True, random_seed=42)
+    >>> print("X_train:", X_train)
+    >>> print("X_test:", X_test)
+    >>> print("y_train:", y_train)
+    >>> print("y_test:", y_test)
+    """
+    logger = get_logger('train_test_split', level=logging.WARNING if not verbose else logging.INFO)
+    logger.info("Starting train_test_split...")
+
+    # Convert inputs to np arrays
+    X = np.asarray(X)
+    if y is not None:
+        y = np.asarray(y)
+
+    # Validate shapes
+    if y is not None and len(X) != len(y):
+        logger.error(f"X and y must have the same number of samples, got {len(X)} and {len(y)}.")
+        raise ValueError(f"X and y must have the same number of samples, got {len(X)} and {len(y)}.")
+
+    n_samples = len(X)
+
+    # Validate and compute test size
+    if isinstance(test_size, float):
+        if not 0.0 < test_size < 1.0:
+            logger.error("If test_size is a float, it must be between 0.0 and 1.0.")
+            raise ValueError("If test_size is a float, it must be between 0.0 and 1.0.")
+        n_test = int(np.ceil(test_size * n_samples))
+    elif isinstance(test_size, int):
+        if not 0 < test_size < n_samples:
+            logger.error("If test_size is an int, it must be between 1 and len(X) - 1.")
+            raise ValueError("If test_size is an int, it must be between 1 and len(X) - 1.")
+        n_test = test_size
+    else:   
+        logger.error("test_size must be either a float or an int.")
+        raise TypeError("test_size must be either a float or an int.")
+
+    n_train = n_samples - n_test
+
+    # Create indices and shuffle
+    indices = np.arange(n_samples)
+    if shuffle:
+        rng = np.random.default_rng(seed=random_seed)
+        rng.shuffle(indices)
+
+    train_idx = indices[:n_train]
+    test_idx = indices[n_train:]
+
+    X_train = X[train_idx]
+    X_test = X[test_idx]
+
+    if y is not None:
+        y_train = y[train_idx]
+        y_test = y[test_idx]
+    else:
+        y_train = y_test = None
+    logger.info("Completed train_test_split.")
+
+    return X_train, X_test, y_train, y_test

machinegnostics/models/regression/__init__.py

@@ -0,0 +1,2 @@
+from machinegnostics.models.regression.mg_poly_reg import PolynomialRegressor
+from machinegnostics.models.regression.mg_lin_reg import LinearRegressor

machinegnostics/models/regression/layer_histroy_rob_reg.py

@@ -0,0 +1,139 @@
+import numpy as np
+from machinegnostics.models.regression.layer_param_rob_reg import ParamRobustRegressorBase
+from dataclasses import dataclass
+
+@dataclass
+class ParamRecord:
+    iteration: int
+    h_loss: float = None
+    weights: np.ndarray = None
+    coefficients: np.ndarray = None
+    degree: int = None
+    rentropy: float = None
+    fi: np.ndarray = None
+    hi: np.ndarray = None
+    fj: np.ndarray = None
+    hj: np.ndarray = None
+    infoi: dict = None
+    infoj: dict = None
+    pi: np.ndarray = None
+    pj: np.ndarray = None
+    ei: float = None
+    ej: float = None
+
+class HistoryRobustRegressor(ParamRobustRegressorBase):
+    """
+    History class for the Robust 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,
+                 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
+        self._history = history
+        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
+            }
+        ]
+
+        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/regression/layer_io_process_rob_rig.py

@@ -0,0 +1,88 @@
+import numpy as np
+from machinegnostics.magcal import DataProcessLayerBase
+from machinegnostics.models.regression.layer_mlflow_rob_reg import InterfaceRobustRegressor
+from machinegnostics.magcal import disable_parent_docstring
+
+@disable_parent_docstring
+class DataProcessRobustRegressor(DataProcessLayerBase, InterfaceRobustRegressor):
+    """
+    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,
+                 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,
+                 **kwargs):
+        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,
+            history=history,
+            **kwargs
+        )
+
+        # --- 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 mg_loss not in ['hi', 'hj']:
+            raise ValueError("mg_loss must be either 'hi' or 'hj'.")
+        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).")
+        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.params = []
+        
+        # logger
+        self.logger.info("DataProcessRobustRegressor initialized.")
+
+    @disable_parent_docstring
+    def _fit(self, X: np.ndarray, y: np.ndarray):
+        """
+        Fit the model to the data and preprocess it.
+        """
+        self.logger.info("Starting fit process for DataProcessRobustRegressor.")
+        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) -> np.ndarray:
+        """
+        Predict using the model after preprocessing the input data.
+        """
+        self.logger.info("Making predictions with DataProcessRobustRegressor.")
+        X = self._predict_io(X)
+        y_pred = super()._predict(X)
+        # y_pred = self._convert_output(y_pred, self.data_form)
+        return y_pred

machinegnostics/models/regression/layer_mlflow_rob_reg.py

@@ -0,0 +1,134 @@
+import numpy as np
+from machinegnostics.models.regression.layer_histroy_rob_reg import HistoryRobustRegressor
+import mlflow
+import os
+import joblib
+
+class InterfaceRobustRegressor(HistoryRobustRegressor, mlflow.pyfunc.PythonModel):
+    """
+    Interface for the Robust Regressor model with MLflow integration.
+    
+    This class extends HistoryRobustRegressor to provide an interface for
+    logging and tracking model parameters and performance metrics using MLflow.
+    
+    Parameters needed for MLflow tracking:
+        - experiment_name: Name of the MLflow experiment
+        - run_name: Name of the MLflow run
+    """
+    
+    def __init__(self,
+                 degree: int = 1,
+                 max_iter: int = 100,
+                 tol: float = 1e-8,
+                 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,
+            history=history
+        )
+        self.coefficients = None
+        self.weights = None
+        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.params = []
+
+        # logger
+        self.logger.info("InterfaceRobustRegressor initialized.")
+
+    def _fit(self, X: np.ndarray, y: np.ndarray):
+        """
+        Fit the model to the data and log parameters to MLflow.
+        
+        Parameters
+        ----------
+        X : np.ndarray
+            Input features.
+        y : np.ndarray
+            Target values.
+        """
+        # Call the fit method from HistoryRobustRegressor
+        self.logger.info("Starting fit process for InterfaceRobustRegressor. Logging to MLflow available.")
+        super()._fit(X, y)
+        return self
+
+    def _predict(self, model_input) -> np.ndarray:
+        """
+        Predict class labels for input data and log predictions to MLflow.
+        
+        Accepts numpy arrays, pandas DataFrames, or pyspark DataFrames.
+        
+        Parameters
+        ----------
+        model_input : np.ndarray, pd.DataFrame, pyspark.sql.DataFrame
+            Input data for prediction.
+        
+        Returns
+        -------
+        np.ndarray
+            Predicted class labels.
+        """
+        self.logger.info("Making predictions with InterfaceRobustRegressor.")
+        predictions = super()._predict(model_input)
+        return predictions
+    
+    def save_model(self, path:str):
+        """
+        Save the trained model to disk using joblib.
+
+        Parameters
+        ----------
+        path : str
+            Directory path where the model will be saved.
+        If the directory does not exist, it will be created.
+        If the model is already saved, it will be overwritten.
+        This method saves the model in a directory with a file named "model.pkl".
+        """
+        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:str):
+        """
+        Load a trained model from disk using joblib.
+
+        Parameters
+        ----------
+        path : str
+            Directory path where the model is saved.
+        This method loads the model from a file named "model.pkl" in the specified directory.
+        Returns
+        -------
+        MlflowInterfaceRobustRegressor
+            An instance of the model loaded from the specified path.
+        """
+        return joblib.load(os.path.join(path, "model.pkl"))
+        
+    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"))