Merge branch 'mypy-applying' into xgb-nvidia-datasets

Author: Igor Rukhovich

datasets/load_datasets.py

@@ -59,8 +59,8 @@ def try_load_dataset(dataset_name: str, output_directory: Path) -> bool:
     if dataset_name in dataset_loaders:
         try:
             return dataset_loaders[dataset_name](output_directory)
-        except BaseException:
-            logging.warning("Internal error loading dataset")
+        except BaseException as ex:
+            logging.warning(f"Internal error loading dataset:\n{ex}")
             return False
     else:
         logging.warning(f"There is no script to download the dataset: {dataset_name}. "

sklearn_bench/df_clsf.py

@@ -20,60 +20,64 @@
 import numpy as np
 from sklearn.metrics import accuracy_score
 
-parser = argparse.ArgumentParser(description='scikit-learn random forest '
-                                             'classification benchmark')
 
-parser.add_argument('--criterion', type=str, default='gini',
-                    choices=('gini', 'entropy'),
-                    help='The function to measure the quality of a split')
-parser.add_argument('--num-trees', type=int, default=100,
-                    help='Number of trees in the forest')
-parser.add_argument('--max-features', type=bench.float_or_int, default=None,
-                    help='Upper bound on features used at each split')
-parser.add_argument('--max-depth', type=int, default=None,
-                    help='Upper bound on depth of constructed trees')
-parser.add_argument('--min-samples-split', type=bench.float_or_int, default=2,
-                    help='Minimum samples number for node splitting')
-parser.add_argument('--max-leaf-nodes', type=int, default=None,
-                    help='Maximum leaf nodes per tree')
-parser.add_argument('--min-impurity-decrease', type=float, default=0.,
-                    help='Needed impurity decrease for node splitting')
-parser.add_argument('--no-bootstrap', dest='bootstrap', default=True,
-                    action='store_false', help="Don't control bootstraping")
+def main():
+    from sklearn.ensemble import RandomForestClassifier
 
-params = bench.parse_args(parser)
+    # Load and convert data
+    X_train, X_test, y_train, y_test = bench.load_data(params)
 
-if not params.no_intel_optimized:
-    from sklearn.ensemble import RandomForestClassifier
+    # Create our random forest classifier
+    clf = RandomForestClassifier(criterion=params.criterion,
+                                 n_estimators=params.num_trees,
+                                 max_depth=params.max_depth,
+                                 max_features=params.max_features,
+                                 min_samples_split=params.min_samples_split,
+                                 max_leaf_nodes=params.max_leaf_nodes,
+                                 min_impurity_decrease=params.min_impurity_decrease,
+                                 bootstrap=params.bootstrap,
+                                 random_state=params.seed,
+                                 n_jobs=params.n_jobs)
+
+    params.n_classes = len(np.unique(y_train))
+
+    fit_time, _ = bench.measure_function_time(clf.fit, X_train, y_train, params=params)
+    y_pred = clf.predict(X_train)
+    train_acc = 100 * accuracy_score(y_pred, y_train)
 
-# Load and convert data
-X_train, X_test, y_train, y_test = bench.load_data(params)
+    predict_time, y_pred = bench.measure_function_time(
+        clf.predict, X_test, params=params)
+    test_acc = 100 * accuracy_score(y_pred, y_test)
 
-# Create our random forest classifier
-clf = RandomForestClassifier(criterion=params.criterion,
-                             n_estimators=params.num_trees,
-                             max_depth=params.max_depth,
-                             max_features=params.max_features,
-                             min_samples_split=params.min_samples_split,
-                             max_leaf_nodes=params.max_leaf_nodes,
-                             min_impurity_decrease=params.min_impurity_decrease,
-                             bootstrap=params.bootstrap,
-                             random_state=params.seed,
-                             n_jobs=params.n_jobs)
+    bench.print_output(library='sklearn', algorithm='decision_forest_classification',
+                       stages=['training', 'prediction'], params=params,
+                       functions=['df_clsf.fit', 'df_clsf.predict'],
+                       times=[fit_time, predict_time], accuracy_type='accuracy[%]',
+                       accuracies=[train_acc, test_acc], data=[X_train, X_test],
+                       alg_instance=clf)
 
-params.n_classes = len(np.unique(y_train))
 
-fit_time, _ = bench.measure_function_time(clf.fit, X_train, y_train, params=params)
-y_pred = clf.predict(X_train)
-train_acc = 100 * accuracy_score(y_pred, y_train)
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn random forest '
+                                                 'classification benchmark')
 
-predict_time, y_pred = bench.measure_function_time(
-    clf.predict, X_test, params=params)
-test_acc = 100 * accuracy_score(y_pred, y_test)
+    parser.add_argument('--criterion', type=str, default='gini',
+                        choices=('gini', 'entropy'),
+                        help='The function to measure the quality of a split')
+    parser.add_argument('--num-trees', type=int, default=100,
+                        help='Number of trees in the forest')
+    parser.add_argument('--max-features', type=bench.float_or_int, default=None,
+                        help='Upper bound on features used at each split')
+    parser.add_argument('--max-depth', type=int, default=None,
+                        help='Upper bound on depth of constructed trees')
+    parser.add_argument('--min-samples-split', type=bench.float_or_int, default=2,
+                        help='Minimum samples number for node splitting')
+    parser.add_argument('--max-leaf-nodes', type=int, default=None,
+                        help='Maximum leaf nodes per tree')
+    parser.add_argument('--min-impurity-decrease', type=float, default=0.,
+                        help='Needed impurity decrease for node splitting')
+    parser.add_argument('--no-bootstrap', dest='bootstrap', default=True,
+                        action='store_false', help="Don't control bootstraping")
 
-bench.print_output(library='sklearn', algorithm='decision_forest_classification',
-                   stages=['training', 'prediction'], params=params,
-                   functions=['df_clsf.fit', 'df_clsf.predict'],
-                   times=[fit_time, predict_time], accuracy_type='accuracy[%]',
-                   accuracies=[train_acc, test_acc], data=[X_train, X_test],
-                   alg_instance=clf)
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)

sklearn_bench/df_regr.py

@@ -18,60 +18,64 @@
 
 import bench
 
-parser = argparse.ArgumentParser(description='scikit-learn random forest '
-                                             'regression benchmark')
 
-parser.add_argument('--criterion', type=str, default='mse',
-                    choices=('mse', 'mae'),
-                    help='The function to measure the quality of a split')
-parser.add_argument('--num-trees', type=int, default=100,
-                    help='Number of trees in the forest')
-parser.add_argument('--max-features', type=bench.float_or_int, default=None,
-                    help='Upper bound on features used at each split')
-parser.add_argument('--max-depth', type=int, default=None,
-                    help='Upper bound on depth of constructed trees')
-parser.add_argument('--min-samples-split', type=bench.float_or_int, default=2,
-                    help='Minimum samples number for node splitting')
-parser.add_argument('--max-leaf-nodes', type=int, default=None,
-                    help='Grow trees with max_leaf_nodes in best-first fashion'
-                         'if it is not None')
-parser.add_argument('--min-impurity-decrease', type=float, default=0.,
-                    help='Needed impurity decrease for node splitting')
-parser.add_argument('--no-bootstrap', dest='bootstrap', default=True,
-                    action='store_false', help="Don't control bootstraping")
+def main():
+    from sklearn.ensemble import RandomForestRegressor
 
-params = bench.parse_args(parser)
+    # Load and convert data
+    X_train, X_test, y_train, y_test = bench.load_data(params)
 
-if not params.no_intel_optimized:
-    from sklearn.ensemble import RandomForestRegressor
+    # Create our random forest regressor
+    regr = RandomForestRegressor(criterion=params.criterion,
+                                 n_estimators=params.num_trees,
+                                 max_depth=params.max_depth,
+                                 max_features=params.max_features,
+                                 min_samples_split=params.min_samples_split,
+                                 max_leaf_nodes=params.max_leaf_nodes,
+                                 min_impurity_decrease=params.min_impurity_decrease,
+                                 bootstrap=params.bootstrap,
+                                 random_state=params.seed,
+                                 n_jobs=params.n_jobs)
+
+    fit_time, _ = bench.measure_function_time(regr.fit, X_train, y_train, params=params)
+
+    y_pred = regr.predict(X_train)
+    train_rmse = bench.rmse_score(y_pred, y_train)
 
-# Load and convert data
-X_train, X_test, y_train, y_test = bench.load_data(params)
+    predict_time, y_pred = bench.measure_function_time(
+        regr.predict, X_test, params=params)
+    test_rmse = bench.rmse_score(y_pred, y_test)
 
-# Create our random forest regressor
-regr = RandomForestRegressor(criterion=params.criterion,
-                             n_estimators=params.num_trees,
-                             max_depth=params.max_depth,
-                             max_features=params.max_features,
-                             min_samples_split=params.min_samples_split,
-                             max_leaf_nodes=params.max_leaf_nodes,
-                             min_impurity_decrease=params.min_impurity_decrease,
-                             bootstrap=params.bootstrap,
-                             random_state=params.seed,
-                             n_jobs=params.n_jobs)
+    bench.print_output(library='sklearn', algorithm='decision_forest_regression',
+                       stages=['training', 'prediction'], params=params,
+                       functions=['df_regr.fit', 'df_regr.predict'],
+                       times=[fit_time, predict_time], accuracy_type='rmse',
+                       accuracies=[train_rmse, test_rmse], data=[X_train, X_test],
+                       alg_instance=regr)
 
-fit_time, _ = bench.measure_function_time(regr.fit, X_train, y_train, params=params)
 
-y_pred = regr.predict(X_train)
-train_rmse = bench.rmse_score(y_pred, y_train)
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn random forest '
+                                     'regression benchmark')
 
-predict_time, y_pred = bench.measure_function_time(
-    regr.predict, X_test, params=params)
-test_rmse = bench.rmse_score(y_pred, y_test)
+    parser.add_argument('--criterion', type=str, default='mse',
+                        choices=('mse', 'mae'),
+                        help='The function to measure the quality of a split')
+    parser.add_argument('--num-trees', type=int, default=100,
+                        help='Number of trees in the forest')
+    parser.add_argument('--max-features', type=bench.float_or_int, default=None,
+                        help='Upper bound on features used at each split')
+    parser.add_argument('--max-depth', type=int, default=None,
+                        help='Upper bound on depth of constructed trees')
+    parser.add_argument('--min-samples-split', type=bench.float_or_int, default=2,
+                        help='Minimum samples number for node splitting')
+    parser.add_argument('--max-leaf-nodes', type=int, default=None,
+                        help='Grow trees with max_leaf_nodes in best-first fashion'
+                        'if it is not None')
+    parser.add_argument('--min-impurity-decrease', type=float, default=0.,
+                        help='Needed impurity decrease for node splitting')
+    parser.add_argument('--no-bootstrap', dest='bootstrap', default=True,
+                        action='store_false', help="Don't control bootstraping")
 
-bench.print_output(library='sklearn', algorithm='decision_forest_regression',
-                   stages=['training', 'prediction'], params=params,
-                   functions=['df_regr.fit', 'df_regr.predict'],
-                   times=[fit_time, predict_time], accuracy_type='rmse',
-                   accuracies=[train_rmse, test_rmse], data=[X_train, X_test],
-                   alg_instance=regr)
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)

sklearn_bench/distances.py

@@ -18,23 +18,27 @@
 
 import bench
 
-parser = argparse.ArgumentParser(description='scikit-learn pairwise distances '
-                                             'benchmark')
-parser.add_argument('--metric', default='cosine',
-                    choices=['cosine', 'correlation'],
-                    help='Metric to test for pairwise distances')
-params = bench.parse_args(parser)
-
-if not params.no_intel_optimized:
+
+def main():
     from sklearn.metrics.pairwise import pairwise_distances
 
-# Load data
-X, _, _, _ = bench.load_data(params, generated_data=['X_train'], add_dtype=True)
+    # Load data
+    X, _, _, _ = bench.load_data(params, generated_data=['X_train'], add_dtype=True)
+
+    time, _ = bench.measure_function_time(pairwise_distances, X, metric=params.metric,
+                                          n_jobs=params.n_jobs, params=params)
+
+    bench.print_output(library='sklearn', algorithm='distances', stages=['computation'],
+                       params=params, functions=[params.metric.capitalize()], times=[time],
+                       accuracy_type=None, accuracies=[None], data=[X],
+                       alg_params={'metric': params.metric})
 
-time, _ = bench.measure_function_time(pairwise_distances, X, metric=params.metric,
-                                      n_jobs=params.n_jobs, params=params)
 
-bench.print_output(library='sklearn', algorithm='distances', stages=['computation'],
-                   params=params, functions=[params.metric.capitalize()], times=[time],
-                   accuracy_type=None, accuracies=[None], data=[X],
-                   alg_params={'metric': params.metric})
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn pairwise distances '
+                                     'benchmark')
+    parser.add_argument('--metric', default='cosine',
+                        choices=['cosine', 'correlation'],
+                        help='Metric to test for pairwise distances')
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)

sklearn_bench/elasticnet.py

@@ -18,45 +18,49 @@
 
 import bench
 
-parser = argparse.ArgumentParser(description='scikit-learn elastic-net regression '
-                                             'benchmark')
-parser.add_argument('--no-fit-intercept', dest='fit_intercept', default=False,
-                    action='store_false',
-                    help="Don't fit intercept (assume data already centered)")
-parser.add_argument('--alpha', dest='alpha', type=float, default=1.0,
-                    help='Regularization parameter')
-parser.add_argument('--maxiter', type=int, default=1000,
-                    help='Maximum iterations for the iterative solver')
-parser.add_argument('--l1_ratio', dest='l1_ratio', type=float, default=0.5,
-                    help='Regularization parameter')
-parser.add_argument('--tol', type=float, default=0.0,
-                    help='Tolerance for solver.')
-params = bench.parse_args(parser)
-
-if not params.no_intel_optimized:
+
+def main():
     from sklearn.linear_model import ElasticNet
 
-# Load data
-X_train, X_test, y_train, y_test = bench.load_data(params)
-
-# Create our regression object
-regr = ElasticNet(fit_intercept=params.fit_intercept, l1_ratio=params.l1_ratio,
-                  alpha=params.alpha, tol=params.tol,
-                  max_iter=params.maxiter, copy_X=False)
-# Time fit
-fit_time, _ = bench.measure_function_time(regr.fit, X_train, y_train, params=params)
-
-# Time predict
-predict_time, pred_train = bench.measure_function_time(regr.predict,
-                                                       X_train, params=params)
-
-train_rmse = bench.rmse_score(pred_train, y_train)
-pred_test = regr.predict(X_test)
-test_rmse = bench.rmse_score(pred_test, y_test)
-
-bench.print_output(library='sklearn', algorithm='elastic-net',
-                   stages=['training', 'prediction'], params=params,
-                   functions=['ElasticNet.fit', 'ElasticNet.predict'],
-                   times=[fit_time, predict_time], accuracy_type='rmse',
-                   accuracies=[train_rmse, test_rmse], data=[X_train, X_train],
-                   alg_instance=regr)
+    # Load data
+    X_train, X_test, y_train, y_test = bench.load_data(params)
+
+    # Create our regression object
+    regr = ElasticNet(fit_intercept=params.fit_intercept, l1_ratio=params.l1_ratio,
+                      alpha=params.alpha, tol=params.tol,
+                      max_iter=params.maxiter, copy_X=False)
+    # Time fit
+    fit_time, _ = bench.measure_function_time(regr.fit, X_train, y_train, params=params)
+
+    # Time predict
+    predict_time, pred_train = bench.measure_function_time(regr.predict,
+                                                           X_train, params=params)
+
+    train_rmse = bench.rmse_score(pred_train, y_train)
+    pred_test = regr.predict(X_test)
+    test_rmse = bench.rmse_score(pred_test, y_test)
+
+    bench.print_output(library='sklearn', algorithm='elastic-net',
+                       stages=['training', 'prediction'], params=params,
+                       functions=['ElasticNet.fit', 'ElasticNet.predict'],
+                       times=[fit_time, predict_time], accuracy_type='rmse',
+                       accuracies=[train_rmse, test_rmse], data=[X_train, X_train],
+                       alg_instance=regr)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='scikit-learn elastic-net regression '
+                                     'benchmark')
+    parser.add_argument('--no-fit-intercept', dest='fit_intercept', default=False,
+                        action='store_false',
+                        help="Don't fit intercept (assume data already centered)")
+    parser.add_argument('--alpha', dest='alpha', type=float, default=1.0,
+                        help='Regularization parameter')
+    parser.add_argument('--maxiter', type=int, default=1000,
+                        help='Maximum iterations for the iterative solver')
+    parser.add_argument('--l1_ratio', dest='l1_ratio', type=float, default=0.5,
+                        help='Regularization parameter')
+    parser.add_argument('--tol', type=float, default=0.0,
+                        help='Tolerance for solver.')
+    params = bench.parse_args(parser)
+    bench.run_with_context(params, main)