Add device context parameter

bench.py

@@ -175,7 +175,11 @@ def parse_args(parser, size=None, loop_types=(),
                         help='Dataset name')
     parser.add_argument('--no-intel-optimized', default=False, action='store_true',
                         help='Use no intel optimized version. '
-                             'Now avalible for scikit-learn benchmarks'),
+                             'Now avalible for scikit-learn benchmarks')
+    parser.add_argument('--device', default=None, type=str,
+                        choices=("host", "cpu", "gpu"),
+                        help='Execution context device')
+
     for data in ['X', 'y']:
         for stage in ['train', 'test']:
             parser.add_argument(f'--file-{data}-{stage}',
@@ -197,6 +201,8 @@ def parse_args(parser, size=None, loop_types=(),
         except ImportError:
             print('Failed to import daal4py.sklearn.patch_sklearn.'
                   'Use stock version scikit-learn', file=sys.stderr)
+    else:
+        params.device = None
 
     # disable finiteness check (default)
     if not params.check_finiteness:
@@ -492,3 +498,11 @@ def print_output(library, algorithm, stages, params, functions,
                     del result['algorithm_parameters']['handle']
             output.append(result)
         print(json.dumps(output, indent=4))
+
+def run_with_context(params, function):
+    if params.device is not None:
+        from daal4py.oneapi import sycl_context
+        with sycl_context(params.device):
+            function()
+    else:
+        function()

configs/skl_with_context_config.json

@@ -0,0 +1,77 @@
+{
+    "common": {
+        "lib": ["sklearn"],
+        "data-format": ["pandas"],
+        "data-order": ["F"],
+        "dtype": ["float64"],
+        "device": ["host", "cpu", "gpu"]
+    },
+    "cases": [
+        {
+            "algorithm": "kmeans",
+            "dataset": [
+                {
+                    "source": "synthetic",
+                    "type": "blobs",
+                    "n_clusters": 10,
+                    "n_features": 50,
+                    "training": {
+                        "n_samples": 1000000
+                    }
+                }
+            ],
+            "n-clusters": [10]
+        },
+        {
+            "algorithm": "dbscan",
+            "dataset": [
+                {
+                    "source": "synthetic",
+                    "type": "blobs",
+                    "n_clusters": 10,
+                    "n_features": 50,
+                    "training": {
+                        "n_samples": 10000
+                    }
+                }
+            ]
+        },
+        {
+            "algorithm": "linear",
+            "dataset": [
+                {
+                    "source": "synthetic",
+                    "type": "regression",
+                    "n_features": 50,
+                    "training": {
+                        "n_samples": 1000000
+                    }
+                }
+            ]
+        },
+        {
+            "algorithm": "log_reg",
+            "solver":["lbfgs", "newton-cg"],
+            "dataset": [
+                {
+                    "source": "synthetic",
+                    "type": "classification",
+                    "n_classes": 2,
+                    "n_features": 100,
+                    "training": {
+                        "n_samples": 100000
+                    }
+                },
+                {
+                    "source": "synthetic",
+                    "type": "classification",
+                    "n_classes": 5,
+                    "n_features": 100,
+                    "training": {
+                        "n_samples": 100000
+                    }
+                }
+            ]
+        }
+    ]
+}

runner.py

@@ -70,6 +70,9 @@ def generate_cases(params):
     parser.add_argument('--report', default=False, action='store_true',
                         help='Create an Excel report based on benchmarks results. '
                              'Need "openpyxl" library')
+    parser.add_argument('--device', default=None, type=str,
+                        choices=("host", "cpu", "gpu"),
+                        help='Execution context device')
     args = parser.parse_args()
     env = os.environ.copy()
 

sklearn_bench/dbscan.py

@@ -19,38 +19,41 @@
 import os
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 import bench
-from sklearn.metrics.cluster import davies_bouldin_score
 
-parser = argparse.ArgumentParser(description='scikit-learn DBSCAN benchmark')
-parser.add_argument('-e', '--eps', '--epsilon', type=float, default=10.,
-                    help='Radius of neighborhood of a point')
-parser.add_argument('-m', '--min-samples', default=5, type=int,
-                    help='The minimum number of samples required in a '
-                    'neighborhood to consider a point a core point')
-params = bench.parse_args(parser)
-
-from sklearn.cluster import DBSCAN
-
-# Load generated data
-X, _, _, _ = bench.load_data(params, add_dtype=True)
-
-# Create our clustering object
-dbscan = DBSCAN(eps=params.eps, n_jobs=params.n_jobs,
-                min_samples=params.min_samples, metric='euclidean',
-                algorithm='auto')
-
-# N.B. algorithm='auto' will select DAAL's brute force method when running
-# daal4py-patched scikit-learn, and probably 'kdtree' when running unpatched
-# scikit-learn.
-
-# Time fit
-time, _ = bench.measure_function_time(dbscan.fit, X, params=params)
-labels = dbscan.labels_
-
-params.n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
-acc = davies_bouldin_score(X, labels)
-
-bench.print_output(library='sklearn', algorithm='dbscan', stages=['training'],
-                   params=params, functions=['DBSCAN'], times=[time], accuracies=[acc],
-                   accuracy_type='davies_bouldin_score', data=[X],
-                   alg_instance=dbscan)
+def main():
+    from sklearn.cluster import DBSCAN
+    from sklearn.metrics.cluster import davies_bouldin_score
+
+    # Load generated data
+    X, _, _, _ = bench.load_data(params, add_dtype=True)
+
+    # Create our clustering object
+    dbscan = DBSCAN(eps=params.eps, n_jobs=params.n_jobs,
+                    min_samples=params.min_samples, metric='euclidean',
+                    algorithm='auto')
+
+    # N.B. algorithm='auto' will select DAAL's brute force method when running
+    # daal4py-patched scikit-learn, and probably 'kdtree' when running unpatched
+    # scikit-learn.
+
+    # Time fit
+    time, _ = bench.measure_function_time(dbscan.fit, X, params=params)
+    labels = dbscan.labels_
+
+    params.n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
+    acc = davies_bouldin_score(X, labels)
+
+    bench.print_output(library='sklearn', algorithm='dbscan', stages=['training'],
+                    params=params, functions=['DBSCAN'], times=[time], accuracies=[acc],
+                    accuracy_type='davies_bouldin_score', data=[X],
+                    alg_instance=dbscan)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn DBSCAN benchmark')
+    parser.add_argument('-e', '--eps', '--epsilon', type=float, default=10.,
+                        help='Radius of neighborhood of a point')
+    parser.add_argument('-m', '--min-samples', default=5, type=int,
+                        help='The minimum number of samples required in a '
+                        'neighborhood to consider a point a core point')
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)

sklearn_bench/kmeans.py

@@ -20,63 +20,65 @@
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 import bench
 import numpy as np
-from sklearn.metrics.cluster import davies_bouldin_score
 
-parser = argparse.ArgumentParser(description='scikit-learn K-means benchmark')
-parser.add_argument('-i', '--filei', '--fileI', '--init',
-                    type=str, help='Initial clusters')
-parser.add_argument('-t', '--tol', type=float, default=0.,
-                    help='Absolute threshold')
-parser.add_argument('--maxiter', type=int, default=100,
-                    help='Maximum number of iterations')
-parser.add_argument('--n-clusters', type=int, help='Number of clusters')
-params = bench.parse_args(parser)
+def main():
+    from sklearn.cluster import KMeans
+    from sklearn.metrics.cluster import davies_bouldin_score
 
-from sklearn.cluster import KMeans
+    # Load and convert generated data
+    X_train, X_test, _, _ = bench.load_data(params)
 
-# Load and convert generated data
-X_train, X_test, _, _ = bench.load_data(params)
-
-if params.filei == 'k-means++':
-    X_init = 'k-means++'
-# Load initial centroids from specified path
-elif params.filei is not None:
-    X_init = np.load(params.filei).astype(params.dtype)
-    params.n_clusters = X_init.shape[0]
-# or choose random centroids from training data
-else:
-    np.random.seed(params.seed)
-    centroids_idx = np.random.randint(0, X_train.shape[0],
-                                      size=params.n_clusters)
-    if hasattr(X_train, "iloc"):
-        X_init = X_train.iloc[centroids_idx].values
+    if params.filei == 'k-means++':
+        X_init = 'k-means++'
+    # Load initial centroids from specified path
+    elif params.filei is not None:
+        X_init = np.load(params.filei).astype(params.dtype)
+        params.n_clusters = X_init.shape[0]
+    # or choose random centroids from training data
     else:
-        X_init = X_train[centroids_idx]
+        np.random.seed(params.seed)
+        centroids_idx = np.random.randint(0, X_train.shape[0],
+                                        size=params.n_clusters)
+        if hasattr(X_train, "iloc"):
+            X_init = X_train.iloc[centroids_idx].values
+        else:
+            X_init = X_train[centroids_idx]
 
 
-def fit_kmeans(X):
-    global X_init, params
-    alg = KMeans(n_clusters=params.n_clusters, tol=params.tol,
-                 max_iter=params.maxiter, init=X_init, n_init=1)
-    alg.fit(X)
-    return alg
+    def fit_kmeans(X, X_init):
+        alg = KMeans(n_clusters=params.n_clusters, tol=params.tol,
+                    max_iter=params.maxiter, init=X_init, n_init=1)
+        alg.fit(X)
+        return alg
 
+    # Time fit
+    fit_time, kmeans = bench.measure_function_time(fit_kmeans, X_train, X_init, params=params)
 
-# Time fit
-fit_time, kmeans = bench.measure_function_time(fit_kmeans, X_train, params=params)
+    train_predict = kmeans.predict(X_train)
+    acc_train = davies_bouldin_score(X_train, train_predict)
 
-train_predict = kmeans.predict(X_train)
-acc_train = davies_bouldin_score(X_train, train_predict)
+    # Time predict
+    predict_time, test_predict = bench.measure_function_time(
+        kmeans.predict, X_test, params=params)
 
-# Time predict
-predict_time, test_predict = bench.measure_function_time(
-    kmeans.predict, X_test, params=params)
+    acc_test = davies_bouldin_score(X_test, test_predict)
 
-acc_test = davies_bouldin_score(X_test, test_predict)
+    bench.print_output(library='sklearn', algorithm='kmeans',
+                    stages=['training', 'prediction'],
+                    params=params, functions=['KMeans.fit', 'KMeans.predict'],
+                    times=[fit_time, predict_time], accuracy_type='davies_bouldin_score',
+                    accuracies=[acc_train, acc_test], data=[X_train, X_test],
+                    alg_instance=kmeans)
 
-bench.print_output(library='sklearn', algorithm='kmeans',
-                   stages=['training', 'prediction'],
-                   params=params, functions=['KMeans.fit', 'KMeans.predict'],
-                   times=[fit_time, predict_time], accuracy_type='davies_bouldin_score',
-                   accuracies=[acc_train, acc_test], data=[X_train, X_test],
-                   alg_instance=kmeans)
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn K-means benchmark')
+    parser.add_argument('-i', '--filei', '--fileI', '--init',
+                        type=str, help='Initial clusters')
+    parser.add_argument('-t', '--tol', type=float, default=0.,
+                        help='Absolute threshold')
+    parser.add_argument('--maxiter', type=int, default=100,
+                        help='Maximum number of iterations')
+    parser.add_argument('--n-clusters', type=int, help='Number of clusters')
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)
+

sklearn_bench/linear.py

@@ -21,36 +21,39 @@
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 import bench
 
-parser = argparse.ArgumentParser(description='scikit-learn linear regression '
-                                             'benchmark')
-parser.add_argument('--no-fit-intercept', dest='fit_intercept', default=True,
-                    action='store_false',
-                    help="Don't fit intercept (assume data already centered)")
-params = bench.parse_args(parser)
+def main():
+    from sklearn.linear_model import LinearRegression
 
-from sklearn.linear_model import LinearRegression
+    # Load data
+    X_train, X_test, y_train, y_test = bench.load_data(
+        params, generated_data=['X_train', 'y_train'])
 
-# Load data
-X_train, X_test, y_train, y_test = bench.load_data(
-    params, generated_data=['X_train', 'y_train'])
+    # Create our regression object
+    regr = LinearRegression(fit_intercept=params.fit_intercept,
+                            n_jobs=params.n_jobs, copy_X=False)
 
-# Create our regression object
-regr = LinearRegression(fit_intercept=params.fit_intercept,
-                        n_jobs=params.n_jobs, copy_X=False)
+    # Time fit
+    fit_time, _ = bench.measure_function_time(regr.fit, X_train, y_train, params=params)
 
-# Time fit
-fit_time, _ = bench.measure_function_time(regr.fit, X_train, y_train, params=params)
+    # Time predict
+    predict_time, yp = bench.measure_function_time(regr.predict, X_test, params=params)
 
-# Time predict
-predict_time, yp = bench.measure_function_time(regr.predict, X_test, params=params)
+    test_rmse = bench.rmse_score(yp, y_test)
+    yp = regr.predict(X_train)
+    train_rmse = bench.rmse_score(yp, y_train)
 
-test_rmse = bench.rmse_score(yp, y_test)
-yp = regr.predict(X_train)
-train_rmse = bench.rmse_score(yp, y_train)
+    bench.print_output(library='sklearn', algorithm='linear_regression',
+                    stages=['training', 'prediction'],
+                    params=params, functions=['Linear.fit', 'Linear.predict'],
+                    times=[fit_time, predict_time], accuracy_type='rmse',
+                    accuracies=[train_rmse, test_rmse], data=[X_train, X_test],
+                    alg_instance=regr)
 
-bench.print_output(library='sklearn', algorithm='linear_regression',
-                   stages=['training', 'prediction'],
-                   params=params, functions=['Linear.fit', 'Linear.predict'],
-                   times=[fit_time, predict_time], accuracy_type='rmse',
-                   accuracies=[train_rmse, test_rmse], data=[X_train, X_test],
-                   alg_instance=regr)
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn linear regression '
+                                             'benchmark')
+    parser.add_argument('--no-fit-intercept', dest='fit_intercept', default=True,
+                        action='store_false',
+                        help="Don't fit intercept (assume data already centered)")
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)