learningmachine 1.1.0__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.0 → learningmachine-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 1.1.0
+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.0 → 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
@@ -88,22 +92,18 @@ class Base(BaseEstimator):
 
             try:
                 base.library(StrVector(["learningmachine"]))
-            except (
-                NotImplementedError
-            ) as e1:  # can't load the package from the global environment
+            except:  # can't load the package from the global environment
                 try:
                     base.library(
                         StrVector(["learningmachine"]),
                         lib_loc="learningmachine_r",
                     )
-                except NotImplementedError as e2:  # well, we tried
+                except:  # well, we tried
                     try:
-                        r("try(library('learningmachine'), silence=FALSE)")
-                    except (
-                        NotImplementedError
-                    ) as e3:  # well, we tried everything at this point
+                        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=FALSE)"
+                            "try(suppressWarnings(suppressMessages(library('learningmachine', lib.loc='learningmachine_r'))), silence=TRUE)"
                         )
 
     def score(self, X, y, scoring=None, **kwargs):
@@ -176,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":
@@ -211,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.0 → 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.0 → learningmachine-2.0.1}/learningmachine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 1.1.0
+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.0 → 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-2.0.1/setup.py

@@ -0,0 +1,154 @@
+import platform
+import subprocess
+
+def check_r_installed():
+    current_platform = platform.system()
+
+    if current_platform == "Windows":
+        # Check if R is installed on Windows by checking the registry
+        try:
+            subprocess.run(
+                ["reg", "query", "HKLM\\Software\\R-core\\R"], check=True
+            )
+            print("R is already installed on Windows.")
+            return True
+        except subprocess.CalledProcessError:
+            print("R is not installed on Windows.")
+            return False
+
+    elif current_platform == "Linux":
+        # Check if R is installed on Linux by checking if the 'R' executable is available
+        try:
+            subprocess.run(["which", "R"], check=True)
+            print("R is already installed on Linux.")
+            return True
+        except subprocess.CalledProcessError:
+            print("R is not installed on Linux.")
+            return False
+
+    elif current_platform == "Darwin":  # macOS
+        # Check if R is installed on macOS by checking if the 'R' executable is available
+        try:
+            subprocess.run(["which", "R"], check=True)
+            print("R is already installed on macOS.")
+            return True
+        except subprocess.CalledProcessError:
+            print("R is not installed on macOS.")
+            return False
+
+    else:
+        print("Unsupported platform. Unable to check for R installation.")
+        return False
+
+def install_r():
+
+    current_platform = platform.system()
+
+    if current_platform == "Windows":
+        # Install R on Windows using PowerShell
+        install_command = "Start-Process powershell -Verb subprocess.runAs -ArgumentList '-Command \"& {Invoke-WebRequest https://cran.r-project.org/bin/windows/base/R-4.1.2-win.exe -OutFile R.exe}; Start-Process R.exe -ArgumentList '/SILENT' -Wait}'"
+        subprocess.run(install_command, shell=True)
+
+    elif current_platform == "Linux":
+        # Install R on Linux using the appropriate package manager (e.g., apt-get)
+        install_command = (
+            "sudo apt update -qq && sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9"
+            + "&& sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/'"
+            + "&& sudo apt update"
+            + "&& sudo apt -y install r-base"
+        )
+        subprocess.run(install_command, shell=True)
+
+    elif current_platform == "Darwin":  # macOS
+        # Install R on macOS using Homebrew
+        install_command = "brew install r"
+        subprocess.run(install_command, shell=True)
+
+    else:
+
+        print("Unsupported platform. Unable to install R.")
+
+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:
+        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", "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(["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
+if not check_r_installed():
+    print("Installing R...")
+    install_r()
+else:
+    print("No installation needed.")
+
+install_packages()
+
+subprocess.run(["pip", "install", "rpy2"])
+
+from setuptools import setup, find_packages
+from codecs import open
+from os import path
+
+# 4 - Package setup -----------------------------------------------
+    
+"""The setup script."""
+
+setup(
+    author="T. Moudiki",
+    author_email="thierry.moudiki@gmail.com",
+    python_requires=">=3.6",
+    classifiers=[
+        "Development Status :: 2 - Pre-Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: BSD License",
+        "Natural Language :: English",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+    ],
+    description="Machine Learning with uncertainty quantification and interpretability",
+    install_requires=['numpy', 'pandas', 'rpy2>=3.4.5', 'scikit-learn', 'scipy'],
+    license="BSD Clause Clear license",
+    long_description="Machine Learning with uncertainty quantification and interpretability.",
+    include_package_data=True,
+    keywords="learningmachine",
+    name="learningmachine",
+    packages=find_packages(include=["learningmachine", "learningmachine.*"]),
+    test_suite="tests",
+    url="https://github.com/Techtonique/learningmachine_python",
+    version="2.0.1",
+    zip_safe=False,
+)

learningmachine-1.1.0/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.0/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.0/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.0/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])
-            )
-        )

learningmachine-1.1.0/setup.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python
-
-import platform 
-import subprocess
-from os import path
-from setuptools import setup, find_packages
-
-# 0 - utility functions -----------------------------------------------
-
-def check_r_installed():
-    current_platform = platform.system()
-
-    if current_platform == "Windows":
-        # Check if R is installed on Windows by checking the registry
-        try:
-            subprocess.run(
-                ["reg", "query", "HKLM\\Software\\R-core\\R"], check=True
-            )
-            print("R is already installed on Windows.")
-            return True
-        except subprocess.CalledProcessError as e:
-            install_r(prompt=True)
-            return True            
-
-    elif current_platform in ("Darwin", "Linux"):
-        # Check if R is installed on Linux by checking if the 'R' executable is available
-
-        try:
-            # Try to find the 'R' executable using 'which' (if available)
-            subprocess.check_call(['which', 'R'])
-            print(f"R is already installed on {current_platform}.")
-            return True
-        except subprocess.CalledProcessError:
-            # 'which' might not be available, or R is not installed
-            print('R may not be installed.')
-            install_r(prompt=True) 
-            return True           
-                
-    else:
-
-        print("Unsupported platform (check manually: https://cloud.r-project.org/)")
-        return False
-
-def install_r(prompt=False):
-
-    current_platform = platform.system()
-
-    if prompt == True:
-        print("Installing R...")    
-        # choice = input("Would you like to install R? (yes/no): ").strip().lower()
-        # if choice == 'yes':
-        #     print("Installing R...")    
-        # elif choice == 'no':
-        #     print("No problem. R will not be installed.")
-        #     return 
-        # else:
-        #     print("Invalid input. Please enter 'yes' or 'no'.")
-        #     return
-
-    if current_platform == "Windows":
-        # Install R on Windows using PowerShell
-        install_command = "Start-Process powershell -Verb runAs -ArgumentList '-Command \"& {Invoke-WebRequest https://cran.r-project.org/bin/windows/base/R-4.1.2-win.exe -OutFile R.exe}; Start-Process R.exe -ArgumentList '/SILENT' -Wait}'"
-        subprocess.run(install_command, shell=True)
-
-    elif current_platform == "Linux":
-        # Install R on Linux using the appropriate package manager (e.g., apt-get)
-        install_command = (
-            "sudo apt update -qq && sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9"
-            + "&& sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/'"
-            + "&& sudo apt update"
-            + "&& sudo apt install r-base"
-        )
-        try: 
-            subprocess.run(install_command, shell=True)
-        except NotImplementedError as e:
-            print("Error installing R on this Linux distribution. Please check manually: https://cloud.r-project.org/")
-
-    elif current_platform == "Darwin":  # macOS
-        # Install R on macOS using Homebrew
-        install_command = "brew install r"
-        try: 
-            subprocess.run(install_command, shell=True)
-        except NotImplementedError as e:
-            print("Error installing R on macOS. Please check manually: https://cloud.r-project.org/")
-
-    else:
-        print("Unsupported platform. Unable to install R.")
-
-def load_learningmachine():
-    # Install R packages
-    commands1_lm = 'base::system.file(package = "learningmachine")'  # check "learningmachine" is installed
-    commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")'  # check "learningmachine" is installed locally
-    exec_commands1_lm = subprocess.run(
-        ["Rscript", "-e", commands1_lm], capture_output=True, text=True
-    )
-    exec_commands2_lm = subprocess.run(
-        ["Rscript", "-e", commands2_lm], capture_output=True, text=True
-    )
-    if (
-        len(exec_commands1_lm.stdout) == 7
-        and len(exec_commands2_lm.stdout) == 7
-    ):  # kind of convoluted, but works
-        print("Installing R packages along with 'learningmachine'...")
-        commands1 = [
-            'try(utils::install.packages(c("R6", "Rcpp", "skimr"), repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
-            'try(utils::install.packages("learningmachine", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=TRUE)',
-        ]
-        commands2 = [
-            'try(utils::install.packages(c("R6", "Rcpp", "skimr"), lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
-            'try(utils::install.packages("learningmachine", lib="./learningmachine_r", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=TRUE)',
-        ]
-        commands3 = [
-            'try(utils::install.packages(c("R6", "Rcpp", "remotes", "skimr"), repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
-            'try(remotes::install_github("Techtonique/learningmachine"), silent=TRUE)',
-        ]
-        commands4 = [
-            'try(utils::install.packages(c("R6", "Rcpp", "remotes", "skimr"), lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=TRUE)',
-            'try(remotes::install_github("Techtonique/learningmachine", lib="./learningmachine_r", dependencies = TRUE), silent=TRUE)',
-        ]
-
-        try:
-            for cmd in commands3:
-                try: 
-                    subprocess.run(["Rscript", "-e", cmd])
-                except:
-                    pass
-        except NotImplementedError as e:  # can't install packages globally
-            try: 
-                subprocess.run(["mkdir", "learningmachine_r"])
-                for cmd in commands4:
-                    try: 
-                        subprocess.run(["Rscript", "-e", cmd])
-                    except:
-                        pass
-            except NotImplementedError as e:
-                try: 
-                    for cmd in commands1:
-                        try: 
-                            subprocess.run(["Rscript", "-e", cmd])
-                        except:
-                            pass
-                except NotImplementedError as e:
-                    subprocess.run(["mkdir", "learningmachine_r"])
-                    for cmd in commands2:
-                        try: 
-                            subprocess.run(["Rscript", "-e", cmd])
-                        except:
-                            pass
-
-        # try:
-        #     base.library(StrVector(["learningmachine"]))
-        # except (
-        #     NotImplementedError
-        # ) as e1:  # can't load the package from the global environment
-        #     try:
-        #         base.library(
-        #             StrVector(["learningmachine"]), lib_loc="learningmachine_r"
-        #         )
-        #     except NotImplementedError as e2:  # well, we tried
-        #         try:
-        #             r("try(library('learningmachine'), silence=TRUE)")
-        #         except (
-        #             NotImplementedError
-        #         ) as e3:  # well, we tried everything at this point
-        #             r(
-        #                 "try(library('learningmachine', lib.loc='learningmachine_r'), silence=TRUE)"
-        #             )
-
-# 1 - import Python packages -----------------------------------------------
-
-subprocess.run(["pip", "install", "rpy2"])
-try: 
-    subprocess.run(["pip", "install", "setuptools"])
-except ModuleNotFoundError as e:
-    print("Error installing setuptools. Please install setuptools manually.")
-
-from rpy2.robjects.packages import importr
-from rpy2.robjects.vectors import StrVector
-from rpy2.robjects import r
-
-base = importr("base")
-
-if not check_r_installed():
-    install_r()
-else:
-    print("R is already installed.")
-
-load_learningmachine()
-
-# 4 - Package setup -----------------------------------------------
-    
-"""The setup script."""
-
-setup(
-    author="T. Moudiki",
-    author_email="thierry.moudiki@gmail.com",
-    python_requires=">=3.6",
-    classifiers=[
-        "Development Status :: 2 - Pre-Alpha",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: BSD License",
-        "Natural Language :: English",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-    ],
-    description="Machine Learning with uncertainty quantification and interpretability",
-    install_requires=['numpy', 'pandas', 'rpy2>=3.4.5', 'scikit-learn', 'scipy'],
-    license="BSD Clause Clear license",
-    long_description="Machine Learning with uncertainty quantification and interpretability.",
-    include_package_data=True,
-    keywords="learningmachine",
-    name="learningmachine",
-    packages=find_packages(include=["learningmachine", "learningmachine.*"]),
-    test_suite="tests",
-    url="https://github.com/Techtonique/learningmachine_python",
-    version="1.1.0",
-    zip_safe=False,
-)