add multithread support

Author: reiase

README.md

@@ -7,6 +7,7 @@ A hyper-parameter library for researchers, data scientists and machine learning
 - [Quick Start](#quick-start)
   - [Object-Style API:](#object-style-api)
   - [Scoped Parameter](#scoped-parameter)
+  - [Predefined Parameter](#predefined-parameter)
 - [Examples](#examples)
   - [parameter tunning for researchers](#parameter-tunning-for-researchers)
   - [experiment tracing for data scientists](#experiment-tracing-for-data-scientists)
@@ -73,6 +74,23 @@ with param_scope(param1=2):
     foo() # 2
 ```
 
+## Predefined Parameter
+```python
+@let( # predefine two parameter for `model_train`
+    learning_rate = 1.0,
+    penalty = 'l1'
+)
+def model_train(X, y):
+    LR = LogisticRegression(C=1.0, 
+        lr=local_param('learning_rate'), 
+        penalty=local_param('penalty'))
+    LR.fit(X, y)
+
+# specify predefined parameter using `param_scope`
+with param_scope('model_train.learning_rate=0.01'):
+    model_train(X, y)
+```
+
 Examples
 ========
 

examples/sparse_lr/README.md

@@ -1,29 +1,27 @@
 Sparse LR Examples
 ==================
 
-This example shows l1 penalty and sparsity in logistic regression, based on `scikit-learn` example from 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.
-
-`sparse_lr_train` (from `model.py`) classifies 8x8 images of digits into two classes: 0-4 against 5-9, 
+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.
 
-We use the `let` decorator to declare hyper-parameters for our algorithm:
+The algorithm is defined in function `sparse_lr_plot` from `model.py`. We use the decorator `let`  to declare hyper-parameters for our function:
 ``` python
 @let(learning_rate=0.01, penalty='l1', C=0.01, tol=0.01)
-def sparse_lr_train(X, y):
+def sparse_lr_plot(X, y):
     C = local_param('C')
     penalty = local_param('penalty')
     tol = local_param('tol')
     print({'C': C, 'penalty': penalty, 'tol': tol})
     ...
 ```
 
-Four hyper-parameter are defined for function `sparse_lr_train`: `learning_rate`, `penalty`, `C` and `tol`. 
+Four hyper-parameter are defined for `sparse_lr_plot`: `learning_rate`, `penalty`, `C` and `tol`. 
 There are two ways to control the hyper-parameters:
 1. parameter scope (see detail in `example_1.py`):
 
 ``` python 
 with param_scope('model.sparse_lr_train.C=0.1'):
-    sparse_lr_train(X, y)
+    sparse_lr_plot(X, y)
 ```
 
 2. command line arguments (see detail in `example_2.py`):
@@ -32,7 +30,7 @@ with param_scope('model.sparse_lr_train.C=0.1'):
 def run(args):
     # run the lr model with parameter from cmdline
     with param_scope(*args.define):  # set parameters according to cmd line
-        sparse_lr_train(X, y)
+        sparse_lr_plot(X, y)
         ...
 
 

examples/sparse_lr/example_1.py

@@ -1,10 +1,9 @@
 from hyperparameter.hp import param_scope, Tracker
-from model import sparse_lr_train
+from model import sparse_lr_plot
 import numpy as np
 
 from sklearn import datasets
 from sklearn.preprocessing import StandardScaler
-import matplotlib.pyplot as plt
 
 X, y = datasets.load_digits(return_X_y=True)
 
@@ -16,25 +15,10 @@
 print('parameter list: \n  {}'.format('\n  '.join(Tracker.all())))
 
 # run the lr model with default parameters
-coef = sparse_lr_train(X, y)
+sparse_lr_plot(X, y)
+
 
-plt.imshow(
-    np.abs(coef.reshape(8, 8)),
-    interpolation="nearest",
-    cmap="binary",
-    vmax=1,
-    vmin=0,
-)
-plt.show()
 
 # run the lr model with another parameter
 with param_scope('model.sparse_lr_train.C=0.1'):
-    coef = sparse_lr_train(X, y)
-    plt.imshow(
-        np.abs(coef.reshape(8, 8)),
-        interpolation="nearest",
-        cmap="binary",
-        vmax=1,
-        vmin=0,
-    )
-    plt.show()
+    sparse_lr_plot(X, y)

examples/sparse_lr/example_2.py

@@ -1,5 +1,5 @@
 from hyperparameter.hp import param_scope, Tracker
-from model import sparse_lr_train
+from model import sparse_lr_plot
 import numpy as np
 
 from sklearn import datasets
@@ -17,16 +17,7 @@
 def run(args):
     # run the lr model with parameter from cmdline
     with param_scope(*args.define):  # set parameters according to cmd line
-        coef = sparse_lr_train(X, y)
-        plt.imshow(
-            np.abs(coef.reshape(8, 8)),
-            interpolation="nearest",
-            cmap="binary",
-            vmax=1,
-            vmin=0,
-        )
-        plt.show()
-
+        sparse_lr_plot(X, y)
 
 if __name__ == '__main__':
     # create cmd line arguments parser

examples/sparse_lr/model.py

@@ -1,18 +1,33 @@
 import numpy as np
 from sklearn.linear_model import LogisticRegression
+import matplotlib.pyplot as plt
 
 from hyperparameter import let, local_param, param_scope
 
 
 @let(learning_rate=0.01, penalty='l1', C=0.01, tol=0.01)
-def sparse_lr_train(X, y):
+def sparse_lr_plot(X, y):
     C = local_param('C')
     penalty = local_param('penalty')
     tol = local_param('tol')
     LR = LogisticRegression(C=C, penalty=penalty, tol=tol, solver='saga')
 
     LR.fit(X, y)
-    coef =  LR.coef_.ravel()
+    coef = LR.coef_.ravel()
     sparsity_LR = np.mean(coef == 0) * 100
-    print({'C': C, 'penalty': penalty, 'tol': tol, 'sparsity': '%.2f%%'%(sparsity_LR)})
-    return coef
+    print()
+    plt.imshow(
+        np.abs(coef.reshape(8, 8)),
+        interpolation="nearest",
+        cmap="binary",
+        vmax=1,
+        vmin=0,
+    )
+    plt.title(
+        str({
+            'C': C,
+            'penalty': penalty,
+            'tol': tol,
+            'sparsity': '%.2f%%' % (sparsity_LR)
+        }))
+    plt.show()

hyperparameter/hp.py

@@ -326,6 +326,12 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_value, traceback):
         param_scope.tls._cfg_.pop()
 
+    @staticmethod
+    def init(params):
+        if not hasattr(param_scope.tls, '_cfg_'):
+            param_scope.tls._cfg_ = []
+            param_scope.tls._cfg_.append(params)
+
 
 def local_param(name: str):
     """

setup.py

@@ -7,7 +7,7 @@
 
 setup(
     name="hyperparameter",
-    version="0.1.3",
+    version="0.1.4",
     description="A hyper-parameter library for researchers, data scientists and machine learning engineers.",
     long_description=long_description,
     long_description_content_type="text/markdown",