learningmachine 2.0.1__tar.gz → 2.2.0__tar.gz

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

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

learningmachine-2.2.0/README.md

@@ -0,0 +1,118 @@
+# learningmachine 
+
+![PyPI](https://img.shields.io/pypi/v/learningmachine) [![PyPI - License](https://img.shields.io/pypi/l/learningmachine)](https://github.com/thierrymoudiki/learningmachine/blob/master/LICENSE) [![Downloads](https://pepy.tech/badge/learningmachine)](https://pepy.tech/project/learningmachine) 
+
+
+Machine Learning with uncertainty quantification and interpretability.
+
+## Install
+
+If R packages are not installed automatically when running `pip`, [install them manually](https://cloud.r-project.org/).
+
+**Development version**
+
+```bash
+!pip install git+https://github.com/Techtonique/learningmachine_python.git --verbose 
+```
+
+## Example
+
+See also:
+- [this notebook](https://colab.research.google.com/github/Techtonique/learningmachine_python/blob/main/learningmachine/demo/thierrymoudiki_20240401_calib.ipynb)
+- [this notebook](https://colab.research.google.com/github/Techtonique/learningmachine_python/blob/main/learningmachine/demo/thierrymoudiki_20240508_calib.ipynb)
+
+```python
+import learningmachine as lm
+import numpy as np
+import pandas as pd 
+from sklearn.datasets import load_diabetes, load_wine
+from sklearn.datasets import load_wine, load_iris, load_breast_cancer
+from sklearn.datasets import fetch_california_housing
+from sklearn.model_selection import train_test_split, cross_val_score
+from rpy2.robjects.vectors import FloatMatrix, FloatVector, StrVector
+from time import time
+from sklearn.metrics import mean_squared_error
+from math import sqrt
+
+
+# 1. Regression
+
+diabetes = load_diabetes()
+X = pd.DataFrame(diabetes.data[:150], columns=diabetes.feature_names)
+y = diabetes.target[:150]
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
+                                                    random_state=1213)
+
+print("\n ----- fitting krr ----- \n")   
+
+fit_obj2 = lm.Regressor(method="krr", pi_method="none")
+start = time()
+fit_obj2.fit(X_train, y_train, lambda_=0.05) # R's `lambda` is renamed as `lambda_` in Python as `lambda` is reserved 
+print("Elapsed time: ", time() - start)
+print(fit_obj2.summary(X=X_test, y=y_test))
+
+# 2. Classification
+
+datasets = [load_wine(), load_iris(), load_breast_cancer()]
+
+print("\n ----- fitting Kernel Ridge Regression ----- \n")   
+
+for dataset in datasets: 
+    
+    print(f"Description: {dataset.DESCR}")
+    X = pd.DataFrame(dataset.data, columns=dataset.feature_names)
+    y = dataset.target
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
+                                                        random_state=123)
+    
+    fit_obj = lm.Classifier(method = "krr", 
+                            pi_method="none")    
+
+    start = time()
+    fit_obj.fit(X_train, y_train, reg_lambda = 0.05)
+    print("Elapsed time: ", time() - start)
+
+    ## Compute accuracy
+    print(fit_obj.summary(X=X_test, y=y_test,                           
+                          class_index=0))
+    
+
+print("\n ----- fitting xgboost ----- \n")   
+
+for dataset in datasets: 
+    
+    print(f"Description: {dataset.DESCR}")
+    X = pd.DataFrame(dataset.data, columns=dataset.feature_names)
+    y = dataset.target
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
+                                                        random_state=123)
+    
+    fit_obj = lm.Classifier(method = "xgboost", 
+                            pi_method="kdesplitconformal",
+                            type_prediction_set = 'score',
+                            B=100)   
+                            
+    print("nb_hidden = 0 -----") # no hidden layer
+    start = time()
+    fit_obj.fit(X_train, y_train, nrounds=100, eta=0.05, max__depth=4, verbose=0) # dot ('.') in R parameters is replaced by '__'
+    print("Elapsed time: ", time() - start)
+    print(fit_obj.predict(X_test))
+    print(fit_obj.summary(X=X_test, y=y_test, 
+                          class_index=1)) # specify the class whose probability is of interest
+    
+    fit_obj = lm.Classifier(method = "xgboost", 
+                            pi_method="kdesplitconformal",
+                            type_prediction_set = 'score',
+                            nb_hidden = 5,
+                            B=100) 
+                            
+    print("nb_hidden = 5 -----") # hidden layer with 5 nodes 
+    start = time()
+    fit_obj.fit(X_train, y_train, nrounds=100, eta=0.05, max__depth=4, verbose=0) # dot ('.') in R parameters is replaced by '__'
+    print("Elapsed time: ", time() - start)
+    print(fit_obj.predict(X_test))
+    print(fit_obj.summary(X=X_test, y=y_test, 
+                          class_index=1)) # specify the class whose probability is of interest
+```

{learningmachine-2.0.1 → learningmachine-2.2.0}/learningmachine/base.py

@@ -1,10 +1,11 @@
+import pandas as pd 
 import sklearn.metrics as skm
 import subprocess
 from functools import lru_cache
 from sklearn.base import BaseEstimator
 from rpy2.robjects.vectors import (
     StrVector,
-    FloatMatrix,
+    ListVector,
     FloatVector,
     IntVector,
     FactorVector,
@@ -58,6 +59,7 @@ class Base(BaseEstimator):
         self.params = params
         self.seed = seed
         self.obj = None
+        self.column_names = None
 
     def load_learningmachine(self):
         # Install R packages
@@ -212,63 +214,43 @@ class Base(BaseEstimator):
 
             return scoring_options[scoring](y, preds, **kwargs)
 
-    def summary(self, X, y,                                 
-                class_index = None,   
-                level = 95,
-                show_progress = True,                                             
-                cl = None):
+    def summary(self, X, y,                
+                class_index = None,                                                                                                    
+                cl = None,
+                show_progress = True):
+        
+        if isinstance(X, pd.DataFrame): 
+            X_r = r.matrix(FloatVector(X.values.ravel()), 
+                                        byrow=True,
+                                        ncol=X.shape[1],
+                                        nrow=X.shape[0])  
+            X_r.colnames = StrVector(self.column_names)
+        else:
+            X_r = r.matrix(FloatVector(X.ravel()), 
+                                    byrow=True,
+                                    ncol=X.shape[1],
+                                    nrow=X.shape[0])   
                 
         if cl is None:
 
             if self.type == "classification":
 
-                assert class_index is not None, "class_index must be provided for classification models"      
+                assert class_index is not None, "For classifiers, 'class_index' must be provided"
 
-                self.obj["summary"](X = r.matrix(FloatVector(X.ravel()), 
-                                                byrow=True,
-                                                ncol=X.shape[1],
-                                                nrow=X.shape[0]),
+                return self.obj["summary"](X = X_r,
                                     y = FactorVector(IntVector(y)),
-                                    class_index = class_index + 1,
-                                    level = level,
+                                    class_index = int(class_index) + 1,
                                     show_progress = show_progress                                                                   
                 )
             
-            else: # regression
-
-                self.obj["summary"](X = r.matrix(FloatVector(X.ravel()), 
-                                                byrow=True,
-                                                ncol=X.shape[1],
-                                                nrow=X.shape[0]),
+            elif self.type == "regression":
+                
+                return self.obj["summary"](X = X_r,
                                     y = FloatVector(y),
-                                    level = level,
                                     show_progress = show_progress
-                ) 
+                )
+             
         else: # cl is not None, parallel computing
 
-            if self.type == "classification":
-
-                assert class_index is not None, "class_index must be provided for classification models"      
-                
-                self.obj["summary"](X = r.matrix(FloatVector(X.ravel()), 
-                                                byrow=True,
-                                                ncol=X.shape[1],
-                                                nrow=X.shape[0]),
-                                    y = FactorVector(IntVector(y)),
-                                    level = level,
-                                    show_progress = show_progress,
-                                    class_index = class_index + 1,
-                                    cl = cl
-                )
-            
-            else: # regression
+            pass 
 
-                self.obj["summary"](X = r.matrix(FloatVector(X.ravel()), 
-                                                byrow=True,
-                                                ncol=X.shape[1],
-                                                nrow=X.shape[0]),
-                                    y = FloatVector(y),
-                                    level = level,
-                                    show_progress = show_progress,
-                                    cl = cl
-                )

learningmachine-2.2.0/learningmachine/classifier.py

@@ -0,0 +1,161 @@
+import numpy as np
+import pandas as pd 
+import sklearn.metrics as skm
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import (
+    FloatVector,
+    IntVector,
+    FactorVector,
+    StrVector
+)
+from sklearn.base import ClassifierMixin
+from .base import Base
+from .utils import format_value, r_list_to_namedtuple
+
+base = importr("base")
+stats = importr("stats")
+utils = importr("utils")
+
+
+class Classifier(Base, ClassifierMixin):
+    """
+    Classifier.
+    """
+
+    def __init__(
+        self,
+        method="ranger",
+        pi_method="none",
+        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,            
+            B=B,
+            nb_hidden=nb_hidden,
+            nodes_sim=nodes_sim,
+            activ=activ,
+            seed=seed,
+        )
+
+        self.type_prediction_set=type_prediction_set          
+        
+        try: 
+            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)})")
+                
+    def fit(self, X, y, **kwargs):
+        """
+        Fit the model according to the given training data.
+        """
+        params_dict = {}
+
+        for k, v in kwargs.items():
+            if k == 'lambda_':
+                params_dict["lambda"] = v    
+            elif '__' in k: 
+                params_dict[k.replace('__', '.')] = v
+            else:
+                params_dict[k] = v 
+
+        if isinstance(X, pd.DataFrame):
+            self.column_names = X.columns
+            X_r = r.matrix(FloatVector(X.values.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])
+            X_r.colnames = StrVector(self.column_names)
+        else:
+            X_r = r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])
+        
+        if isinstance(y, pd.DataFrame) or isinstance(y, pd.Series):
+            y = y.values.ravel()                    
+
+        self.obj["fit"](X_r,
+            FactorVector(IntVector(y)),
+            **params_dict)
+        self.classes_ = np.unique(y)  # /!\ do not remove
+        return self
+    
+    def predict_proba(self, X):
+        """
+        Predict using the model.
+        """    
+
+        if isinstance(X, pd.DataFrame): 
+            X_r = r.matrix(FloatVector(X.values.ravel()), 
+                            byrow=True,
+                            ncol=X.shape[1],
+                            nrow=X.shape[0])
+            X_r.colnames = StrVector(self.column_names)
+        else: 
+            X_r = r.matrix(FloatVector(X.ravel()), 
+                            byrow=True,
+                            ncol=X.shape[1],
+                            nrow=X.shape[0])
+                    
+        if self.pi_method == "none": 
+            if isinstance(X, pd.DataFrame):                   
+                res = self.obj["predict_proba"](X_r)
+            return np.asarray(res)   
+        if isinstance(X, pd.DataFrame):                        
+            return r_list_to_namedtuple(self.obj["predict_proba"](X_r))
+
+    def predict(self, X):
+        """
+        Predict using the model.
+        """    
+
+        if isinstance(X, pd.DataFrame): 
+            X_r = r.matrix(FloatVector(X.values.ravel()), 
+                            byrow=True,
+                            ncol=X.shape[1],
+                            nrow=X.shape[0])
+            X_r.colnames = StrVector(self.column_names)
+        else: 
+            X_r = r.matrix(FloatVector(X.ravel()), 
+                            byrow=True,
+                            ncol=X.shape[1],
+                            nrow=X.shape[0])
+            
+        if self.pi_method == "none":                            
+            return (
+                np.asarray(
+                    self.obj["predict"](
+                        X_r
+                    )
+                ) - 1 
+            )
+                   
+        return r_list_to_namedtuple(self.obj["predict"](X_r))        
+        

learningmachine-2.2.0/learningmachine/regression.py

@@ -0,0 +1,124 @@
+import numpy as np
+import pandas as pd 
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import FloatVector, StrVector
+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():
+            if k == 'lambda_':
+                params_dict["lambda"] = v    
+            elif '__' in k: 
+                params_dict[k.replace('__', '.')] = v
+            else:
+                params_dict[k] = v 
+
+        if isinstance(X, pd.DataFrame):
+            self.column_names = X.columns
+            X_r = r.matrix(FloatVector(X.values.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])      
+            X_r.colnames = StrVector(self.column_names)
+        else:
+            X_r = r.matrix(FloatVector(X.ravel()), 
+                       byrow=True,
+                       ncol=X.shape[1],
+                       nrow=X.shape[0])               
+
+        if isinstance(y, pd.DataFrame) or isinstance(y, pd.Series):
+            y = y.values.ravel()            
+                    
+        self.obj["fit"](X_r,
+            FloatVector(y), 
+            **params_dict            
+        )
+        return self
+
+    def predict(self, X):
+        """
+        Predict using the model.
+        """
+
+        if isinstance(X, pd.DataFrame): 
+            X_r = r.matrix(FloatVector(X.values.ravel()), 
+                            byrow=True,
+                            ncol=X.shape[1],
+                            nrow=X.shape[0])
+            X_r.colnames = StrVector(self.column_names)
+        else: 
+            X_r = r.matrix(FloatVector(X.ravel()), 
+                            byrow=True,
+                            ncol=X.shape[1],
+                            nrow=X.shape[0])
+                    
+        if self.pi_method == "none":            
+                return(np.asarray(self.obj["predict"](
+                    X_r 
+                )))
+        return r_list_to_namedtuple(self.obj["predict"](
+                    X_r
+                ))
+        

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 2.0.1
+Version: 2.2.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.2.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.2.0",
     zip_safe=False,
 )

learningmachine-2.0.1/README.md

@@ -1,54 +0,0 @@
-# learningmachine 
-
-![PyPI](https://img.shields.io/pypi/v/learningmachine) [![PyPI - License](https://img.shields.io/pypi/l/learningmachine)](https://github.com/thierrymoudiki/learningmachine/blob/master/LICENSE) [![Downloads](https://pepy.tech/badge/learningmachine)](https://pepy.tech/project/learningmachine) 
-
-
-Machine Learning with uncertainty quantification and interpretability.
-
-## Install
-
-If R packages are not installed automatically when running `pip`, [install it manually](https://cloud.r-project.org/).
-
-**Development version**
-
-```bash
-!pip install git+https://github.com/Techtonique/learningmachine_python.git --verbose 
-```
-
-**Stable version**
-
-```bash
-!pip install learningmachine --verbose
-```
-
-## Example
-
-See also:
-- [this notebook](https://colab.research.google.com/github/Techtonique/learningmachine_python/blob/main/learningmachine/demo/thierrymoudiki_20240401_calib.ipynb)
-- [this notebook](https://colab.research.google.com/github/Techtonique/learningmachine_python/blob/main/learningmachine/demo/thierrymoudiki_20240508_calib.ipynb)
-
-```python
-import learningmachine as lm
-
-from sklearn.datasets import load_diabetes
-from sklearn.model_selection import train_test_split
-from time import time
-from sklearn.metrics import mean_squared_error
-
-# Regression (linear)
-fit_obj = lm.BaseRegressor()
-diabetes = load_diabetes()
-X = diabetes.data[:150]
-y = diabetes.target[:150]
-
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
-                                                    random_state=1213)
-
-start = time()
-fit_obj.fit(X_train, y_train)
-print("Elapsed time: ", time() - start)
-
-## Compute RMSE
-rms1 = sqrt(mean_squared_error(y_test, fit_obj.predict(X_test), squared=False))
-print(rms1)
-```

learningmachine-2.0.1/learningmachine/classifier.py

@@ -1,140 +0,0 @@
-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 (
-    FloatVector,
-    IntVector,
-    FactorVector,
-    ListVector
-)
-from sklearn.base import ClassifierMixin
-from .base import Base
-from .utils import format_value, r_list_to_namedtuple
-
-base = importr("base")
-stats = importr("stats")
-utils = importr("utils")
-
-
-class Classifier(Base, ClassifierMixin):
-    """
-    Classifier.
-    """
-
-    def __init__(
-        self,
-        method="ranger",
-        pi_method="none",
-        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,            
-            B=B,
-            nb_hidden=nb_hidden,
-            nodes_sim=nodes_sim,
-            activ=activ,
-            seed=seed,
-        )
-
-        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(
-                 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.
-        """
-        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]),
-            FactorVector(IntVector(y)),
-            **params_dict)
-        self.classes_ = np.unique(y)  # /!\ do not remove
-        return self
-    
-    def predict_proba(self, X):
-        """
-        Predict using the model.
-        """    
-        if self.pi_method == "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)        
-        return r_list_to_namedtuple(self.obj["predict_proba"](
-                    r.matrix(FloatVector(X.ravel()), 
-                byrow=True,
-                ncol=X.shape[1],
-                nrow=X.shape[0])
-                ))
-
-    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])
-                )
-            ) - 1 
-        )
-        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/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])
-            ))
-