machinegnostics 0.0.1__py3-none-any.whl

machinegnostics/models/regression/mg_poly_reg.py

@@ -0,0 +1,258 @@
+'''
+Machine Gnostics - Machine Gnostics Library
+Copyright (C) 2025  Machine Gnostics Team
+
+Author: Nirmal Parmar
+
+Description:
+This module implements a robust polynomial 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
+import logging
+from machinegnostics.magcal.util.logging import get_logger
+
+class PolynomialRegressor(DataProcessRobustRegressor):
+    """
+    Robust Polynomial Regression using Mathematical Gnostics principles.
+
+    This regressor fits a polynomial model to data using robust, gnostic loss functions
+    and gnostic 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 gnostic weights.
+    - Flexible polynomial degree: Supports linear and higher-order polynomial regression.
+    - 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
+    ----------
+    degree : int, default=2
+        Degree of the polynomial to fit.
+    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 polynomial 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).
+    degree, max_iter, tol, mg_loss, early_stopping, verbose, scale, data_form, gnostic_characteristics
+        Configuration parameters as set at initialization.
+
+    Methods
+    -------
+    fit(X, y)
+        Fit the polynomial 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 PolynomialRegressor
+    >>> model = PolynomialRegressor(degree=2, max_iter=200, 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, 
+        degree: int = 2, 
+        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 PolynomialRegressor instance with robust, gnostic regression settings.
+
+        Parameters
+        ----------
+        degree : int, default=2
+            Degree of the polynomial to fit.
+        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__(
+            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
+        )
+        # # Optionally, set self.degree here as well for safety:
+        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._record_history = history
+        self.params = []
+        # history option
+        if history:
+            self._history = []
+        else:
+            self._history = None
+        # logger
+        self.logger = get_logger(self.__class__.__name__, logging.DEBUG if verbose else logging.WARNING)
+        self.logger.debug(f"{self.__class__.__name__} initialized.")
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """
+        Fit the robust polynomial regressor model to the provided data.
+
+        This method performs robust polynomial 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 : PolynomialRegressor
+            Returns the fitted model instance for chaining or further use.
+        
+        Example
+        -------
+        >>> model = PolynomialRegressor(degree=2, max_iter=200, verbose=True)
+        >>> model.fit(X_train, y_train) 
+
+        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.
+        """
+        # Call the fit method from DataProcessRobustRegressor
+        self.logger.info("Starting fit process.")
+        super()._fit(X, y)
+    
+    def predict(self, model_input: np.ndarray) -> np.ndarray:
+        """
+        Predict target values using the fitted polynomial 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 = PolynomialRegressor(degree=2)
+        >>> model.fit(X_train, y_train)
+        >>> y_pred = model.predict(X_test)
+        """
+        # Call the predict method from DataProcessRobustRegressor
+        self.logger.info("Making predictions.")
+        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 polynomial 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 = PolynomialRegressor(degree=2)
+        >>> 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.")
+        # prediction
+        y_pred = self.predict(X)
+        # Call the score method from DataProcessRobustRegressor
+        r2 = robr2(y, y_pred, w=self.weights)
+        return r2

machinegnostics-0.0.1.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: machinegnostics
+Version: 0.0.1
+Summary: Machine Gnostics is an open-source initiative that seeks to redefine the mathematical underpinnings of machine learning. While most conventional ML libraries are grounded in probabilistic and statistical frameworks, Machine Gnostics explores alternative paradigms—drawing from Mathematical Gnostics, the non-statistical and deterministic approach. Laws of Nature, Encoded—For Everyone!
+Author-email: Nirmal Parmar <info.machinegnostics@gmail.com>
+Maintainer-email: Nirmal Parmar <info.machinegnostics@gmail.com>
+License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/MachineGnostics
+Project-URL: Issues, https://github.com/MachineGnostics/machinegnostics
+Project-URL: Website, https://machinegnostics.info/
+Keywords: machine learning,AI,data science,data analysis,deep learning,neural networks,ML,Machine Gnostics,Mathematical Gnostics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pydantic
+Requires-Dist: scipy
+Requires-Dist: SQLAlchemy
+Dynamic: license-file
+
+# Machine Gnostics
+
+> Machine Gnostics: Laws of Nature, Encoded—For Everyone!
+
+Welcome to **Machine Gnostics**, an innovative Python library designed to implement the principles of **Machine Gnostics** for robust data analysis, modeling, and inference. Unlike traditional statistical approaches that depend heavily on probabilistic assumptions, Machine Gnostics harnesses deterministic algebraic and geometric structures. This unique foundation enables the library to deliver exceptional resilience against outliers, noise, and corrupted data, making it a powerful tool for challenging real-world scenarios.
+
+Machine Gnostics is an open-source initiative that seeks to redefine the mathematical underpinnings of machine learning. While most conventional ML libraries are grounded in probabilistic and statistical frameworks, Machine Gnostics explores alternative paradigms—drawing from deterministic algebra, information theory, and geometric methods. This approach opens new avenues for building robust, interpretable, and reliable analysis tools that can withstand the limitations of traditional models.
+
+> As a pioneering project, Machine Gnostics invites users to adopt a fresh perspective and develop a new understanding of machine learning. The library is currently in its infancy, and as such, some features may require refinement and fixes. We are actively working to expand its capabilities, with new models and methods planned for the near future. Community support and collaboration are essential to realizing Machine Gnostics’ full potential. Together, let’s build a new AI grounded in a rational and resilient paradigm.
+
+More information at [Machine Gnostics](https://machinegnostics.info)
+
+---
+
+# Installation Guide
+
+Machine Gnostics is distributed as a standard Python package and is designed for easy installation and integration into your data science workflow. The library has been tested on macOS with Python 3.11 and is fully compatible with standard data science libraries.
+
+---
+
+## 1. Create a Python Virtual Environment
+
+It is best practice to use a virtual environment to manage your project dependencies and avoid conflicts with other Python packages.
+
+### macOS & Linux
+
+```bash
+# Create a new virtual environment named 'mg-env'
+python3 -m venv mg-env
+# Activate the environment
+source mg-env/bin/activate
+```
+
+### Windows
+
+```cmd
+# Create a new virtual environment named 'mg-env'
+python -m venv mg-env
+# Activate the environment
+mg-env\Scripts\activate
+```
+
+---
+
+## 2. Install Machine Gnostics
+
+Install the Machine Gnostics library using pip:
+
+### macOS & Linux
+
+```bash
+pip install machinegnostics
+```
+
+### Windows
+
+```cmd
+pip install machinegnostics
+```
+
+This command will install Machine Gnostics and automatically resolve its dependencies.
+
+---
+
+## 3. Verify Installation
+
+You can verify that Machine Gnostics and its dependencies are installed correctly by importing them in a Python session:
+
+```python
+# check import
+import machinegnostics
+print("imported successfully!")
+```
+
+You can also check the installation with pip:
+
+### macOS & Linux
+
+```bash
+pip show machinegnostics
+```
+
+### Windows
+
+```cmd
+pip show machinegnostics
+```
+
+---
+
+## 4. Quick Usage Example
+
+Machine Gnostics is designed to be as simple to use as other machine learning libraries. You can call its functions and classes directly after installation.
+
+### Example "Gnostic Distribution Function"
+
+```python
+import numpy as np
+from machinegnostics.magcal import EGDF
+
+data = np.array([ -13.5, 0, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
+egdf = EGDF()
+egdf.fit(data)
+egdf.plot()
+print(egdf.params)
+```
+
+### Example "Polynomial Regression"
+
+```python
+import numpy as np
+from machinegnostics.models.regression import PolynomialRegressor
+
+# Example data
+X = np.array([0., 0.4, 0.8, 1.2, 1.6, 2. ])
+y = np.array([17.89408548, 69.61586934, -7.19890572, 9.37670866, -10.55673099, 16.57855348])
+
+# Create and fit a robust polynomial regression model
+model = PolynomialRegressor(degree=2)
+model.fit(X, y)
+
+model_lr = LinearRegressor()
+model_lr.fit(X, y)
+
+# Make predictions
+y_pred = model.predict(X)
+y_pred_lr = model_lr.predict(X)
+
+print("Predictions:", y_pred)
+
+# coefficients
+print("Coefficients:", model.coefficients)
+
+# x vs y, y_pred plot
+import matplotlib.pyplot as plt
+plt.scatter(X, y, color='blue', label='Data')
+plt.plot(X, y_pred, color='red', label='Polynomial Prediction')
+plt.plot(X, y_pred_lr, color='green', label='Linear Prediction')
+plt.xlabel('X')
+plt.ylabel('y')
+plt.title('Polynomial Regression')
+plt.legend()
+plt.grid(True, alpha=0.3)
+plt.show()
+```
+
+---
+
+## 5. Platform and Environment
+
+- **Operating System:** Tested on macOS and Windows 11
+- **Python Version:** 3.11 recommended
+- **Dependencies:** Compatible with NumPy, pandas, SciPy, and other standard data science libraries
+
+---
+
+## 6. Troubleshooting
+
+- **Activate Your Environment:**
+  Always activate your virtual environment before installing or running Machine Gnostics.
+
+  **macOS & Linux:**
+
+  ```bash
+  source mg-env/bin/activate
+  # or for conda
+  conda activate myenv
+  ```
+
+  **Windows:**
+
+  ```cmd
+  mg-env\Scripts\activate
+  # or for conda
+  conda activate myenv
+  ```
+- **Check Your Python Version:**
+  Ensure you are using Python 3.8 or newer.
+
+  **macOS & Linux:**
+
+  ```bash
+  python3 --version
+  ```
+
+  **Windows:**
+
+  ```cmd
+  python --version
+  ```
+- **Upgrade pip:**
+  An outdated pip can cause installation errors. Upgrade pip before installing:
+
+  **macOS & Linux:**
+
+  ```bash
+  pip install --upgrade pip
+  ```
+
+  **Windows:**
+
+  ```cmd
+  pip install --upgrade pip
+  ```
+
+**Install from a Clean Environment:** If you encounter conflicts, try creating a fresh virtual environment and reinstalling.
+**Check Your Internet Connection:** Download errors often result from network issues. Make sure you are connected.
+**Permission Issues:** If you see permission errors, avoid using `sudo pip install`. Instead, use a virtual environment.
+
+- **Still Stuck**
+
+  - [Contact us](https://machinegnostics.info/contact/) or open an issue on [GitHub](https://github.com/MachineGnostics/machinegnostics).
+
+---
+
+Machine Gnostics is designed for simplicity and reliability, making robust machine learning accessible for all Python users.

machinegnostics-0.0.1.dist-info/RECORD

@@ -0,0 +1,93 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+machinegnostics/__init__.py,sha256=54lUgrIrAdmRD8tTaLGU3sq3Ly_VqKu9JCF2AGsUPuk,984
+machinegnostics/magcal/__init__.py,sha256=X9h_kMerd0u1vRaCpw5xuu_PIohPcEeRR0j_IFmo7dU,2012
+machinegnostics/magcal/characteristics.py,sha256=KE9jLNyDk2Z8oKFBs0iHbn-3AA8zIj3LvHD5xRLOXyc,13755
+machinegnostics/magcal/criteria_eval.py,sha256=AicifHZCUwz-_O2AS5_dKxgQkMQ4Ye58ez9nxZFU6CY,10995
+machinegnostics/magcal/criterion.py,sha256=5dpnPxaE4eBgqw5XB-9N0a4Gob_a4owR5Copq1u8lz0,4822
+machinegnostics/magcal/data_conversion.py,sha256=GPtZuzmWsgJHKeWsWwzBgQ8NzHgYpOa3SDG8X4YHa-c,10960
+machinegnostics/magcal/gcor.py,sha256=WdkjXHktmNbAjjNvEe23DtTkUAiXzzyE3KK2wjr6E5I,2217
+machinegnostics/magcal/layer_base.py,sha256=ZKGn_4kkfbKBPZmqao6ng4-DyOdd21bVDcLXxy7vA8g,906
+machinegnostics/magcal/layer_history_base.py,sha256=7FAmTJfoHom6Wtck-lgRcFK3muj0YvuRVqgfsTBmp-A,2693
+machinegnostics/magcal/layer_io_process_base.py,sha256=PWhJ10-24VnUS2Qufuy0p0duCLP86MaIUvLtuOrM8Ek,8098
+machinegnostics/magcal/layer_param_base.py,sha256=SV0N-hD763rCar--HqzrkEfm7eB0Uk6ZLSTKGxa1jjo,15096
+machinegnostics/magcal/mg_weights.py,sha256=Tg8gnSw2WanshnZRvD4JVdmJXy3hxpZqBoJkR9WpMWk,1117
+machinegnostics/magcal/sample_characteristics.py,sha256=XVGZ5xzVr6DC14vlu7AHl8BbtTWE3Gt5CCPCQOcDV_0,18786
+machinegnostics/magcal/scale_optimization.py,sha256=T2SaMV7UhY73ZdW5M4suMtEkLdxqDXviw9W1hfVfmfI,5273
+machinegnostics/magcal/scale_param.py,sha256=MYC-MqpEe8iEb_I0hZh7hS5p7SfysOVJbHaZbf23S_I,11598
+machinegnostics/magcal/gdf/__init__.py,sha256=ri_dNxE3bNPgbRXd07jF7X4kG6VJ8F0iJtfFDGoB-UQ,97
+machinegnostics/magcal/gdf/base_df.py,sha256=AGodnDv7T03WALrMLmBCz0_PRJRQxKm2WVPrLBR87AE,858
+machinegnostics/magcal/gdf/base_distfunc.py,sha256=YPjuxOFLf0t01BT0F0YGivz8-7V0H0K9R6uxzmqQBYA,51858
+machinegnostics/magcal/gdf/base_egdf.py,sha256=Mtk0H7Ksc3gx9KmlTU37kaaEsnMxQmNEBrAkgTTUtkw,34855
+machinegnostics/magcal/gdf/base_eldf.py,sha256=Pfm_Wf5tYftKniYBrsT7WqgwIbSbgiNElXQisoehkCQ,33021
+machinegnostics/magcal/gdf/base_qgdf.py,sha256=lsLP8T-TTrujxC0aNt-L8UAy9tUtMlAAWgjiFI5F2y0,55670
+machinegnostics/magcal/gdf/base_qldf.py,sha256=LAWQVvlq8qOXT7zpEiag_r4VRdafTQ-eMtikv5JdQPE,42047
+machinegnostics/magcal/gdf/cluster_analysis.py,sha256=WIWmzC6YWfYEn43XTDaKxNvcnXnvLEYZyhSbGe3BYek,19364
+machinegnostics/magcal/gdf/data_cluster.py,sha256=vJvGYsjDCAEY_RRU67k3_0kVfNTTjPVu_Q8Txg-o6AE,43108
+machinegnostics/magcal/gdf/data_intervals.py,sha256=oqxXFeGmCBcCBnq009JbOKQ682BbkcSSjaq1Y8BXKK4,40600
+machinegnostics/magcal/gdf/data_membership.py,sha256=x1iIyG_pwhsPOyG2QvNMdGhAE9qPptC8d5pntFu_bps,24034
+machinegnostics/magcal/gdf/der_egdf.py,sha256=kKxgVKnnGGMRf2Jya-GKcs19fEjRXCm5hlJL1Zn3p_0,9692
+machinegnostics/magcal/gdf/distfunc_engine.py,sha256=WkRnKrUr-oUW43bRx1_8qol-34MQ4fb47rqqH2BAShk,35240
+machinegnostics/magcal/gdf/egdf.py,sha256=916fHl-y3BLubArbbwnWP98e8g_pEbV-ekzeopK_miA,17969
+machinegnostics/magcal/gdf/eldf.py,sha256=DWKrghXUmTse1LbJ1tSmAqx09nK22GNUsBm4AbegBck,15646
+machinegnostics/magcal/gdf/eldf_intv.py,sha256=Pm5K7qgeb-pyhpA5vf_LH4oUIgzMx6CoUJOJoEh4Lps,28751
+machinegnostics/magcal/gdf/eldf_ma.py,sha256=o_5Chr_QdjCL3NT-2NaPussxyltwrf_guPkUBhMCMGw,26810
+machinegnostics/magcal/gdf/homogeneity.py,sha256=R_aEzP2pHM7nN2BTzkQIkLCdvp1ourFADjj2dGheGcE,53649
+machinegnostics/magcal/gdf/intv_engine.py,sha256=yB0f9rwfe5yuZpu4RIM08-1fYD9gwRaKH-kWFCZpOKo,67142
+machinegnostics/magcal/gdf/marginal_intv_analysis.py,sha256=Kvhpb1alTDRHQAhPtOJ1ezDd219yStfOEfaAz2q-bpY,24856
+machinegnostics/magcal/gdf/qgdf.py,sha256=QwRgCMo00iLocEPuBZg1p803CyrJWPDe_xF5NjBX64Q,15106
+machinegnostics/magcal/gdf/qldf.py,sha256=Y1nl8GAIQq7djp1ZKpmkU858zVN1_4HS9pO5bIHhJqQ,15516
+machinegnostics/magcal/gdf/scedasticity.py,sha256=C8KaY08hQun8t5AFbkS-W5J21g-7LtelMUtycElMyG0,8925
+machinegnostics/magcal/gdf/wedf.py,sha256=-oAhOiskK_mZe4jZFwVblki8Ac1uYRt9APKdcyseirs,6222
+machinegnostics/magcal/gdf/z0_estimator.py,sha256=3wXdCu2kO_eD3HSxgSmQqd3yOtNtROdJMlYPi89yCXs,46010
+machinegnostics/magcal/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+machinegnostics/magcal/util/dis_docstring.py,sha256=8oZncKcDPcy3H-2VU_BQdljYxgYlSi-Jr3n94bquxoc,595
+machinegnostics/magcal/util/logging.py,sha256=hNJwtnSuEWrntIVf_UYJL4gZTOHfXS1XSo9O1ZhUio4,742
+machinegnostics/magcal/util/min_max_float.py,sha256=WOaD8AELbSJyugSIKyB0I9vu7Ur9Yi2_FfSEl3qcjeY,668
+machinegnostics/magnet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+machinegnostics/metrics/__init__.py,sha256=Poj3FjaVyh66gnnUhH4sIcYv2yugZDKcSgFq4DJy7ys,1402
+machinegnostics/metrics/accu.py,sha256=uyKcmwAPiYHye17V-GXsqAtFF8dek8QGIiogLd12vQs,2510
+machinegnostics/metrics/accuracy.py,sha256=ApA88sK--Gde4u32r_dy3xBsFST4IdcsXjY8-0DSdNo,2487
+machinegnostics/metrics/auto_correlation.py,sha256=FDN40rAlU5mOs_R-3sbUJ8EvQdlc3TmTdJ1l1jOsQxQ,7246
+machinegnostics/metrics/auto_covariance.py,sha256=94EZ2cQjOx26tRWQ_xZXihH-JBc5MYbxMNHUIlyNia8,8253
+machinegnostics/metrics/cls_report.py,sha256=wGa2YA9-URgdDSf-kITi5nzPb2ESnSYRzPFbQ5V0TPQ,4737
+machinegnostics/metrics/conf_matrix.py,sha256=npqv7xIG_lXTm0lbWozyA6TYNll-VY8ZribRXg2pHNw,3689
+machinegnostics/metrics/correlation.py,sha256=OMMzAypCnR32-5dXEnjibXhqClLscotgFxFfVRtRhTA,6836
+machinegnostics/metrics/cross_variance.py,sha256=VgcXyiEJz1fm--Pa62CIo0moFvS_qqbiqZ7Nisx-hy0,6955
+machinegnostics/metrics/divi.py,sha256=vMRvKf_bVQIZB3MAMkPJ1Zbqe8SFp2G8wglc9wAFjlg,2873
+machinegnostics/metrics/evalmet.py,sha256=OtjUoAZ-Z0yf1xO1jGJZXzrazXPvY8ah-nRQrOe8b70,3926
+machinegnostics/metrics/f1_score.py,sha256=irHcxQ3mcPgFQcuaWDnSc1iij3h9rA-B1UmtxKgAYTg,5596
+machinegnostics/metrics/gmmfe.py,sha256=oNwnzvTqWrIox_5CMGcO2DXbeFMHbMEwZZcEA4nvbDs,3883
+machinegnostics/metrics/hc.py,sha256=eoQSP9cyrqTy_p43ujl-ADJmX-iqY6rZrIYmpkO_pyo,5570
+machinegnostics/metrics/mae.py,sha256=lIS6Qm5OAvSPjfFLqjlCRc5H9PNtgjLZQyFbZ5c6PMI,2703
+machinegnostics/metrics/mean.py,sha256=rifs-MpjoMB27IbMde4HRf8rrLKg48ZsouC3z0os4q4,4508
+machinegnostics/metrics/median.py,sha256=pi51rqY1aJOloCCHnhZ3YgxFWazmBRN8it8gbndXla0,4667
+machinegnostics/metrics/mg_r2.py,sha256=OCkoamJ1y80_qdO2WYE3PZUPi0w1-x4lm0zeLod6Z2s,6934
+machinegnostics/metrics/mse.py,sha256=_PW6zkrDyhfcQBiPOOpBxieh30jMVAn61G5twLuemqY,3267
+machinegnostics/metrics/precision.py,sha256=UqURGeZJb7ycy9xZwhHyNwJzl_NLxEbnOZ_Q9eiaRpU,5092
+machinegnostics/metrics/r2.py,sha256=AuDjk3qDZRcUlqy38Ks2gvuSrwfZfiIJQoF37m8O4j4,4259
+machinegnostics/metrics/recall.py,sha256=LyEcPLGWdPFFWv6B9zTUwiNxt9XrWnUt1It-zsKFmhA,4328
+machinegnostics/metrics/rmse.py,sha256=xSI18yQsU_ld8_mTgskJ7GB4yZzJjXjkgn6KCbfd-As,3033
+machinegnostics/metrics/robr2.py,sha256=F2m1JMxahKT5lxtXwSMRBsDZqdVlpTJ6o8VvwE42KKM,4769
+machinegnostics/metrics/std.py,sha256=AsVWDQijdBFb9bfBBYeLwabLItwPCrqjBcTRCeatNRA,5761
+machinegnostics/metrics/variance.py,sha256=uosAjkn57HflQ4wda51PGe_e7oGKdT4L5OFOpC6r-zA,3688
+machinegnostics/models/__init__.py,sha256=VjnEzMbEi4KIA0WxN02E7EAOpV8AUp0vSWps-Fq-lhM,129
+machinegnostics/models/cross_validation.py,sha256=G4x6bjFbCOPz16j7g5HVZCoZNF3aNAOr17UBoucHmbY,3887
+machinegnostics/models/data_split.py,sha256=Y-1VFEMuXNAXA3yBfGYjLow0PRSZ1OFyiWlfW3ep8Eg,3732
+machinegnostics/models/classification/__init__.py,sha256=blhns36tnKpxM4MM2rkQnv7E4IxBqJco9mYJqPMkvB8,78
+machinegnostics/models/classification/layer_history_log_reg.py,sha256=CjcYV27lbXqu6sxsqfg1TBRdv2oUz5di1c7wj75fMnw,4444
+machinegnostics/models/classification/layer_io_process_log_reg.py,sha256=ObYfnobQgYBlXvGLPZIBQsqQ3msi9n-muH5J8Hzz9LI,3973
+machinegnostics/models/classification/layer_mlflow_log_reg.py,sha256=rPM5WCcnm5Tc64wVsYf7MTqx1QS3PUqK-ZaHJdm2F24,3751
+machinegnostics/models/classification/layer_param_log_reg.py,sha256=-2vNRYMXOY8hxMKeCdTwt0TMy9W16oMGQVsr-1ubiN4,11267
+machinegnostics/models/classification/mg_log_reg.py,sha256=1RrTcwUCy9T005tauVjVDnjwdf7_cpQRbGYod0p0lWo,10744
+machinegnostics/models/regression/__init__.py,sha256=1Bkbz-7buCSrEmTD1h_I7ehCA-fsRnmNzSeW1_y-jI4,150
+machinegnostics/models/regression/layer_histroy_rob_reg.py,sha256=21ml_nmC3cE1HaXwHJdcLtTQsRDipmkqBb5Xt4xuAQU,4860
+machinegnostics/models/regression/layer_io_process_rob_rig.py,sha256=f2RLzBxCaeUySCwZoBXcW436W7iO28Aa0Z5TldpDpeI,3544
+machinegnostics/models/regression/layer_mlflow_rob_reg.py,sha256=jPRgLW-LVqC__D8PKXDX2FVRMNb_uGqHRD0p-Vy1Hjo,4493
+machinegnostics/models/regression/layer_param_rob_reg.py,sha256=_pBEjyB5JhXPtkhwVxXi4UC4QmhbsnfVwWIECompDqM,8028
+machinegnostics/models/regression/mg_lin_reg.py,sha256=7C9ClM06l4dYPSV8uIOaUJmKRRa2OeINsgMqJHr-FTM,9266
+machinegnostics/models/regression/mg_poly_reg.py,sha256=d80EPeb6SmBoMp07RTATFnUPF1e99XxwgxWzRzz0I9Y,9653
+machinegnostics-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+machinegnostics-0.0.1.dist-info/METADATA,sha256=_B-sWASL85RfbnRN428wl6JqeURiIO98k-L3AfSNVdQ,7813
+machinegnostics-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+machinegnostics-0.0.1.dist-info/top_level.txt,sha256=qGvrRC633BXccx-wAgfo3urOcQZkQxCt3XX8KzykPlg,25
+machinegnostics-0.0.1.dist-info/RECORD,,

machinegnostics-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+