learningmachine 0.2.3__tar.gz → 1.1.2__tar.gz

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

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 0.2.3
+Version: 1.1.2
 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.2/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.2/learningmachine/base.py

@@ -0,0 +1,209 @@
+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:  # can't load the package from the global environment
+                try:
+                    base.library(
+                        StrVector(["learningmachine"]),
+                        lib_loc="learningmachine_r",
+                    )
+                except:  # well, we tried
+                    try:
+                        r("try(library('learningmachine'), silence=TRUE)")
+                    except:  # well, we tried everything at this point
+                        r(
+                            "try(library('learningmachine', lib.loc='learningmachine_r'), silence=TRUE)"
+                        )
+
+    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.2/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.2/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.2}/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.2}/learningmachine.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 0.2.3
+Version: 1.1.2
 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.2}/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-0.2.3 → learningmachine-1.1.2}/setup.py

@@ -1,17 +1,5 @@
-#!/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 -----------------------------------------------
+import subprocess
 
 def check_r_installed():
     current_platform = platform.system()
@@ -25,9 +13,7 @@ def check_r_installed():
             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/)."
-            )
+            print("R is not installed on Windows.")
             return False
 
     elif current_platform == "Linux":
@@ -37,9 +23,7 @@ def check_r_installed():
             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/)."
-            )
+            print("R is not installed on Linux.")
             return False
 
     elif current_platform == "Darwin":  # macOS
@@ -49,21 +33,20 @@ def check_r_installed():
             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/)."
-            )
+            print("R is not installed on macOS.")
             return False
 
     else:
-        print("Unsupported platform (check manually: https://cloud.r-project.org/)")
+        print("Unsupported platform. Unable to check for R installation.")
         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}'"
+        install_command = "Start-Process powershell -Verb subprocess.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":
@@ -72,31 +55,56 @@ def install_r():
             "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"
+            + "&& sudo apt -y 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/")
+        subprocess.run(install_command, shell=True)
 
     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/")
+        subprocess.run(install_command, shell=True)
 
     else:
-        print("Unsupported platform. Unable to install R.")
 
+        print("Unsupported platform. Unable to install R.")
 
-# 3 - check if R is installed -----------------------------------------------
-        
+def install_packages():
+    try:	
+        subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(devtools, dependencies=TRUE)"])
+        subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), dependencies=TRUE)"])
+        subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages('learningmachine', repos='https://techtonique.r-universe.dev', dependencies=TRUE)"])
+    except: 	
+        try: 
+            subprocess.run(["mkdir", "-p", "r-learningmachine"])		 
+            subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(devtools, lib='r-learningmachine', dependencies=TRUE)"])
+            subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), lib='r-learningmachine', dependencies=TRUE)"])
+            subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages('learningmachine', repos='https://techtonique.r-universe.dev', lib='r-learningmachine', dependencies=TRUE)"])
+        except:
+            try:	
+                subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(devtools, dependencies=TRUE)"])
+                subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), dependencies=TRUE)"])
+                subprocess.run(["sudo", "Rscript", "-e", "devtools::install_github('Techtonique/learningmachine')"])
+            except: 	
+                subprocess.run(["mkdir", "-p", "r-learningmachine"])		 
+                subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(devtools, lib='r-learningmachine', dependencies=TRUE)"])
+                subprocess.run(["sudo", "Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), lib='r-learningmachine', dependencies=TRUE)"])
+                subprocess.run(["sudo", "Rscript", "-e", "devtools::install_github('Techtonique/learningmachine', lib='r-learningmachine')"])
+
+
+# Check if R is installed; if not, install it
 if not check_r_installed():
+    print("Installing R...")
     install_r()
 else:
-    print("R is already installed.")
+    print("No installation needed.")
+
+install_packages()
+
+subprocess.run(["pip", "install", "rpy2"])
+
+from setuptools import setup, find_packages
+from codecs import open
+from os import path
 
 # 4 - Package setup -----------------------------------------------
     
@@ -126,6 +134,6 @@ setup(
     packages=find_packages(include=["learningmachine", "learningmachine.*"]),
     test_suite="tests",
     url="https://github.com/Techtonique/learningmachine_python",
-    version="0.2.3",
+    version="1.1.2",
     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)