learningmachine 2.0.1__tar.gz → 2.1.0__tar.gz

{learningmachine-2.0.1 → learningmachine-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 2.0.1
+Version: 2.1.0
 Summary: Machine Learning with uncertainty quantification and interpretability
 Home-page: https://github.com/Techtonique/learningmachine_python
 Author: T. Moudiki

{learningmachine-2.0.1 → learningmachine-2.1.0}/learningmachine/classifier.py

@@ -50,37 +50,29 @@ class Classifier(Base, ClassifierMixin):
             seed=seed,
         )
 
-        self.type_prediction_set=type_prediction_set
-
+        self.type_prediction_set=type_prediction_set        
+        
         try: 
-            self.obj = r(f"suppressWarnings(suppressMessages(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:
-            self.obj = r(
+            r_obj_command = (
+    'suppressWarnings(suppressMessages(library(learningmachine))); '
+    'Classifier$new(method = ' + str(format_value(self.method)) + ', '
+    'pi_method = ' + str(format_value(self.pi_method)) + ', '
+    'level = ' + str(format_value(self.level)) + ', '
+    'type_prediction_set = ' + str(format_value(self.type_prediction_set)) + ', '
+    'B = ' + str(format_value(self.B)) + ', '
+    'nb_hidden = ' + str(format_value(self.nb_hidden)) + ', '
+    'nodes_sim = ' + str(format_value(self.nodes_sim)) + ', '
+    'activ = ' + str(format_value(self.activ)) + ', '
+    'seed = ' + str(format_value(self.seed)) + ')')
+            self.obj = r(r_obj_command)
+        except Exception:
+            try:
+                self.obj = r(f"suppressWarnings(suppressMessages(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 Exception:
+                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)})"
              )
-
-        # 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:
-        #         base.suppressWarnings(base.suppressMessages(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"""
-        #                         suppressWarnings(suppressMessages(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, **kwargs):
         """
         Fit the model according to the given training data.

learningmachine-2.1.0/learningmachine/regression.py

@@ -0,0 +1,100 @@
+import numpy as np
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import FloatVector, ListVector
+from sklearn.base import RegressorMixin
+from .base import Base
+from .utils import format_value, r_list_to_namedtuple
+
+base = importr("base")
+stats = importr("stats")
+utils = importr("utils")
+
+
+class Regressor(Base, RegressorMixin):
+    """
+    Regressor.
+    """
+
+    def __init__(
+            self,
+        method="ranger",
+        pi_method="none",
+        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: 
+            r_obj_command = (
+    'suppressWarnings(suppressMessages(library(learningmachine))); '
+    'Regressor$new(method = ' + str(format_value(self.method)) + ', '
+    'pi_method = ' + str(format_value(self.pi_method)) + ', '
+    'level = ' + str(format_value(self.level)) + ', '
+    'B = ' + str(format_value(self.B)) + ', '
+    'nb_hidden = ' + str(format_value(self.nb_hidden)) + ', '
+    'nodes_sim = ' + str(format_value(self.nodes_sim)) + ', '
+    'activ = ' + str(format_value(self.activ)) + ', '
+    'seed = ' + str(format_value(self.seed)) + ')')
+            self.obj = r(r_obj_command)
+        except Exception: 
+            try:                 
+                self.obj = r(f"suppressWarnings(suppressMessages(library(learningmachine))); Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, 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 Exception: 
+                self.obj = r(
+                    f"learningmachine::Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, 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)})"
+                )
+        
+    def fit(self, X, y, **kwargs):
+        """
+        Fit the model according to the given training data.
+        """        
+        params_dict = {}
+        for k, v in kwargs.items():
+            params_dict[k.replace('_', '.')] = v
+        self.obj["fit"](
+            r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0]),
+            FloatVector(y), 
+            **params_dict            
+        )
+        return self
+
+    def predict(self, X):
+        """
+        Predict using the model.
+        """
+        if self.pi_method == "none":
+            return(np.asarray(self.obj["predict"](
+                r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])
+            )))
+        return r_list_to_namedtuple(self.obj["predict"](
+                r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])
+            ))
+        

{learningmachine-2.0.1 → learningmachine-2.1.0}/learningmachine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 2.0.1
+Version: 2.1.0
 Summary: Machine Learning with uncertainty quantification and interpretability
 Home-page: https://github.com/Techtonique/learningmachine_python
 Author: T. Moudiki

{learningmachine-2.0.1 → learningmachine-2.1.0}/setup.py

@@ -72,34 +72,50 @@ def install_packages():
     try: 
         subprocess.run(["Rscript", "-e", "utils::install.packages('remotes', dependencies=TRUE)"])
         subprocess.run(["Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), dependencies=TRUE)"])
-        #subprocess.run(["Rscript", "-e", "utils::install.packages('learningmachine', repos='https://techtonique.r-universe.dev', dependencies=TRUE)"])
         subprocess.run(["Rscript", "-e", "remotes::install_github('Techtonique/learningmachine')"])        
-    except:
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred: {e}")
+        print(f"Return code: {e.returncode}")
+        print(f"Output: {e.output}")
+        print(f"Stderr: {e.stderr}")
         try:
             subprocess.run(["mkdir", "-p", "r-learningmachine"])		 
             subprocess.run(["Rscript", "-e", "utils::install.packages('remotes', lib='r-learningmachine', dependencies=TRUE)"])
             subprocess.run(["Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), lib='r-learningmachine', dependencies=TRUE)"])
-            #subprocess.run(["Rscript", "-e", "utils::install.packages('learningmachine', repos='https://techtonique.r-universe.dev', lib='r-learningmachine', dependencies=TRUE)"]) 
             subprocess.run(["Rscript", "-e", "remotes::install_github('Techtonique/learningmachine', lib='r-learningmachine')"])
-        except:             
+        except subprocess.CalledProcessError as e:    
+            print(f"Error occurred: {e}")
+            print(f"Return code: {e.returncode}")
+            print(f"Output: {e.output}")
+            print(f"Stderr: {e.stderr}")        
             try:	
                 subprocess.run(["Rscript", "-e", "utils::install.packages('remotes', dependencies=TRUE)"])
                 subprocess.run(["Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), dependencies=TRUE)"])
-                #subprocess.run(["Rscript", "-e", "utils::install.packages('learningmachine', repos='https://techtonique.r-universe.dev', dependencies=TRUE)"])
                 subprocess.run(["Rscript", "-e", "remotes::install_github('Techtonique/learningmachine')"])        
-            except: 	
+            except subprocess.CalledProcessError as e:	
+                print(f"Error occurred: {e}")
+                print(f"Return code: {e.returncode}")
+                print(f"Output: {e.output}")
+                print(f"Stderr: {e.stderr}")        
                 try: 
                     subprocess.run(["mkdir", "-p", "r-learningmachine"])		 
                     subprocess.run(["Rscript", "-e", "utils::install.packages('remotes', lib='r-learningmachine', dependencies=TRUE)"])
                     subprocess.run(["Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), lib='r-learningmachine', dependencies=TRUE)"])
-                    #subprocess.run(["Rscript", "-e", "utils::install.packages('learningmachine', repos='https://techtonique.r-universe.dev', lib='r-learningmachine', dependencies=TRUE)"])
                     subprocess.run(["Rscript", "-e", "remotes::install_github('Techtonique/learningmachine', lib='r-learningmachine')"])
-                except:
+                except subprocess.CalledProcessError as e:
+                    print(f"Error occurred: {e}")
+                    print(f"Return code: {e.returncode}")
+                    print(f"Output: {e.output}")
+                    print(f"Stderr: {e.stderr}")        
                     try:	
                         subprocess.run(["Rscript", "-e", "utils::install.packages('remotes', dependencies=TRUE)"])
                         subprocess.run(["Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), dependencies=TRUE)"])
                         subprocess.run(["Rscript", "-e", "remotes::install_github('Techtonique/learningmachine')"])
-                    except: 	
+                    except subprocess.CalledProcessError as e:	
+                        print(f"Error occurred: {e}")
+                        print(f"Return code: {e.returncode}")
+                        print(f"Output: {e.output}")
+                        print(f"Stderr: {e.stderr}")        
                         subprocess.run(["mkdir", "-p", "r-learningmachine"])		 
                         subprocess.run(["Rscript", "-e", "utils::install.packages('remotes', lib='r-learningmachine', dependencies=TRUE)"])
                         subprocess.run(["Rscript", "-e", "utils::install.packages(c('R6', 'Rcpp', 'skimr'), lib='r-learningmachine', dependencies=TRUE)"])
@@ -108,10 +124,14 @@ def install_packages():
 
 # Check if R is installed; if not, install it
 if not check_r_installed():
-    print("Installing R...")
-    install_r()
+    install_r_prompt = int(input("Try installing R? 1-yes, 2-no"))
+    if install_r_prompt == 1: 
+        print("Installing R...")
+        install_r()
+    else:
+        raise ValueError('Try installing R manually first.')
 else:
-    print("No installation needed.")
+    print("No R installation needed.")
 
 install_packages()
 
@@ -149,6 +169,6 @@ setup(
     packages=find_packages(include=["learningmachine", "learningmachine.*"]),
     test_suite="tests",
     url="https://github.com/Techtonique/learningmachine_python",
-    version="2.0.1",
+    version="2.1.0",
     zip_safe=False,
 )

learningmachine-2.0.1/learningmachine/regression.py

@@ -1,109 +0,0 @@
-import numpy as np
-from rpy2.robjects import r
-from rpy2.robjects.packages import importr
-from rpy2.robjects.vectors import FloatVector, ListVector
-from sklearn.base import RegressorMixin
-from .base import Base
-from .utils import format_value, r_list_to_namedtuple
-
-base = importr("base")
-stats = importr("stats")
-utils = importr("utils")
-
-
-class Regressor(Base, RegressorMixin):
-    """
-    Regressor.
-    """
-
-    def __init__(
-            self,
-        method="ranger",
-        pi_method="none",
-        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.obj = r(f"suppressWarnings(suppressMessages(library(learningmachine))); Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, 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: 
-            self.obj = r(
-                 f"learningmachine::Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, 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)})"
-            )
-        
-        # 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)}, 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:                
-        #         base.suppressWarnings(base.suppressMessages(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)}, 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"""
-        #                             suppressWarnings(suppressMessages(library(learningmachine))); 
-        #                             Regressor$new(method = {format_value(self.method)}, pi_method = {format_value(self.pi_method)}, level = {format_value(self.level)}, 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, **kwargs):
-        """
-        Fit the model according to the given training data.
-        """        
-        params_dict = {}
-        for k, v in kwargs.items():
-            params_dict[k.replace('_', '.')] = v
-        self.obj["fit"](
-            r.matrix(FloatVector(X.ravel()), 
-                       byrow=True,
-                       ncol=X.shape[1],
-                       nrow=X.shape[0]),
-            FloatVector(y), 
-            **params_dict            
-        )
-        return self
-
-    def predict(self, X):
-        """
-        Predict using the model.
-        """
-        if self.pi_method == "none":
-            return(np.asarray(self.obj["predict"](
-                r.matrix(FloatVector(X.ravel()), 
-                       byrow=True,
-                       ncol=X.shape[1],
-                       nrow=X.shape[0])
-            )))
-        return r_list_to_namedtuple(self.obj["predict"](
-                r.matrix(FloatVector(X.ravel()), 
-                       byrow=True,
-                       ncol=X.shape[1],
-                       nrow=X.shape[0])
-            ))
-