learningmachine 0.2.2__tar.gz → 0.2.3__tar.gz

{learningmachine-0.2.2 → learningmachine-0.2.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 0.2.2
+Version: 0.2.3
 Summary: Machine Learning with uncertainty quantification and interpretability
-Home-page: https://github.com/Techtonique/learningmachine
+Home-page: https://github.com/Techtonique/learningmachine_python
 Author: T. Moudiki
 Author-email: thierry.moudiki@gmail.com
 License: BSD Clause Clear license

learningmachine-0.2.3/learningmachine/base.py

@@ -0,0 +1,75 @@
+import subprocess
+from functools import lru_cache
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import StrVector
+from sklearn.base import BaseEstimator
+
+base = importr("base")
+stats = importr("stats")
+
+
+@lru_cache(maxsize=32)
+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)',
+        ]
+        try:
+            for cmd in commands1:
+                subprocess.run(["Rscript", "-e", cmd])
+        except Exception as e:  # can't install packages globally
+            subprocess.run(["mkdir", "learningmachine_r"])
+            for cmd in commands2:
+                subprocess.run(["Rscript", "-e", cmd])
+
+        try:
+            base.library(StrVector(["learningmachine"]))
+        except (
+            Exception
+        ) as e1:  # can't load the package from the global environment
+            try:
+                base.library(
+                    StrVector(["learningmachine"]), lib_loc="learningmachine_r"
+                )
+            except Exception 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)"
+                    )
+
+
+class Base(BaseEstimator):
+    """
+    Base class.
+    """
+
+    def __init__(self):
+        """
+        Initialize the model.
+        """
+        self.type_fit = None
+        self.obj = None
+        load_learningmachine()

learningmachine-0.2.3/learningmachine/basemodels.py

@@ -0,0 +1,231 @@
+import numpy as np
+import sklearn.metrics as skm
+from subprocess import run
+from rpy2.robjects import r
+from rpy2.robjects.packages import importr
+from rpy2.robjects.vectors import (
+    FloatMatrix,
+    FloatVector,
+    IntVector,
+    StrVector,
+)
+from sklearn.base import RegressorMixin, ClassifierMixin
+from .base import Base
+
+base = importr("base")
+stats = importr("stats")
+utils = importr("utils")
+
+
+class BaseRegressor(Base, RegressorMixin):
+    """
+    Base Regressor.
+    """
+
+    def __init__(self):
+        """
+        Initialize the model.
+        """
+        super().__init__()
+        self.type_fit = "regression"
+        self.obj = r("learningmachine::BaseRegressor$new()")
+
+    def fit(self, X, y):
+        """
+        Fit the model according to the given training data.
+        """
+        self.obj["fit"](
+            r.matrix(
+                FloatVector(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
+            ),
+            FloatVector(y),
+        )
+        return self
+
+    def predict(self, X):
+        """
+        Predict using the model.
+        """
+        return np.asarray(
+            self.obj["predict"](
+                r.matrix(
+                    FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
+                )
+            )
+        )
+
+    def score(self, X, y, scoring=None, **kwargs):
+        """Score the model on test set features X and response y.
+
+        Parameters:
+
+            X: {array-like}, shape = [n_samples, n_features]
+                Training vectors, where n_samples is the number
+                of samples and n_features is the number of features
+
+            y: array-like, shape = [n_samples]
+                Target values
+
+            scoring: str
+                must be in ('explained_variance', 'neg_mean_absolute_error',
+                            'neg_mean_squared_error', 'neg_mean_squared_log_error',
+                            'neg_median_absolute_error', 'r2')
+
+            **kwargs: additional parameters to be passed to scoring functions
+
+        Returns:
+
+        model scores: {array-like}
+
+        """
+
+        preds = self.predict(X)
+
+        if type(preds) == tuple:  # if there are std. devs in the predictions
+            preds = preds[0]
+
+        if scoring is None:
+            scoring = "neg_mean_squared_error"
+
+        # check inputs
+        assert scoring in (
+            "explained_variance",
+            "neg_mean_absolute_error",
+            "neg_mean_squared_error",
+            "neg_mean_squared_log_error",
+            "neg_median_absolute_error",
+            "r2",
+        ), "'scoring' should be in ('explained_variance', 'neg_mean_absolute_error', \
+                           'neg_mean_squared_error', 'neg_mean_squared_log_error', \
+                           'neg_median_absolute_error', 'r2')"
+
+        scoring_options = {
+            "explained_variance": skm.explained_variance_score,
+            "neg_mean_absolute_error": skm.median_absolute_error,
+            "neg_mean_squared_error": skm.mean_squared_error,
+            "neg_mean_squared_log_error": skm.mean_squared_log_error,
+            "neg_median_absolute_error": skm.median_absolute_error,
+            "r2": skm.r2_score,
+        }
+
+        return scoring_options[scoring](y, preds, **kwargs)
+
+
+class BaseClassifier(Base, ClassifierMixin):
+    """
+    Base Classifier.
+    """
+
+    def __init__(self):
+        """
+        Initialize the model.
+        """
+        super().__init__()
+        self.type_fit = "classification"
+        self.obj = r("learningmachine::BaseClassifier$new()")
+
+    def fit(self, X, y):
+        """
+        Fit the model according to the given training data.
+        """
+        self.obj["fit"](
+            r.matrix(
+                FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
+            ),
+            base.as_factor(IntVector(y)),
+        )
+        self.classes_ = np.unique(y)
+        return self
+
+    def predict(self, X):
+        """
+        Predict classes using the model.
+        """
+        return np.asarray(
+            self.obj["predict"](
+                r.matrix(
+                    FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
+                )
+            )
+        )
+
+    def predict_proba(self, X):
+        """
+        Predict probabilities using the model.
+        """
+        return np.asarray(
+            self.obj["predict_proba"](
+                r.matrix(
+                    FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
+                )
+            )
+        )
+
+    def score(self, X, y, scoring=None, **kwargs):
+        """Score the model on test set features X and response y.
+
+        Parameters:
+
+            X: {array-like}, shape = [n_samples, n_features]
+                Training vectors, where n_samples is the number
+                of samples and n_features is the number of features
+
+            y: array-like, shape = [n_samples]
+                Target values
+
+            scoring: str
+                must be in ('accuracy', 'average_precision',
+                           'brier_score_loss', 'f1', 'f1_micro',
+                           'f1_macro', 'f1_weighted',  'f1_samples',
+                           'neg_log_loss', 'precision', 'recall',
+                           'roc_auc')
+
+            **kwargs: additional parameters to be passed to scoring functions
+
+        Returns:
+
+            model scores: {array-like}
+
+        """
+
+        preds = self.predict(X)
+
+        if scoring is None:
+            scoring = "accuracy"
+
+        # check inputs
+        assert scoring in (
+            "accuracy",
+            "average_precision",
+            "brier_score_loss",
+            "f1",
+            "f1_micro",
+            "f1_macro",
+            "f1_weighted",
+            "f1_samples",
+            "neg_log_loss",
+            "precision",
+            "recall",
+            "roc_auc",
+        ), "'scoring' should be in ('accuracy', 'average_precision', \
+                           'brier_score_loss', 'f1', 'f1_micro', \
+                           'f1_macro', 'f1_weighted',  'f1_samples', \
+                           'neg_log_loss', 'precision', 'recall', \
+                           'roc_auc')"
+
+        scoring_options = {
+            "accuracy": skm.accuracy_score,
+            "average_precision": skm.average_precision_score,
+            "brier_score_loss": skm.brier_score_loss,
+            "f1": skm.f1_score,
+            "f1_micro": skm.f1_score,
+            "f1_macro": skm.f1_score,
+            "f1_weighted": skm.f1_score,
+            "f1_samples": skm.f1_score,
+            "neg_log_loss": skm.log_loss,
+            "precision": skm.precision_score,
+            "recall": skm.recall_score,
+            "roc_auc": skm.roc_auc_score,
+        }
+
+        return scoring_options[scoring](y, preds, **kwargs)

{learningmachine-0.2.2 → learningmachine-0.2.3}/learningmachine.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: learningmachine
-Version: 0.2.2
+Version: 0.2.3
 Summary: Machine Learning with uncertainty quantification and interpretability
-Home-page: https://github.com/Techtonique/learningmachine
+Home-page: https://github.com/Techtonique/learningmachine_python
 Author: T. Moudiki
 Author-email: thierry.moudiki@gmail.com
 License: BSD Clause Clear license

learningmachine-0.2.3/setup.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+
+# 1 - import Python packages -----------------------------------------------
+
+import subprocess
+
+subprocess.run(["pip", "install", "rpy2"])
+
+from os import path
+import platform
+from setuptools import setup, find_packages
+
+
+# 2 - 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:
+            print(
+                "R is required but not installed on Windows (check manually: https://cloud.r-project.org/)."
+            )
+            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 required but not installed on Linux (check manually: https://cloud.r-project.org/)."
+            )
+            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 required but not installed on macOS (check manually: https://cloud.r-project.org/)."
+            )
+            return False
+
+    else:
+        print("Unsupported platform (check manually: https://cloud.r-project.org/)")
+        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 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 Exception 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 Exception as e:
+            print("Error installing R on macOS. Please check manually: https://cloud.r-project.org/")
+
+    else:
+        print("Unsupported platform. Unable to install R.")
+
+
+# 3 - check if R is installed -----------------------------------------------
+        
+if not check_r_installed():
+    install_r()
+else:
+    print("R is already installed.")
+
+# 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="0.2.3",
+    zip_safe=False,
+)

learningmachine-0.2.2/learningmachine/base.py

@@ -1,18 +0,0 @@
-from rpy2.robjects import r
-from rpy2.robjects.packages import importr
-from .utils import check_install_r_pkg
-
-base = importr("base")
-stats = importr("stats")
-
-
-class Base(object):
-    """
-    Base class.
-    """
-
-    def __init__(self):
-        """
-        Initialize the model.
-        """
-        self.obj = None

learningmachine-0.2.2/learningmachine/basemodels.py

@@ -1,112 +0,0 @@
-from subprocess import run
-from rpy2.robjects import r
-from rpy2.robjects.packages import importr
-from rpy2.robjects.vectors import (
-    FloatMatrix,
-    FloatVector,
-    IntVector,
-    StrVector,
-)
-
-from sklearn.base import BaseEstimator, RegressorMixin, ClassifierMixin
-from .base import Base
-
-base = importr("base")
-stats = importr("stats")
-utils = importr("utils")
-
-
-class BaseRegressor(Base, BaseEstimator, RegressorMixin):
-    """
-    Base Regressor.
-    """
-
-    def __init__(self):
-        """
-        Initialize the model.
-        """
-
-        super(Base, self).__init__()
-
-        try:
-            self.obj = r("learningmachine::BaseRegressor$new()")
-        except NotImplementedError as e:  # doesn't work yet
-            self.obj = run(
-                ["Rscript", "-e", "learningmachine::BaseRegressor$new()"],
-                capture_output=True,
-            )
-
-    def fit(self, X, y):
-        """
-        Fit the model according to the given training data.
-        """
-        self.obj["fit"](
-            r.matrix(
-                FloatVector(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            ),
-            FloatVector(y),
-        )
-        return self
-
-    def predict(self, X):
-        """
-        Predict using the model.
-        """
-        return self.obj["predict"](
-            r.matrix(
-                FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            )
-        )
-
-
-class BaseClassifier(Base, BaseEstimator, ClassifierMixin):
-    """
-    Base Classifier.
-    """
-
-    def __init__(self):
-        """
-        Initialize the model.
-        """
-
-        super(Base, self).__init__()
-
-        try:
-            self.obj = r("learningmachine::BaseClassifier$new()")
-        except NotImplementedError as e:  # doesn't work yet
-            self.obj = run(
-                ["Rscript", "-e", "learningmachine::BaseClassifier$new()"],
-                capture_output=True,
-            )
-
-    def fit(self, X, y):
-        """
-        Fit the model according to the given training data.
-        """
-        self.obj["fit"](
-            r.matrix(
-                FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            ),
-            base.as_factor(IntVector(y)),
-        )
-        return self
-
-    def predict(self, X):
-        """
-        Predict classes using the model.
-        """
-        return self.obj["predict"](
-            r.matrix(
-                FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            )
-        )
-
-    def predict_proba(self, X):
-        """
-        Predict probabilities using the model.
-        """
-        return self.obj["predict_proba"](
-            r.matrix(
-                FloatMatrix(X), byrow=True, nrow=X.shape[0], ncol=X.shape[1]
-            )
-        )

learningmachine-0.2.2/setup.py

@@ -1,175 +0,0 @@
-#!/usr/bin/env python
-
-# 1 - import Python packages -----------------------------------------------
-
-import platform
-import subprocess
-from os import path
-from rpy2.robjects.packages import importr
-from setuptools import setup, find_packages
-from rpy2.robjects.vectors import StrVector
-from rpy2.robjects import r
-
-# 2 - 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:
-            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 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"
-        )
-        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.")
-
-# 3 - Install packages -----------------------------------------------
-
-# 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 R packages
-commands1_lm = 'base::system.file(package = "learningmachine")' # check is installed 
-commands2_lm = 'base::system.file("learningmachine_r", package = "learningmachine")' # check 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...")
-    commands1 = ['try(utils::install.packages("R6", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)', 
-                'try(utils::install.packages("Rcpp", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)',
-                'try(utils::install.packages("skimr", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)', 
-                'try(utils::install.packages("learningmachine", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=FALSE)']
-    commands2 = ['try(utils::install.packages("R6", lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)', 
-                'try(utils::install.packages("Rcpp", lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)',
-                'try(utils::install.packages("skimr", lib="./learningmachine_r", repos="https://cloud.r-project.org", dependencies = TRUE), silent=FALSE)', 
-                'try(utils::install.packages("learningmachine", lib="./learningmachine_r", repos="https://techtonique.r-universe.dev", dependencies = TRUE), silent=FALSE)']
-    try:             
-        for cmd in commands1:
-            subprocess.run(['Rscript', '-e', cmd])
-    except Exception as e:
-        subprocess.run(['mkdir', 'learningmachine_r'])
-        for cmd in commands2:
-            subprocess.run(['Rscript', '-e', cmd])
-    
-    base = importr("base")
-    
-    try:
-        base.library(StrVector(["learningmachine"]))
-    except Exception as e1:
-        try:
-            base.library(
-                StrVector(["learningmachine"]), lib_loc="learningmachine_r"
-            )
-        except Exception as e2:
-            try:
-                r("try(library('learningmachine'), silence=TRUE)")
-            except NotImplementedError as e3:
-                r(
-                    "try(library('learningmachine', lib.loc='learningmachine_r'), silence=TRUE)"
-                )
-
-
-"""The setup script."""
-here = path.abspath(path.dirname(__file__))
-
-# get the dependencies and installs
-with open(
-    path.join(here, "requirements.txt"), encoding="utf-8"
-) as f:
-    all_reqs = f.read().split("\n")
-
-install_requires = [
-    x.strip() for x in all_reqs if "git+" not in x
-]
-dependency_links = [
-    x.strip().replace("git+", "")
-    for x in all_reqs
-    if x.startswith("git+")
-]
-
-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=install_requires,
-    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',
-    version='0.2.2',
-    zip_safe=False,
-)