TSNE and RF: fix cuml RF regressor benchmark and add cuml TSNE benchmark(without divergence)

Author: itearsl

bench.py

@@ -503,6 +503,8 @@ def gen_basic_dict(library, algorithm, stage, params, data, alg_instance=None,
             alg_instance_params = dict(alg_instance.attributes())
         else:
             alg_instance_params = dict(alg_instance.get_params())
+            if 'min_samples_leaf' in alg_instance_params:
+                alg_instance_params['dtype'] = str(alg_instance_params['dtype'])
         result['algorithm_parameters'].update(alg_instance_params)
     if alg_params is not None:
         result['algorithm_parameters'].update(alg_params)

cuml_bench/df_regr.py

@@ -15,46 +15,36 @@
 # ===============================================================================
 
 import argparse
-import pandas as pd
 import bench
+import cuml
 from cuml.ensemble import RandomForestRegressor
 
 parser = argparse.ArgumentParser(description='cuml 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('--split-algorithm', type=str, default='hist',
                     choices=('hist', 'global_quantile'),
                     help='The algorithm to determine how '
                          'nodes are split in the tree')
 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,
+parser.add_argument('--max-features', type=bench.float_or_int, default=1.0,
                     help='Upper bound on features used at each split')
-parser.add_argument('--max-depth', type=int, default=None,
+parser.add_argument('--max-depth', type=int, default=16,
                     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=-1,
                     help='Maximum leaf nodes per tree')
-parser.add_argument('--min-impurity-decrease', type=float, default=0.,
+parser.add_argument('--min-impurity-decrease', type=float, default=0.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")
 
 params = bench.parse_args(parser)
 
 # Load and convert data
-X_train, X_test, y_train, y_test = bench.load_data(params)
-y_train = y_test.values.ravel()
-y_train = y_test.values.ravel()
-
-if params.criterion == 'mse':
-    params.criterion = 2
-else:
-    params.criterion = 3
+X_train, X_test, y_train, y_test = bench.load_data(params, int_label=True)
 
 if params.split_algorithm == 'hist':
     params.split_algorithm = 0
@@ -63,18 +53,19 @@
 
 # Create our random forest regressor
 regr = RandomForestRegressor(
-    split_criterion=params.criterion,
-    split_algo=params.split_algorithm,
     n_estimators=params.num_trees,
-    max_depth=params.max_depth,
+    split_algo=params.split_algorithm,
     max_features=params.max_features,
     min_samples_split=params.min_samples_split,
+    max_depth=params.max_depth,
     max_leaves=params.max_leaf_nodes,
     min_impurity_decrease=params.min_impurity_decrease,
     bootstrap=params.bootstrap,
+
 )
 
 
+
 def fit(regr, X, y):
     return regr.fit(X, y)
 
@@ -84,7 +75,6 @@ def predict(regr, X):
 
 
 fit_time, _ = bench.measure_function_time(fit, regr, X_train, y_train, params=params)
-
 y_pred = predict(regr, X_train)
 train_rmse = bench.rmse_score(y_pred, y_train)
 

cuml_bench/tsne.py

@@ -1,5 +1,6 @@
 import argparse
 import pandas as pd
+import cuml
 import bench
 from cuml.manifold import TSNE
 
@@ -16,25 +17,22 @@
 parser.add_argument('--min-grad-norm', type=float, default=1e-7,
                     help='If the gradient norm is below this threshold, the optimization will be stopped.')
 parser.add_argument('--random-state', type=int, default=1234)
-
 params = bench.parse_args(parser)
 
 # Load and convert data
-X_train, X_test, _, _ = bench.load_data(params)
-full_x = pd.concat([X_train, X_test])
+X, _, _, _ = bench.load_data(params)
 
 # Create our random forest regressor
 tsne = TSNE(n_components=params.n_components, early_exaggeration=params.early_exaggeration,
             learning_rate=params.learning_rate, angle=params.angle,
             min_grad_norm=params.min_grad_norm, random_state=params.random_state)
 
-fit_time, _ = bench.measure_function_time(tsne.fit, full_x, params=params)
-
-divergence = tsne.kl_divergence_
+fit_time, _ = bench.measure_function_time(tsne.fit, X, params=params)
+# divergence = tsne.kl_divergence_
 
 bench.print_output(library='cuml', algorithm='tsne',
                    stages=['training'], params=params,
                    functions=['tsne.fit'],
-                   times=[fit_time], metric_type='divergence',
-                   metrics=[divergence], data=[full_x],
+                   times=[fit_time], metric_type=None,
+                   metrics=None, data=[X],
                    alg_instance=tsne)

sklearn_bench/df_regr.py

@@ -15,7 +15,6 @@
 # ===============================================================================
 
 import argparse
-
 import bench
 
 

sklearn_bench/tsne.py

@@ -15,25 +15,21 @@
 # ===============================================================================
 
 import argparse
-
 import bench
 import pandas as pd
 
 def main():
     from sklearn.manifold import TSNE
 
     # Load and convert data
-    X_train, X_test, _, _ = bench.load_data(params)
-    full_x = pd.concat([X_train, X_test])
+    X, _, _, _ = bench.load_data(params)
 
     # Create our TSNE model
     tsne = TSNE(n_components=params.n_components, early_exaggeration=params.early_exaggeration,
                 learning_rate=params.learning_rate, angle=params.angle,
                 min_grad_norm=params.min_grad_norm, random_state=params.random_state)
 
-    fit_time, _ = bench.measure_function_time(tsne.fit, full_x, params=params)
-
-    divergence = tsne.kl_divergence_
+    fit_time, _ = bench.measure_function_time(tsne.fit, X, params=params)
 
     bench.print_output(
         library='sklearn',
@@ -44,7 +40,7 @@ def main():
         times=[fit_time],
         metric_type='divergence',
         metrics=[divergence],
-        data=[full_x],
+        data=[X],
         alg_instance=tsne,
     )
 
@@ -64,6 +60,6 @@ def main():
     parser.add_argument('--min-grad-norm', type=float, default=1e-7,
                         help='If the gradient norm is below this threshold, the optimization will be stopped.')
     parser.add_argument('--random-state', type=int, default=1234)
-    
+
     params = bench.parse_args(parser)
     bench.run_with_context(params, main)