learningmachine 1.1.2__tar.gz → 2.0.1__tar.gz

learningmachine-2.0.1/LICENSE

@@ -0,0 +1,32 @@
+The Clear BSD License
+
+Copyright (c) [2023-2024] [T. Moudiki]
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted (subject to the limitations in the disclaimer
+below) provided that the following conditions are met:
+
+     * Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+     * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+     * Neither the name of the copyright holder nor the names of its
+     contributors may be used to endorse or promote products derived from this
+     software without specific prior written permission.
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

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

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

learningmachine-2.0.1/README.md

@@ -0,0 +1,54 @@
+# 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-1.1.2 → learningmachine-2.0.1}/learningmachine/base.py

@@ -2,9 +2,16 @@ 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.vectors import (
+    StrVector,
+    FloatMatrix,
+    FloatVector,
+    IntVector,
+    FactorVector,
+)
 from rpy2.robjects.packages import importr
 from rpy2.robjects import r
+from rpy2.robjects import NULL as rNULL
 
 base = importr("base")
 stats = importr("stats")
@@ -23,7 +30,6 @@ class Base(BaseEstimator):
         method="ranger",
         pi_method="kdesplitconformal",
         level=95,
-        type_prediction_set="score",
         B=100,
         nb_hidden = 0,
         nodes_sim = "sobol",
@@ -40,7 +46,6 @@ class Base(BaseEstimator):
         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"), \
@@ -54,7 +59,6 @@ class Base(BaseEstimator):
         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
@@ -96,10 +100,10 @@ class Base(BaseEstimator):
                     )
                 except:  # well, we tried
                     try:
-                        r("try(library('learningmachine'), silence=TRUE)")
+                        r("try(suppressWarnings(suppressMessages(library('learningmachine'))), silence=TRUE)")
                     except:  # well, we tried everything at this point
                         r(
-                            "try(library('learningmachine', lib.loc='learningmachine_r'), silence=TRUE)"
+                            "try(suppressWarnings(suppressMessages(library('learningmachine', lib.loc='learningmachine_r'))), silence=TRUE)"
                         )
 
     def score(self, X, y, scoring=None, **kwargs):
@@ -172,7 +176,7 @@ class Base(BaseEstimator):
             try:
                 preds = preds.ravel().astype(int)
                 return scoring_options[scoring](y, preds, **kwargs)
-            except:
+            except TypeError:
                 return scoring_options[scoring](y, preds, **kwargs)
 
         if self.type == "regression":
@@ -207,3 +211,64 @@ 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):
+                
+        if cl is None:
+
+            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)),
+                                    class_index = class_index + 1,
+                                    level = level,
+                                    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]),
+                                    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
+
+                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.0.1/learningmachine/classifier.py

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,109 @@
+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])
+            ))
+        

{learningmachine-1.1.2 → learningmachine-2.0.1}/learningmachine/utils.py

@@ -1,5 +1,8 @@
+import numpy as np 
 import subprocess
 from rpy2.robjects import r
+from rpy2.robjects import NULL as rNULL
+from collections import namedtuple
 
 
 def check_pkg_installed():
@@ -71,4 +74,22 @@ def format_value(value):
     if isinstance(value, bool):
         return f"{str(value).upper()}"
     if isinstance(value, int) or isinstance(value, float):
-        return f"{value}"
+        return f"{value}"
+    
+# R list to namedtuple
+def r_list_to_namedtuple(r_list):
+    # Extract the names from the R list        
+    if r_list.names is rNULL:
+        ##names = [f'obs{i+1}' for i in range(len(r_list))]
+        # Define a namedtuple type based on the names in the R list
+        ##DescribeResult = namedtuple('DescribeResult', names)    
+        # Extract elements from the R list and create a namedtuple
+        ##elements = {name: r_list.rx2(i+1) for i, name in enumerate(names)}    
+        ##return DescribeResult(**elements)
+        return tuple([[int(r_list.rx2(i+1)[j]) for j in range(len(r_list.rx2(i+1)))] for i in range(len(r_list))])
+    names = r_list.names
+    # Define a namedtuple type based on the names in the R list
+    DescribeResult = namedtuple('DescribeResult', names)    
+    # Extract elements from the R list and create a namedtuple
+    elements = {name: np.asarray(r_list.rx2(name)) for name in names}    
+    return DescribeResult(**elements)

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

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

{learningmachine-1.1.2 → learningmachine-2.0.1}/learningmachine.egg-info/SOURCES.txt

@@ -2,7 +2,7 @@ CONTRIBUTING.rst
 HISTORY.rst
 LICENSE
 MANIFEST.in
-README.rst
+README.md
 setup.cfg
 setup.py
 docs/Makefile

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

@@ -69,26 +69,41 @@ def install_r():
         print("Unsupported platform. Unable to install R.")
 
 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: 
+    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:
+        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:
+            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:             
             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')"])
+                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: 	
-                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')"])
+                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:
+                    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: 	
+                        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", "remotes::install_github('Techtonique/learningmachine', lib='r-learningmachine')"])
 
 
 # Check if R is installed; if not, install it
@@ -134,6 +149,6 @@ setup(
     packages=find_packages(include=["learningmachine", "learningmachine.*"]),
     test_suite="tests",
     url="https://github.com/Techtonique/learningmachine_python",
-    version="1.1.2",
+    version="2.0.1",
     zip_safe=False,
 )

learningmachine-1.1.2/LICENSE

@@ -1,32 +0,0 @@
-
-
-BSD License
-
-Copyright (c) 2024, T. Moudiki
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this
-  list of conditions and the following disclaimer in the documentation and/or
-  other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from this
-  software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-OF THE POSSIBILITY OF SUCH DAMAGE.
-

learningmachine-1.1.2/README.rst

@@ -1,37 +0,0 @@
-===============
-learningmachine
-===============
-
-
-.. image:: https://img.shields.io/pypi/v/learningmachine.svg
-        :target: https://pypi.python.org/pypi/learningmachine
-
-.. image:: https://img.shields.io/travis/Techtonique/learningmachine.svg
-        :target: https://travis-ci.com/Techtonique/learningmachine
-
-.. image:: https://readthedocs.org/projects/learningmachine/badge/?version=latest
-        :target: https://learningmachine.readthedocs.io/en/latest/?version=latest
-        :alt: Documentation Status
-
-
-
-
-Machine Learning with uncertainty quantification and interpretability
-
-
-* Free software: BSD license
-* Documentation: https://learningmachine.readthedocs.io.
-
-
-Features
---------
-
-* TODO
-
-Credits
--------
-
-This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template.
-
-.. _Cookiecutter: https://github.com/audreyr/cookiecutter
-.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage

learningmachine-1.1.2/learningmachine/classifier.py

@@ -1,134 +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 (
-    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

@@ -1,92 +0,0 @@
-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])
-            )
-        )