drop and

Author: reiase

README.md

@@ -76,11 +76,8 @@ with param_scope(param1=2):
 
 ## Predefined Parameter
 ```python
-@let( # predefine two parameter for `model_train`
-    learning_rate = 1.0,
-    penalty = 'l1'
-)
-def model_train(X, y):
+@auto_param #convert keyword arguments into hyper parameters
+def model_train(X, y, learning_rate = 1.0, penalty = 'l1'):
     LR = LogisticRegression(C=1.0, 
         lr=local_param('learning_rate'), 
         penalty=local_param('penalty'))

examples/sparse_lr/README.md

@@ -4,18 +4,16 @@ Sparse LR Examples
 This example is based on `scikit-learn` example: [l1 penalty and sparsity in logistic regression](https://scikit-learn.org/stable/auto_examples/linear_model/plot_logistic_l1_l2_sparsity.html#sphx-glr-auto-examples-linear-model-plot-logistic-l1-l2-sparsity-py), which classifies 8x8 images of digits into two classes: 0-4 against 5-9, 
 and visualize the coefficients of the model for different penalty methods(l1 or l2) and C.
 
-The algorithm is defined in function `sparse_lr_plot` from `model.py`. We use the decorator `let`  to declare hyper-parameters for our function:
+The algorithm is defined in function `sparse_lr_plot` from `model.py`. We use the decorator `auto_param`  to declare hyper-parameters for our function:
 ``` python
-@let(learning_rate=0.01, penalty='l1', C=0.01, tol=0.01)
-def sparse_lr_plot(X, y):
-    C = local_param('C')
-    penalty = local_param('penalty')
-    tol = local_param('tol')
+@auto_param
+def sparse_lr_plot(X, y, learning_rate=0.01, penalty='l1', C=0.01, tol=0.01):
     print({'C': C, 'penalty': penalty, 'tol': tol})
     ...
 ```
 
-Four hyper-parameter are defined for `sparse_lr_plot`: `learning_rate`, `penalty`, `C` and `tol`. 
+Four keyword arguments are defined for `sparse_lr_plot`: `learning_rate`, `penalty`, `C` and `tol`. `auto_param` will convert these arguments into hyper-parameters.
+
 There are two ways to control the hyper-parameters:
 1. parameter scope (see detail in `example_1.py`):
 

examples/sparse_lr/model.py

@@ -2,14 +2,11 @@
 from sklearn.linear_model import LogisticRegression
 import matplotlib.pyplot as plt
 
-from hyperparameter import let, local_param, param_scope
+from hyperparameter import auto_param, param_scope
 
 
-@let(learning_rate=0.01, penalty='l1', C=0.01, tol=0.01)
-def sparse_lr_plot(X, y):
-    C = local_param('C')
-    penalty = local_param('penalty')
-    tol = local_param('tol')
+@auto_param
+def sparse_lr_plot(X, y, learning_rate=0.01, penalty='l1', C=0.01, tol=0.01):
     LR = LogisticRegression(C=C, penalty=penalty, tol=tol, solver='saga')
 
     LR.fit(X, y)

hyperparameter/__init__.py

@@ -1 +1 @@
-from .hp import *
+from .hp import HyperParameter, param_scope, auto_param

hyperparameter/hp.py

@@ -274,10 +274,6 @@ def from_json_file(path):
             return HyperParameter(**obj)
 
 
-def hparam(*arg, **kws):
-    return HyperParameter(*arg, **kws)
-
-
 class param_scope(HyperParameter):
     ''' 
     thread safe scoped hyper parameeter
@@ -327,119 +323,14 @@ def __exit__(self, exc_type, exc_value, traceback):
 
     @staticmethod
     def init(params):
+        """
+        init param_scope for a new thread.
+        """
         if not hasattr(param_scope.tls, '_cfg_'):
             param_scope.tls._cfg_ = []
             param_scope.tls._cfg_.append(params)
 
 
-def local_param(name: str):
-    """
-    >>> @let(a=1)
-    ... def foo():
-    ...     print(local_param('a'))
-
-    >>> foo()
-    1
-
-    >>> with param_scope('foo.a=2'):
-    ...     foo()
-    2
-    """
-    import sys
-    namespace = inspect.getmodulename(sys._getframe(1).f_code.co_filename)
-    if namespace == '__main__':
-        namespace = None
-    if namespace is not None:
-        namespace += '.{}'.format(sys._getframe(1).f_code.co_name)
-    else:
-        namespace = sys._getframe(1).f_code.co_name
-    with param_scope() as hp:
-        value = hp.get(namespace + '.' + name)
-        if value is not None:
-            return value
-        else:
-            raise Exception(
-                'name {} not defined for {}, available parameters: {}'.format(
-                    name, namespace, str(hp)))
-
-
-def let(*arg, **kws):
-    """
-    wrap a function with parameters
-
-    example for pre-defined global parameter
-    >>> @let(
-    ...     'a.b=1',
-    ... )
-    ... def foo():
-    ...     with param_scope() as hp:
-    ...         print(hp.a.b)
-
-    >>> foo()
-    1
-
-    >>> with param_scope('a.b=2') as hp:
-    ...     foo()
-    2
-
-    example for pre-defined function local parameter
-
-    >>> @let(b=1)
-    ... def foo():
-    ...     return local_param('b')
-
-    >>> foo()
-    1
-
-    >>> with param_scope('foo.b=2'):
-    ...     foo()
-    2
-    """
-    predef_arg = arg
-    predef_kws = kws
-
-    def wrapper(func):
-        namespace = func.__module__
-        if namespace == '__main__':
-            namespace = None
-        if namespace is not None:
-            namespace += '.{}'.format(func.__name__)
-        else:
-            namespace = func.__name__
-
-        global params_list
-        for item in predef_arg:
-            if '=' in item:
-                k, v = item.split('=', 1)
-                Tracker.wlist.add(k)
-        for k, v in predef_kws.items():
-            name = '{}.{}'.format(namespace, k)
-            Tracker.wlist.add(name)
-
-        def result_func(*arg, **kws):
-            accepted_arg = []
-            accepted_kws = {}
-            with param_scope() as hp:
-                for item in predef_arg:
-                    if '=' in item:
-                        k, v = item.split('=', 1)
-                        if hp.get(k) is None:
-                            accepted_arg.append(item)
-                for k, v in predef_kws.items():
-                    name = '{}.{}'.format(namespace, k)
-                    if hp.get(name) is None:
-                        accepted_kws[name] = safe_numeric(v)
-            with param_scope(*accepted_arg) as hp:
-                for k, v in accepted_kws.items():
-                    v = safe_numeric(v)
-                    hp.put(k, v)
-                return func(*arg, **kws)
-
-        return result_func
-
-    return wrapper
-
-
 def auto_param(func):
     """
     Convert keyword arguments into hyperparameters
@@ -472,6 +363,7 @@ def auto_param(func):
         if v.default != v.empty:
             name = '{}.{}'.format(namespace, k)
             predef_kws[k] = name
+            Tracker.rlist.add(name)
 
     def wrapper(*arg, **kws):
         with param_scope() as hp:
@@ -505,11 +397,11 @@ def safe_numeric(value):
     class TestHyperParameter(unittest.TestCase):
 
         def test_parameter_create(self):
-            param1 = hparam(a=1, b=2)
+            param1 = HyperParameter(a=1, b=2)
             self.assertEqual(param1.a, 1)
             self.assertEqual(param1.b, 2)
 
-            param2 = hparam(**{'a': 1, 'b': 2})
+            param2 = HyperParameter(**{'a': 1, 'b': 2})
             self.assertEqual(param2.a, 1)
             self.assertEqual(param2.b, 2)