learningmachine 0.2.3__tar.gz → 1.1.0__tar.gz

{learningmachine-0.2.3 → learningmachine-1.1.0}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 0.2.3
+Version: 1.1.0
 Summary: Machine Learning with uncertainty quantification and interpretability
 Home-page: https://github.com/Techtonique/learningmachine_python
 Author: T. Moudiki
 Author-email: thierry.moudiki@gmail.com
 License: BSD Clause Clear license
 Keywords: learningmachine
-Platform: UNKNOWN
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -18,6 +17,10 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.6
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rpy2>=3.4.5
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
 
 Machine Learning with uncertainty quantification and interpretability.
-

learningmachine-1.1.0/learningmachine/__init__.py

@@ -0,0 +1,10 @@
+"""Top-level package for learningmachine."""
+
+__author__ = """T. Moudiki"""
+__email__ = "thierry.moudiki@gmail.com"
+
+from .base import Base
+from .classifier import Classifier
+from .regression import Regressor
+
+__all__ = ["Base", "Classifier", "Regressor"]

learningmachine-1.1.0/learningmachine/base.py

@@ -0,0 +1,213 @@
+import sklearn.metrics as skm
+import subprocess
+from functools import lru_cache
+from sklearn.base import BaseEstimator
+from rpy2.robjects.vectors import StrVector
+from rpy2.robjects.packages import importr
+from rpy2.robjects import r
+
+base = importr("base")
+stats = importr("stats")
+utils = importr("utils")
+
+
+class Base(BaseEstimator):
+    """
+    Base class.
+    """
+
+    def __init__(
+        self,
+        type=None,
+        name="Base",
+        method="ranger",
+        pi_method="kdesplitconformal",
+        level=95,
+        type_prediction_set="score",
+        B=100,
+        nb_hidden = 0,
+        nodes_sim = "sobol",
+        activ = "relu",
+        params=None,
+        seed=123,
+    ):
+        """
+        Initialize the model.
+        """
+        super().__init__()
+        self.name = name
+        self.type = type
+        self.method = method
+        self.pi_method = pi_method
+        self.level = level
+        self.type_prediction_set = type_prediction_set
+        self.B = B        
+        self.nb_hidden = nb_hidden
+        assert nodes_sim in ("sobol", "halton", "unif"), \
+            "must have nodes_sim in ('sobol', 'halton', 'unif')"
+        self.nodes_sim = "sobol"
+        assert activ in ("relu", "sigmoid", "tanh",
+                             "leakyrelu", "elu", "linear"), \
+                            "must have activ in ('relu', 'sigmoid', 'tanh', 'leakyrelu', 'elu', 'linear')"
+        self.activ = activ 
+        self.params = params
+        self.seed = seed
+        self.obj = None
+
+    @lru_cache
+    def load_learningmachine(self):
+        # Install R packages
+        commands1_lm = 'base::system.file(package = "learningmachine")'  # check "learningmachine" is installed
+        commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")'  # check "learningmachine" is installed locally
+        exec_commands1_lm = subprocess.run(
+            ["Rscript", "-e", commands1_lm], capture_output=True, text=True
+        )
+        exec_commands2_lm = subprocess.run(
+            ["Rscript", "-e", commands2_lm], capture_output=True, text=True
+        )
+        if (
+            len(exec_commands1_lm.stdout) == 7
+            and len(exec_commands2_lm.stdout) == 7
+        ):  # kind of convoluted, but works
+            print("Installing R packages along with 'learningmachine'...")
+            commands1 = [
+                'try(utils::install.packages(c("R6", "Rcpp", "skimr"), repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)',
+                'try(utils::install.packages("learningmachine", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=FALSE)',
+            ]
+            commands2 = [
+                'try(utils::install.packages(c("R6", "Rcpp", "skimr"), lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)',
+                'try(utils::install.packages("learningmachine", lib="./learningmachine_r", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=FALSE)',
+            ]
+            try:
+                for cmd in commands1:
+                    subprocess.run(["Rscript", "-e", cmd])
+            except NotImplementedError as e:  # can't install packages globally
+                subprocess.run(["mkdir", "learningmachine_r"])
+                for cmd in commands2:
+                    subprocess.run(["Rscript", "-e", cmd])
+
+            try:
+                base.library(StrVector(["learningmachine"]))
+            except (
+                NotImplementedError
+            ) as e1:  # can't load the package from the global environment
+                try:
+                    base.library(
+                        StrVector(["learningmachine"]),
+                        lib_loc="learningmachine_r",
+                    )
+                except NotImplementedError as e2:  # well, we tried
+                    try:
+                        r("try(library('learningmachine'), silence=FALSE)")
+                    except (
+                        NotImplementedError
+                    ) as e3:  # well, we tried everything at this point
+                        r(
+                            "try(library('learningmachine', lib.loc='learningmachine_r'), silence=FALSE)"
+                        )
+
+    def score(self, X, y, scoring=None, **kwargs):
+        """Score the model on test set features X and response y.
+
+        Parameters:
+
+            X: {array-like}, shape = [n_samples, n_features]
+                Training vectors, where n_samples is the number
+                of samples and n_features is the number of features
+
+            y: array-like, shape = [n_samples]
+                Target values
+
+            scoring: str
+                must be in ('explained_variance', 'neg_mean_absolute_error',
+                            'neg_mean_squared_error', 'neg_mean_squared_log_error',
+                            'neg_median_absolute_error', 'r2')
+
+            **kwargs: additional parameters to be passed to scoring functions
+
+        Returns:
+
+        model scores: {array-like}
+
+        """
+
+        preds = self.predict(X)
+
+        if self.type == "classification":
+
+            if scoring is None:
+                scoring = "accuracy"
+
+            # check inputs
+            assert scoring in (
+                "accuracy",
+                "average_precision",
+                "brier_score_loss",
+                "f1",
+                "f1_micro",
+                "f1_macro",
+                "f1_weighted",
+                "f1_samples",
+                "neg_log_loss",
+                "precision",
+                "recall",
+                "roc_auc",
+            ), "'scoring' should be in ('accuracy', 'average_precision', \
+                            'brier_score_loss', 'f1', 'f1_micro', \
+                            'f1_macro', 'f1_weighted',  'f1_samples', \
+                            'neg_log_loss', 'precision', 'recall', \
+                            'roc_auc')"
+
+            scoring_options = {
+                "accuracy": skm.accuracy_score,
+                "average_precision": skm.average_precision_score,
+                "brier_score_loss": skm.brier_score_loss,
+                "f1": skm.f1_score,
+                "f1_micro": skm.f1_score,
+                "f1_macro": skm.f1_score,
+                "f1_weighted": skm.f1_score,
+                "f1_samples": skm.f1_score,
+                "neg_log_loss": skm.log_loss,
+                "precision": skm.precision_score,
+                "recall": skm.recall_score,
+                "roc_auc": skm.roc_auc_score,
+            }
+
+            try:
+                preds = preds.ravel().astype(int)
+                return scoring_options[scoring](y, preds, **kwargs)
+            except:
+                return scoring_options[scoring](y, preds, **kwargs)
+
+        if self.type == "regression":
+
+            if (
+                type(preds) == tuple
+            ):  # if there are std. devs in the predictions
+                preds = preds[0]
+
+            if scoring is None:
+                scoring = "neg_mean_squared_error"
+
+            # check inputs
+            assert scoring in (
+                "explained_variance",
+                "neg_mean_absolute_error",
+                "neg_mean_squared_error",
+                "neg_mean_squared_log_error",
+                "neg_median_absolute_error",
+                "r2",
+            ), "'scoring' should be in ('explained_variance', 'neg_mean_absolute_error', \
+                            'neg_mean_squared_error', 'neg_mean_squared_log_error', \
+                            'neg_median_absolute_error', 'r2')"
+
+            scoring_options = {
+                "explained_variance": skm.explained_variance_score,
+                "neg_mean_absolute_error": skm.median_absolute_error,
+                "neg_mean_squared_error": skm.mean_squared_error,
+                "neg_mean_squared_log_error": skm.mean_squared_log_error,
+                "neg_median_absolute_error": skm.median_absolute_error,
+                "r2": skm.r2_score,
+            }
+
+            return scoring_options[scoring](y, preds, **kwargs)

learningmachine-1.1.0/learningmachine/classifier.py

@@ -0,0 +1,134 @@
+import numpy as np
+import sklearn.metrics as skm
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import (
+    FloatMatrix,
+    FloatVector,
+    IntVector,
+    FactorVector,
+)
+from sklearn.base import ClassifierMixin
+from .base import Base
+from .utils import format_value
+
+base = importr("base")
+stats = importr("stats")
+utils = importr("utils")
+
+
+class Classifier(Base, ClassifierMixin):
+    """
+    Classifier.
+    """
+
+    def __init__(
+        self,
+        method="ranger",
+        pi_method="kdesplitconformal",
+        level=95,
+        type_prediction_set="score",
+        B=100,
+        nb_hidden = 0,
+        nodes_sim = "sobol",
+        activ = "relu",
+        seed=123,
+    ):
+        """
+        Initialize the model.
+        """
+        super().__init__(
+            name = "Classifier",
+            type = "classification",
+            method=method,
+            pi_method=pi_method,
+            level=level,
+            type_prediction_set=type_prediction_set,
+            B=B,
+            nb_hidden=nb_hidden,
+            nodes_sim=nodes_sim,
+            activ=activ,
+            seed=seed,
+        )
+
+        try:
+            self.load_learningmachine()
+            self.obj = r(
+                f"learningmachine::Classifier$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, type_prediction_set = {format_value(self.type_prediction_set)}, B = {format_value(self.B)}, nb_hidden = {format_value(self.nb_hidden)}, nodes_sim = {format_value(self.nodes_sim)}, activ = {format_value(self.activ)}, seed = {format_value(self.seed)})"
+            )
+        except NotImplementedError as e:
+            try:
+                r.library("learningmachine")
+                self.obj = r(
+                    f"Classifier$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, type_prediction_set = {format_value(self.type_prediction_set)}, B = {format_value(self.B)}, nb_hidden = {format_value(self.nb_hidden)}, nodes_sim = {format_value(self.nodes_sim)}, activ = {format_value(self.activ)}, seed = {format_value(self.seed)})"
+                )
+            except NotImplementedError as e:
+                try:
+                    self.obj = r(
+                        f"""
+                                 library(learningmachine); 
+                                 Classifier$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, type_prediction_set = {format_value(self.type_prediction_set)}, B = {format_value(self.B)}, nb_hidden = {format_value(self.nb_hidden)}, nodes_sim = {format_value(self.nodes_sim)}, activ = {format_value(self.activ)}, seed = {format_value(self.seed)})
+                                 """
+                    )
+                except NotImplementedError as e:
+                    print("R package can't be loaded: ", e)
+
+    def fit(self, X, y):
+        """
+        Fit the model according to the given training data.
+        """
+        self.obj["fit"](
+            r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0]),
+            FactorVector(IntVector(y)),
+        )
+        self.classes_ = np.unique(y)  # /!\ do not remove
+        return self
+    
+    def predict_proba(self, X):
+        """
+        Predict using the model.
+        """    
+        if self.level is None:               
+            res = self.obj["predict_proba"](
+                    r.matrix(FloatVector(X.ravel()), 
+                byrow=True,
+                ncol=X.shape[1],
+                nrow=X.shape[0])
+                )
+            return np.asarray(res)
+        res = self.obj["predict_proba"](
+                    r.matrix(FloatVector(X.ravel()), 
+                byrow=True,
+                ncol=X.shape[1],
+                nrow=X.shape[0])
+                )
+        return np.asarray(res[0])                                    
+
+    def predict(self, X):
+        """
+        Predict using the model.
+        """    
+        if self.level is None:               
+            return (
+            np.asarray(
+                self.obj["predict"](
+                    r.matrix(FloatVector(X.ravel()), 
+                byrow=True,
+                ncol=X.shape[1],
+                nrow=X.shape[0])
+                )
+            ) - 1 
+        )
+        return (
+            np.asarray(
+                self.obj["predict"](
+                    r.matrix(FloatVector(X.ravel()), 
+                byrow=True,
+                ncol=X.shape[1],
+                nrow=X.shape[0])
+                )
+            )            
+        )

learningmachine-1.1.0/learningmachine/regression.py

@@ -0,0 +1,92 @@
+import numpy as np
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import FloatMatrix, FloatVector
+from sklearn.base import RegressorMixin
+from .base import Base
+from .utils import format_value
+
+base = importr("base")
+stats = importr("stats")
+utils = importr("utils")
+
+
+class Regressor(Base, RegressorMixin):
+    """
+    Regressor.
+    """
+
+    def __init__(
+            self,
+        method="ranger",
+        pi_method="kdesplitconformal",
+        level=95,
+        B=100,
+        nb_hidden = 0,
+        nodes_sim = "sobol",
+        activ = "relu",
+        seed=123,
+    ):
+        """
+        Initialize the model.
+        """
+        super().__init__(
+            name = "Regressor",
+            type = "regression",
+            method=method,
+            pi_method=pi_method,
+            level=level,
+            B=B,
+            nb_hidden=nb_hidden,
+            nodes_sim=nodes_sim,
+            activ=activ,
+            seed=seed,
+        )
+        
+        try:
+            self.load_learningmachine()
+            self.obj = r(
+                f"learningmachine::Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, type_prediction_set = {format_value(self.type_prediction_set)}, B = {format_value(self.B)}, nb_hidden = {format_value(self.nb_hidden)}, nodes_sim = {format_value(self.nodes_sim)}, activ = {format_value(self.activ)}, seed = {format_value(self.seed)})"
+            )
+        except NotImplementedError as e:
+            try:
+                r.library("learningmachine")
+                self.obj = r(
+                    f"Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, type_prediction_set = {format_value(self.type_prediction_set)}, B = {format_value(self.B)}, nb_hidden = {format_value(self.nb_hidden)}, nodes_sim = {format_value(self.nodes_sim)}, activ = {format_value(self.activ)}, seed = {format_value(self.seed)})"
+                )
+            except NotImplementedError as e:
+                try:
+                    self.obj = r(
+                        f"""
+                                 library(learningmachine); 
+                                 Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, type_prediction_set = {format_value(self.type_prediction_set)}, B = {format_value(self.B)}, nb_hidden = {format_value(self.nb_hidden)}, nodes_sim = {format_value(self.nodes_sim)}, activ = {format_value(self.activ)}, seed = {format_value(self.seed)})
+                                 """
+                    )
+                except NotImplementedError as e:
+                    print("R package can't be loaded: ", e)
+
+    def fit(self, X, y):
+        """
+        Fit the model according to the given training data.
+        """
+        self.obj["fit"](
+            r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0]),
+            FloatVector(y),
+        )
+        return self
+
+    def predict(self, X):
+        """
+        Predict using the model.
+        """
+        return np.asarray(
+            self.obj["predict"](
+                r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])
+            )
+        )

{learningmachine-0.2.3 → learningmachine-1.1.0}/learningmachine/utils.py

@@ -60,3 +60,15 @@ def check_install_r_pkg():
     if check_pkg_installed() == True:
         return 1
     return 0
+
+
+# Formatting object as a string
+def format_value(value):
+    if value is None:
+        return f"NULL"
+    if isinstance(value, str):
+        return f'"{value}"'
+    if isinstance(value, bool):
+        return f"{str(value).upper()}"
+    if isinstance(value, int) or isinstance(value, float):
+        return f"{value}"

{learningmachine-0.2.3 → learningmachine-1.1.0}/learningmachine.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 0.2.3
+Version: 1.1.0
 Summary: Machine Learning with uncertainty quantification and interpretability
 Home-page: https://github.com/Techtonique/learningmachine_python
 Author: T. Moudiki
 Author-email: thierry.moudiki@gmail.com
 License: BSD Clause Clear license
 Keywords: learningmachine
-Platform: UNKNOWN
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -18,6 +17,10 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.6
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rpy2>=3.4.5
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
 
 Machine Learning with uncertainty quantification and interpretability.
-

{learningmachine-0.2.3 → learningmachine-1.1.0}/learningmachine.egg-info/SOURCES.txt

@@ -16,7 +16,8 @@ docs/readme.rst
 docs/usage.rst
 learningmachine/__init__.py
 learningmachine/base.py
-learningmachine/basemodels.py
+learningmachine/classifier.py
+learningmachine/regression.py
 learningmachine/utils.py
 learningmachine.egg-info/PKG-INFO
 learningmachine.egg-info/SOURCES.txt

learningmachine-1.1.0/setup.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python
+
+import platform 
+import subprocess
+from os import path
+from setuptools import setup, find_packages
+
+# 0 - utility functions -----------------------------------------------
+
+def check_r_installed():
+    current_platform = platform.system()
+
+    if current_platform == "Windows":
+        # Check if R is installed on Windows by checking the registry
+        try:
+            subprocess.run(
+                ["reg", "query", "HKLM\\Software\\R-core\\R"], check=True
+            )
+            print("R is already installed on Windows.")
+            return True
+        except subprocess.CalledProcessError as e:
+            install_r(prompt=True)
+            return True            
+
+    elif current_platform in ("Darwin", "Linux"):
+        # Check if R is installed on Linux by checking if the 'R' executable is available
+
+        try:
+            # Try to find the 'R' executable using 'which' (if available)
+            subprocess.check_call(['which', 'R'])
+            print(f"R is already installed on {current_platform}.")
+            return True
+        except subprocess.CalledProcessError:
+            # 'which' might not be available, or R is not installed
+            print('R may not be installed.')
+            install_r(prompt=True) 
+            return True           
+                
+    else:
+
+        print("Unsupported platform (check manually: https://cloud.r-project.org/)")
+        return False
+
+def install_r(prompt=False):
+
+    current_platform = platform.system()
+
+    if prompt == True:
+        print("Installing R...")    
+        # choice = input("Would you like to install R? (yes/no): ").strip().lower()
+        # if choice == 'yes':
+        #     print("Installing R...")    
+        # elif choice == 'no':
+        #     print("No problem. R will not be installed.")
+        #     return 
+        # else:
+        #     print("Invalid input. Please enter 'yes' or 'no'.")
+        #     return
+
+    if current_platform == "Windows":
+        # Install R on Windows using PowerShell
+        install_command = "Start-Process powershell -Verb runAs -ArgumentList '-Command \"& {Invoke-WebRequest https://cran.r-project.org/bin/windows/base/R-4.1.2-win.exe -OutFile R.exe}; Start-Process R.exe -ArgumentList '/SILENT' -Wait}'"
+        subprocess.run(install_command, shell=True)
+
+    elif current_platform == "Linux":
+        # Install R on Linux using the appropriate package manager (e.g., apt-get)
+        install_command = (
+            "sudo apt update -qq && sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9"
+            + "&& sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/'"
+            + "&& sudo apt update"
+            + "&& sudo apt install r-base"
+        )
+        try: 
+            subprocess.run(install_command, shell=True)
+        except NotImplementedError as e:
+            print("Error installing R on this Linux distribution. Please check manually: https://cloud.r-project.org/")
+
+    elif current_platform == "Darwin":  # macOS
+        # Install R on macOS using Homebrew
+        install_command = "brew install r"
+        try: 
+            subprocess.run(install_command, shell=True)
+        except NotImplementedError as e:
+            print("Error installing R on macOS. Please check manually: https://cloud.r-project.org/")
+
+    else:
+        print("Unsupported platform. Unable to install R.")
+
+def load_learningmachine():
+    # Install R packages
+    commands1_lm = 'base::system.file(package = "learningmachine")'  # check "learningmachine" is installed
+    commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")'  # check "learningmachine" is installed locally
+    exec_commands1_lm = subprocess.run(
+        ["Rscript", "-e", commands1_lm], capture_output=True, text=True
+    )
+    exec_commands2_lm = subprocess.run(
+        ["Rscript", "-e", commands2_lm], capture_output=True, text=True
+    )
+    if (
+        len(exec_commands1_lm.stdout) == 7
+        and len(exec_commands2_lm.stdout) == 7
+    ):  # kind of convoluted, but works
+        print("Installing R packages along with 'learningmachine'...")
+        commands1 = [
+            'try(utils::install.packages(c("R6", "Rcpp", "skimr"), repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
+            'try(utils::install.packages("learningmachine", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=TRUE)',
+        ]
+        commands2 = [
+            'try(utils::install.packages(c("R6", "Rcpp", "skimr"), lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
+            'try(utils::install.packages("learningmachine", lib="./learningmachine_r", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=TRUE)',
+        ]
+        commands3 = [
+            'try(utils::install.packages(c("R6", "Rcpp", "remotes", "skimr"), repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
+            'try(remotes::install_github("Techtonique/learningmachine"), silent=TRUE)',
+        ]
+        commands4 = [
+            'try(utils::install.packages(c("R6", "Rcpp", "remotes", "skimr"), lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
+            'try(remotes::install_github("Techtonique/learningmachine", lib="./learningmachine_r", dependencies = TRUE), silent=TRUE)',
+        ]
+
+        try:
+            for cmd in commands3:
+                try: 
+                    subprocess.run(["Rscript", "-e", cmd])
+                except:
+                    pass
+        except NotImplementedError as e:  # can't install packages globally
+            try: 
+                subprocess.run(["mkdir", "learningmachine_r"])
+                for cmd in commands4:
+                    try: 
+                        subprocess.run(["Rscript", "-e", cmd])
+                    except:
+                        pass
+            except NotImplementedError as e:
+                try: 
+                    for cmd in commands1:
+                        try: 
+                            subprocess.run(["Rscript", "-e", cmd])
+                        except:
+                            pass
+                except NotImplementedError as e:
+                    subprocess.run(["mkdir", "learningmachine_r"])
+                    for cmd in commands2:
+                        try: 
+                            subprocess.run(["Rscript", "-e", cmd])
+                        except:
+                            pass
+
+        # try:
+        #     base.library(StrVector(["learningmachine"]))
+        # except (
+        #     NotImplementedError
+        # ) as e1:  # can't load the package from the global environment
+        #     try:
+        #         base.library(
+        #             StrVector(["learningmachine"]), lib_loc="learningmachine_r"
+        #         )
+        #     except NotImplementedError as e2:  # well, we tried
+        #         try:
+        #             r("try(library('learningmachine'), silence=TRUE)")
+        #         except (
+        #             NotImplementedError
+        #         ) as e3:  # well, we tried everything at this point
+        #             r(
+        #                 "try(library('learningmachine', lib.loc='learningmachine_r'), silence=TRUE)"
+        #             )
+
+# 1 - import Python packages -----------------------------------------------
+
+subprocess.run(["pip", "install", "rpy2"])
+try: 
+    subprocess.run(["pip", "install", "setuptools"])
+except ModuleNotFoundError as e:
+    print("Error installing setuptools. Please install setuptools manually.")
+
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import StrVector
+from rpy2.robjects import r
+
+base = importr("base")
+
+if not check_r_installed():
+    install_r()
+else:
+    print("R is already installed.")
+
+load_learningmachine()
+
+# 4 - Package setup -----------------------------------------------
+    
+"""The setup script."""
+
+setup(
+    author="T. Moudiki",
+    author_email="thierry.moudiki@gmail.com",
+    python_requires=">=3.6",
+    classifiers=[
+        "Development Status :: 2 - Pre-Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: BSD License",
+        "Natural Language :: English",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+    ],
+    description="Machine Learning with uncertainty quantification and interpretability",
+    install_requires=['numpy', 'pandas', 'rpy2>=3.4.5', 'scikit-learn', 'scipy'],
+    license="BSD Clause Clear license",
+    long_description="Machine Learning with uncertainty quantification and interpretability.",
+    include_package_data=True,
+    keywords="learningmachine",
+    name="learningmachine",
+    packages=find_packages(include=["learningmachine", "learningmachine.*"]),
+    test_suite="tests",
+    url="https://github.com/Techtonique/learningmachine_python",
+    version="1.1.0",
+    zip_safe=False,
+)

learningmachine-0.2.3/learningmachine/__init__.py

@@ -1,11 +0,0 @@
-"""Top-level package for learningmachine."""
-
-__author__ = """T. Moudiki"""
-__email__ = "thierry.moudiki@gmail.com"
-__version__ = "0.2.0"
-
-from .base import Base
-from .basemodels import BaseClassifier, BaseRegressor
-from .utils import check_install_r_pkg
-
-__all__ = ["check_install_r_pkg", "Base", "BaseClassifier", "BaseRegressor"]

learningmachine-0.2.3/learningmachine/base.py

@@ -1,75 +0,0 @@
-import subprocess
-from functools import lru_cache
-from rpy2.robjects import r
-from rpy2.robjects.packages import importr
-from rpy2.robjects.vectors import StrVector
-from sklearn.base import BaseEstimator
-
-base = importr("base")
-stats = importr("stats")
-
-
-@lru_cache(maxsize=32)
-def load_learningmachine():
-    # Install R packages
-    commands1_lm = 'base::system.file(package = "learningmachine")'  # check "learningmachine" is installed
-    commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")'  # check "learningmachine" is installed locally
-    exec_commands1_lm = subprocess.run(
-        ["Rscript", "-e", commands1_lm], capture_output=True, text=True
-    )
-    exec_commands2_lm = subprocess.run(
-        ["Rscript", "-e", commands2_lm], capture_output=True, text=True
-    )
-    if (
-        len(exec_commands1_lm.stdout) == 7
-        and len(exec_commands2_lm.stdout) == 7
-    ):  # kind of convoluted, but works
-        print("Installing R packages along with 'learningmachine'...")
-        commands1 = [
-            'try(utils::install.packages(c("R6", "Rcpp", "skimr"), repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
-            'try(utils::install.packages("learningmachine", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=TRUE)',
-        ]
-        commands2 = [
-            'try(utils::install.packages(c("R6", "Rcpp", "skimr"), lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
-            'try(utils::install.packages("learningmachine", lib="./learningmachine_r", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=TRUE)',
-        ]
-        try:
-            for cmd in commands1:
-                subprocess.run(["Rscript", "-e", cmd])
-        except Exception as e:  # can't install packages globally
-            subprocess.run(["mkdir", "learningmachine_r"])
-            for cmd in commands2:
-                subprocess.run(["Rscript", "-e", cmd])
-
-        try:
-            base.library(StrVector(["learningmachine"]))
-        except (
-            Exception
-        ) as e1:  # can't load the package from the global environment
-            try:
-                base.library(
-                    StrVector(["learningmachine"]), lib_loc="learningmachine_r"
-                )
-            except Exception as e2:  # well, we tried
-                try:
-                    r("try(library('learningmachine'), silence=TRUE)")
-                except (
-                    NotImplementedError
-                ) as e3:  # well, we tried everything at this point
-                    r(
-                        "try(library('learningmachine', lib.loc='learningmachine_r'), silence=TRUE)"
-                    )
-
-
-class Base(BaseEstimator):
-    """
-    Base class.
-    """
-
-    def __init__(self):
-        """
-        Initialize the model.
-        """
-        self.type_fit = None
-        self.obj = None
-        load_learningmachine()

learningmachine-0.2.3/learningmachine/basemodels.py

@@ -1,231 +0,0 @@
-import numpy as np
-import sklearn.metrics as skm
-from subprocess import run
-from rpy2.robjects import r
-from rpy2.robjects.packages import importr
-from rpy2.robjects.vectors import (
-    FloatMatrix,
-    FloatVector,
-    IntVector,
-    StrVector,
-)
-from sklearn.base import RegressorMixin, ClassifierMixin
-from .base import Base
-
-base = importr("base")
-stats = importr("stats")
-utils = importr("utils")
-
-
-class BaseRegressor(Base, RegressorMixin):
-    """
-    Base Regressor.
-    """
-
-    def __init__(self):
-        """
-        Initialize the model.
-        """
-        super().__init__()
-        self.type_fit = "regression"
-        self.obj = r("learningmachine::BaseRegressor$new()")
-
-    def fit(self, X, y):
-        """
-        Fit the model according to the given training data.
-        """
-        self.obj["fit"](
-            r.matrix(
-                FloatVector(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            ),
-            FloatVector(y),
-        )
-        return self
-
-    def predict(self, X):
-        """
-        Predict using the model.
-        """
-        return np.asarray(
-            self.obj["predict"](
-                r.matrix(
-                    FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-                )
-            )
-        )
-
-    def score(self, X, y, scoring=None, **kwargs):
-        """Score the model on test set features X and response y.
-
-        Parameters:
-
-            X: {array-like}, shape = [n_samples, n_features]
-                Training vectors, where n_samples is the number
-                of samples and n_features is the number of features
-
-            y: array-like, shape = [n_samples]
-                Target values
-
-            scoring: str
-                must be in ('explained_variance', 'neg_mean_absolute_error',
-                            'neg_mean_squared_error', 'neg_mean_squared_log_error',
-                            'neg_median_absolute_error', 'r2')
-
-            **kwargs: additional parameters to be passed to scoring functions
-
-        Returns:
-
-        model scores: {array-like}
-
-        """
-
-        preds = self.predict(X)
-
-        if type(preds) == tuple:  # if there are std. devs in the predictions
-            preds = preds[0]
-
-        if scoring is None:
-            scoring = "neg_mean_squared_error"
-
-        # check inputs
-        assert scoring in (
-            "explained_variance",
-            "neg_mean_absolute_error",
-            "neg_mean_squared_error",
-            "neg_mean_squared_log_error",
-            "neg_median_absolute_error",
-            "r2",
-        ), "'scoring' should be in ('explained_variance', 'neg_mean_absolute_error', \
-                           'neg_mean_squared_error', 'neg_mean_squared_log_error', \
-                           'neg_median_absolute_error', 'r2')"
-
-        scoring_options = {
-            "explained_variance": skm.explained_variance_score,
-            "neg_mean_absolute_error": skm.median_absolute_error,
-            "neg_mean_squared_error": skm.mean_squared_error,
-            "neg_mean_squared_log_error": skm.mean_squared_log_error,
-            "neg_median_absolute_error": skm.median_absolute_error,
-            "r2": skm.r2_score,
-        }
-
-        return scoring_options[scoring](y, preds, **kwargs)
-
-
-class BaseClassifier(Base, ClassifierMixin):
-    """
-    Base Classifier.
-    """
-
-    def __init__(self):
-        """
-        Initialize the model.
-        """
-        super().__init__()
-        self.type_fit = "classification"
-        self.obj = r("learningmachine::BaseClassifier$new()")
-
-    def fit(self, X, y):
-        """
-        Fit the model according to the given training data.
-        """
-        self.obj["fit"](
-            r.matrix(
-                FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            ),
-            base.as_factor(IntVector(y)),
-        )
-        self.classes_ = np.unique(y)
-        return self
-
-    def predict(self, X):
-        """
-        Predict classes using the model.
-        """
-        return np.asarray(
-            self.obj["predict"](
-                r.matrix(
-                    FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-                )
-            )
-        )
-
-    def predict_proba(self, X):
-        """
-        Predict probabilities using the model.
-        """
-        return np.asarray(
-            self.obj["predict_proba"](
-                r.matrix(
-                    FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-                )
-            )
-        )
-
-    def score(self, X, y, scoring=None, **kwargs):
-        """Score the model on test set features X and response y.
-
-        Parameters:
-
-            X: {array-like}, shape = [n_samples, n_features]
-                Training vectors, where n_samples is the number
-                of samples and n_features is the number of features
-
-            y: array-like, shape = [n_samples]
-                Target values
-
-            scoring: str
-                must be in ('accuracy', 'average_precision',
-                           'brier_score_loss', 'f1', 'f1_micro',
-                           'f1_macro', 'f1_weighted',  'f1_samples',
-                           'neg_log_loss', 'precision', 'recall',
-                           'roc_auc')
-
-            **kwargs: additional parameters to be passed to scoring functions
-
-        Returns:
-
-            model scores: {array-like}
-
-        """
-
-        preds = self.predict(X)
-
-        if scoring is None:
-            scoring = "accuracy"
-
-        # check inputs
-        assert scoring in (
-            "accuracy",
-            "average_precision",
-            "brier_score_loss",
-            "f1",
-            "f1_micro",
-            "f1_macro",
-            "f1_weighted",
-            "f1_samples",
-            "neg_log_loss",
-            "precision",
-            "recall",
-            "roc_auc",
-        ), "'scoring' should be in ('accuracy', 'average_precision', \
-                           'brier_score_loss', 'f1', 'f1_micro', \
-                           'f1_macro', 'f1_weighted',  'f1_samples', \
-                           'neg_log_loss', 'precision', 'recall', \
-                           'roc_auc')"
-
-        scoring_options = {
-            "accuracy": skm.accuracy_score,
-            "average_precision": skm.average_precision_score,
-            "brier_score_loss": skm.brier_score_loss,
-            "f1": skm.f1_score,
-            "f1_micro": skm.f1_score,
-            "f1_macro": skm.f1_score,
-            "f1_weighted": skm.f1_score,
-            "f1_samples": skm.f1_score,
-            "neg_log_loss": skm.log_loss,
-            "precision": skm.precision_score,
-            "recall": skm.recall_score,
-            "roc_auc": skm.roc_auc_score,
-        }
-
-        return scoring_options[scoring](y, preds, **kwargs)

learningmachine-0.2.3/setup.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-
-# 1 - import Python packages -----------------------------------------------
-
-import subprocess
-
-subprocess.run(["pip", "install", "rpy2"])
-
-from os import path
-import platform
-from setuptools import setup, find_packages
-
-
-# 2 - utility functions -----------------------------------------------
-
-def check_r_installed():
-    current_platform = platform.system()
-
-    if current_platform == "Windows":
-        # Check if R is installed on Windows by checking the registry
-        try:
-            subprocess.run(
-                ["reg", "query", "HKLM\\Software\\R-core\\R"], check=True
-            )
-            print("R is already installed on Windows.")
-            return True
-        except subprocess.CalledProcessError:
-            print(
-                "R is required but not installed on Windows (check manually: https://cloud.r-project.org/)."
-            )
-            return False
-
-    elif current_platform == "Linux":
-        # Check if R is installed on Linux by checking if the 'R' executable is available
-        try:
-            subprocess.run(["which", "R"], check=True)
-            print("R is already installed on Linux.")
-            return True
-        except subprocess.CalledProcessError:
-            print(
-                "R is required but not installed on Linux (check manually: https://cloud.r-project.org/)."
-            )
-            return False
-
-    elif current_platform == "Darwin":  # macOS
-        # Check if R is installed on macOS by checking if the 'R' executable is available
-        try:
-            subprocess.run(["which", "R"], check=True)
-            print("R is already installed on macOS.")
-            return True
-        except subprocess.CalledProcessError:
-            print(
-                "R is required but not installed on macOS (check manually: https://cloud.r-project.org/)."
-            )
-            return False
-
-    else:
-        print("Unsupported platform (check manually: https://cloud.r-project.org/)")
-        return False
-
-def install_r():
-    current_platform = platform.system()
-
-    if current_platform == "Windows":
-        # Install R on Windows using PowerShell
-        install_command = "Start-Process powershell -Verb runAs -ArgumentList '-Command \"& {Invoke-WebRequest https://cran.r-project.org/bin/windows/base/R-4.1.2-win.exe -OutFile R.exe}; Start-Process R.exe -ArgumentList '/SILENT' -Wait}'"
-        subprocess.run(install_command, shell=True)
-
-    elif current_platform == "Linux":
-        # Install R on Linux using the appropriate package manager (e.g., apt-get)
-        install_command = (
-            "sudo apt update -qq && sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9"
-            + "&& sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/'"
-            + "&& sudo apt update"
-            + "&& sudo apt install r-base"
-        )
-        try: 
-            subprocess.run(install_command, shell=True)
-        except Exception as e:
-            print("Error installing R on this Linux distribution. Please check manually: https://cloud.r-project.org/")
-
-    elif current_platform == "Darwin":  # macOS
-        # Install R on macOS using Homebrew
-        install_command = "brew install r"
-        try: 
-            subprocess.run(install_command, shell=True)
-        except Exception as e:
-            print("Error installing R on macOS. Please check manually: https://cloud.r-project.org/")
-
-    else:
-        print("Unsupported platform. Unable to install R.")
-
-
-# 3 - check if R is installed -----------------------------------------------
-        
-if not check_r_installed():
-    install_r()
-else:
-    print("R is already installed.")
-
-# 4 - Package setup -----------------------------------------------
-    
-"""The setup script."""
-
-setup(
-    author="T. Moudiki",
-    author_email="thierry.moudiki@gmail.com",
-    python_requires=">=3.6",
-    classifiers=[
-        "Development Status :: 2 - Pre-Alpha",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: BSD License",
-        "Natural Language :: English",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-    ],
-    description="Machine Learning with uncertainty quantification and interpretability",
-    install_requires=['numpy', 'pandas', 'rpy2>=3.4.5', 'scikit-learn', 'scipy'],
-    license="BSD Clause Clear license",
-    long_description="Machine Learning with uncertainty quantification and interpretability.",
-    include_package_data=True,
-    keywords="learningmachine",
-    name="learningmachine",
-    packages=find_packages(include=["learningmachine", "learningmachine.*"]),
-    test_suite="tests",
-    url="https://github.com/Techtonique/learningmachine_python",
-    version="0.2.3",
-    zip_safe=False,
-)