learningmachine 2.2.0__tar.gz → 2.3.0__tar.gz

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

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

{learningmachine-2.2.0 → learningmachine-2.3.0}/README.md

@@ -1,6 +1,6 @@
 # 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) 
+![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) [![Documentation](https://img.shields.io/badge/documentation-is_here-green)](https://techtonique.github.io/learningmachine/)
 
 
 Machine Learning with uncertainty quantification and interpretability.

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

@@ -1,4 +1,4 @@
-import pandas as pd 
+import pandas as pd
 import sklearn.metrics as skm
 import subprocess
 from functools import lru_cache
@@ -32,9 +32,9 @@ class Base(BaseEstimator):
         pi_method="kdesplitconformal",
         level=95,
         B=100,
-        nb_hidden = 0,
-        nodes_sim = "sobol",
-        activ = "relu",
+        nb_hidden=0,
+        nodes_sim="sobol",
+        activ="relu",
         params=None,
         seed=123,
     ):
@@ -47,15 +47,23 @@ class Base(BaseEstimator):
         self.method = method
         self.pi_method = pi_method
         self.level = level
-        self.B = B        
+        self.B = B
         self.nb_hidden = nb_hidden
-        assert nodes_sim in ("sobol", "halton", "unif"), \
-            "must have nodes_sim in ('sobol', 'halton', 'unif')"
+        assert nodes_sim in (
+            "sobol",
+            "halton",
+            "unif",
+        ), "must have nodes_sim in ('sobol', 'halton', 'unif')"
         self.nodes_sim = "sobol"
-        assert activ in ("relu", "sigmoid", "tanh",
-                             "leakyrelu", "elu", "linear"), \
-                            "must have activ in ('relu', 'sigmoid', 'tanh', 'leakyrelu', 'elu', 'linear')"
-        self.activ = activ 
+        assert activ in (
+            "relu",
+            "sigmoid",
+            "tanh",
+            "leakyrelu",
+            "elu",
+            "linear",
+        ), "must have activ in ('relu', 'sigmoid', 'tanh', 'leakyrelu', 'elu', 'linear')"
+        self.activ = activ
         self.params = params
         self.seed = seed
         self.obj = None
@@ -63,8 +71,10 @@ class Base(BaseEstimator):
 
     def load_learningmachine(self):
         # Install R packages
-        commands1_lm = 'base::system.file(package = "learningmachine")'  # check "learningmachine" is installed
-        commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")'  # check "learningmachine" is installed locally
+        # check "learningmachine" is installed
+        commands1_lm = 'base::system.file(package = "learningmachine")'
+        # check "learningmachine" is installed locally
+        commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")'
         exec_commands1_lm = subprocess.run(
             ["Rscript", "-e", commands1_lm], capture_output=True, text=True
         )
@@ -102,7 +112,9 @@ class Base(BaseEstimator):
                     )
                 except:  # well, we tried
                     try:
-                        r("try(suppressWarnings(suppressMessages(library('learningmachine'))), silence=TRUE)")
+                        r(
+                            "try(suppressWarnings(suppressMessages(library('learningmachine'))), silence=TRUE)"
+                        )
                     except:  # well, we tried everything at this point
                         r(
                             "try(suppressWarnings(suppressMessages(library('learningmachine', lib.loc='learningmachine_r'))), silence=TRUE)"
@@ -214,43 +226,57 @@ class Base(BaseEstimator):
 
             return scoring_options[scoring](y, preds, **kwargs)
 
-    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])  
+    def summary(
+        self,
+        X,
+        y,
+        class_index=None,
+        cl=None,
+        type_ci="student",
+        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])   
-                
+            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, "For classifiers, 'class_index' must be provided"
+                assert (
+                    class_index is not None
+                ), "For classifiers, 'class_index' must be provided"
 
-                return self.obj["summary"](X = X_r,
-                                    y = FactorVector(IntVector(y)),
-                                    class_index = int(class_index) + 1,
-                                    show_progress = show_progress                                                                   
+                return self.obj["summary"](
+                    X=X_r,
+                    y=FactorVector(IntVector(y)),
+                    class_index=int(class_index) + 1,
+                    type_ci=StrVector([type_ci]),
+                    show_progress=show_progress,
                 )
-            
+
             elif self.type == "regression":
-                
-                return self.obj["summary"](X = X_r,
-                                    y = FloatVector(y),
-                                    show_progress = show_progress
+
+                return self.obj["summary"](
+                    X=X_r,
+                    y=FloatVector(y),
+                    type_ci=StrVector([type_ci]),
+                    show_progress=show_progress,
                 )
-             
-        else: # cl is not None, parallel computing
 
-            pass 
+        else:  # cl is not None, parallel computing
 
+            pass

learningmachine-2.3.0/learningmachine/classifier.py

@@ -0,0 +1,188 @@
+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.3.0/learningmachine/regression.py

@@ -0,0 +1,157 @@
+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))
+
+    def update(self, newx, newy):
+        """
+        update the model.
+        """
+
+        newx_r = base.as_vector(FloatVector(newx))
+
+        self.obj["update"](newx_r, base.as_numeric(FloatVector([newy])))
+
+        return self

{learningmachine-2.2.0 → learningmachine-2.3.0}/learningmachine/utils.py

@@ -1,4 +1,4 @@
-import numpy as np 
+import numpy as np
 import subprocess
 from rpy2.robjects import r
 from rpy2.robjects import NULL as rNULL
@@ -75,21 +75,30 @@ def format_value(value):
         return f"{str(value).upper()}"
     if isinstance(value, int) or isinstance(value, float):
         return f"{value}"
-    
+
+
 # R list to namedtuple
 def r_list_to_namedtuple(r_list):
-    # Extract the names from the 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))]
+        # 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)    
+        # 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))])
+        # 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)    
+    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)
+    elements = {name: np.asarray(r_list.rx2(name)) for name in names}
+    return DescribeResult(**elements)

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

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

{learningmachine-2.2.0 → learningmachine-2.3.0}/setup.py

@@ -169,6 +169,6 @@ setup(
     packages=find_packages(include=["learningmachine", "learningmachine.*"]),
     test_suite="tests",
     url="https://github.com/Techtonique/learningmachine_python",
-    version="2.2.0",
+    version="2.3.0",
     zip_safe=False,
 )

learningmachine-2.2.0/learningmachine/classifier.py

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

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