all tests pass

Author: eloquentarduino

.gitignore

@@ -3,7 +3,8 @@ __pycache__
 *.py[cod]
 .cache
 .ipynb_checkpoints
-everywhereml/project
-serve.py
-test
-notebook.html
+./enumerate_packages.py
+./enumerate_templates.py
+./publish
+./setup_template.py
+./test

README.md

@@ -23,7 +23,7 @@ The package implements most of the tools you need to develop a fully functional
 
  [X] Data loading and visualization
  [X] Preprocessing
-    [X] Pipeline
+    [] Pipeline
     [X] BoxCox (power transform)
     [X] CrossDiff
     [X] MinMaxScaler
@@ -32,7 +32,9 @@ The package implements most of the tools you need to develop a fully functional
     [X] RateLimit
     [X] StandardScaler
     [X] YeoJohnson (power transform)
-    [] Feature selection
+    [] Audio
+        [] MelSpectrogram
+    [X] Feature selection
         [X] RFE
         [X] SelectKBest
     [] Time series analysis
@@ -45,7 +47,7 @@ The package implements most of the tools you need to develop a fully functional
     [X] LogisticRegression
     [X] GaussianNB
     []  BernoulliNB
-    [X] SVM
+    [] SVM (not tested)
     []  LinearSVM
     [X] DecisionTree
     [X] XGBoost

enumerate_packages.py

@@ -0,0 +1,18 @@
+import os
+import json
+from os.path import isdir
+from glob import glob
+
+
+def package_name(folder):
+    if folder.endswith(os.path.sep):
+        folder = folder[:-1]
+
+    return folder.replace(os.path.sep, '.')
+
+
+if __name__ == '__main__':
+    packages = [package_name(folder) for folder in glob('everywhereml/**', recursive=True)
+                if isdir(folder) and '__pycache__' not in folder]
+
+    print(json.dumps(packages).replace('/', '\\/').replace('"', '\\"'))

enumerate_templates.py

@@ -0,0 +1,9 @@
+import json
+from glob import glob
+
+
+if __name__ == '__main__':
+    templates = [filename.replace('everywhereml/', '')
+     for filename in glob('everywhereml/templates/**/*.jinja', recursive=True)]
+
+    print(json.dumps(templates).replace('/', '\\/').replace('"', '\\"'))

everywhereml/IsPortableMixin.py

@@ -1,3 +1,4 @@
+import numpy as np
 from everywhereml.templates import Jinja
 
 
@@ -17,18 +18,27 @@ def port(self, language, data=None, **kwargs):
         template_data.update(self.get_template_data_for_language(language))
         template_data.update(data or {})
 
-        for k, v in self.get_default_template_data_for_language(language).items():
+        # kwargs first
+        for k, v in kwargs.items():
             template_data.setdefault(k, v)
 
-        for k, v in self.get_default_template_data().items():
+        # then language-specific data
+        for k, v in self.get_default_template_data_for_language(language).items():
             template_data.setdefault(k, v)
 
-        for k, v in kwargs.items():
+        # then default data
+        for k, v in self.get_default_template_data().items():
             template_data.setdefault(k, v)
 
         # ALWAYS inject these values
         template_data.update(uuid='UUID%d' % id(self))
         template_data.update(source_class=self.__module__.__str__())
+        template_data.update(language=language)
+
+        # replace NaNs with 0 and inf with a large number
+        for k, v in template_data.items():
+            if isinstance(v, np.ndarray):
+                template_data.update(**{k: np.nan_to_num(v)})
 
         ported = Jinja('', language=language, dialect=kwargs.get('dialect', None)).render(template_name, template_data)
 

everywhereml/classification/BaseClassifier.py

@@ -1,8 +1,10 @@
+from cached_property import cached_property
 from sklearn.model_selection import KFold
 from everywhereml.IsPortableMixin import IsPortableMixin
 from everywhereml.classification.utils import to_Xy
-from everywhereml.templates import Jinja
 from everywhereml.data.plot import plot_confusion_matrix
+from everywhereml.classification.MakesBinaryDecisionMixin import MakesBinaryDecisionMixin
+from everywhereml.classification.MakesBinaryComplementDecisionMixin import MakesBinaryComplementDecisionMixin
 
 
 class BaseClassifier(IsPortableMixin):
@@ -29,17 +31,17 @@ def num_classes(self):
 
         return len(set(self.y_train))
 
-    @property
+    @cached_property
     def package_name(self):
         """
         Get base package name
-        :return:
+        :return: str
         """
         package_name = self.__module__.__str__().replace('everywhereml.classification.', '').split('.')[0]
 
         return package_name[0].upper() + package_name[1:]
 
-    @property
+    @cached_property
     def classname(self):
         """
         Get class name
@@ -49,7 +51,7 @@ def classname(self):
 
         return classname[0].upper() + classname[1:]
 
-    @property
+    @cached_property
     def packages(self):
         """
         Get package names
@@ -59,6 +61,15 @@ def packages(self):
 
         return [package[0].upper() + package[1:] for package in packages]
 
+    @property
+    def binary_complement(self):
+        """
+        Some implementations output swapped labels for binary classification
+        If this property is True, fix the return value in the templates
+        :return: bool
+        """
+        return False
+
     def clone(self):
         """
         Clone classifier
@@ -147,18 +158,20 @@ def port(self, language, classname=None, classmap=None, data=None, **kwargs):
 
     def get_default_template_data(self):
         """
-        Get default data for template
+        Get default data for templates
         :return: dict
         """
         return {
             'num_inputs': self.num_inputs,
             'num_classes': self.num_classes,
-            'package_name': self.package_name
+            'package_name': self.package_name,
+            'makes_binary_decision': isinstance(self, MakesBinaryDecisionMixin),
+            'makes_binary_complement_decision': isinstance(self, MakesBinaryComplementDecisionMixin)
         }
 
     def get_default_template_data_php(self, **kwargs):
         """
-
+        Get default data for PHP templates
         :param kwargs:
         :return:
         """

everywhereml/classification/MakesBinaryComplementDecisionMixin.py

@@ -0,0 +1,9 @@
+from everywhereml.classification.MakesBinaryDecisionMixin import MakesBinaryDecisionMixin
+
+
+class MakesBinaryComplementDecisionMixin(MakesBinaryDecisionMixin):
+    """
+    Mixin to mark classes that, for binary classification, produces a label
+    based on `decision > threshold ? 0 : 1`
+    """
+    pass

everywhereml/classification/MakesBinaryDecisionMixin.py

@@ -0,0 +1,6 @@
+class MakesBinaryDecisionMixin:
+    """
+    Mixin to mark classes that, for binary classification, produces a label
+    based on `decision > threshold ? 1 : 0`
+    """
+    pass

everywhereml/classification/sklearn/linear_model/LogisticRegression.py

@@ -1,11 +1,21 @@
 from sklearn.linear_model import LogisticRegression as SklearnClassifier
+from everywhereml.classification.MakesBinaryDecisionMixin import MakesBinaryDecisionMixin
 from everywhereml.classification.sklearn.SklearnBaseClassifier import SklearnBaseClassifier
 
 
-class LogisticRegression(SklearnBaseClassifier, SklearnClassifier):
+class LogisticRegression(MakesBinaryDecisionMixin, SklearnBaseClassifier, SklearnClassifier):
     """
     sklearn.linear_model.LogisticRegression wrapper
     """
+
+    @property
+    def binary_complement(self):
+        """
+        @see parent
+        :return:
+        """
+        return True
+
     def get_template_data(self):
         """
         Get additional data for template

everywhereml/classification/utils.py

@@ -1,20 +1,23 @@
 import numpy as np
 
 
-def to_Xy(X, y=None):
+def to_Xy(X, y=None, allow_y_none=False):
     """
-    Convert X, y from different formats to X, y ndarrays
-    :param X:
-    :param y:
+    Convert X, y from different formats to X, y arrays
+    :param X: np.array
+    :param y: np.array
+    :param allow_y_none: bool if True, don't raise exception if y is None
     :return: tuple first element is X array, second element is y array
     """
-    if y is None:
-        assert hasattr(X, 'X') and hasattr(X, 'y'), 'when y is None, first argument MUST have X and y attributes'
-        y = X.y
+    # X is a Dataset object
+    if hasattr(X, "X"):
+        y = y or getattr(X, "y", None)
         X = X.X
 
-    assert X is not None, 'X CANNOT be None'
-    assert y is not None, 'y CANNOT be None'
-    assert len(X) == len(y), 'X and y MUST have the same length'
+    if y is None and not allow_y_none:
+        raise AssertionError("y CANNOT be None")
+
+    assert X is not None, "X CANNOT be None"
+    assert y is None or len(X) == len(y), "X and y MUST have the same length"
 
     return np.asarray(X), np.asarray(y, dtype=np.uint8)