Classes
class	XBGoostTextNode

Functions
def	dump_tree (tree_structure)

def	dump2ROOT (model, output_filename, output_treename='xgboost')

def	convertXGBoostToRootTree (model, output_filename, tree_name='xgboost')

def	test (model_file, tree_file, objective, tree_name='xgboost', ntests=10000, test_file=None)

def	test_regression (booster, mva_utils, objective, ntests=10000, test_file=None)

def	test_binary (booster, mva_utils, objective, ntests=10000, test_file=None)

def	test_multiclass (booster, mva_utils, objective, ntests=10000, test_file=None)

def	check_file (fn)

Variables
string	__author__ = "Yuan-Tang Chou"

	level

	parser = argparse.ArgumentParser(description=__doc__)

	help

	type

	str

	default

	action

	int

	args = parser.parse_args()

list	supported_objective = ['binary:logistic', 'reg:linear', 'reg:squarederror','multi:softprob']

def	output_treename = convertXGBoostToRootTree(args.input, args.output, args.tree_name)

def	result = test(args.input, args.output, args.objective, args.tree_name, args.ntests, args.test_file)

	objective = args.objective

	data = np.load(args.test_file)

Function Documentation

◆ check_file()

def util.convertXGBoostToRootTree.check_file ( fn )

Definition at line 279 of file convertXGBoostToRootTree.py.

 def check_file(fn):
     f = ROOT.TFile.Open(fn)
     keys = f.GetListOfKeys()
     keys = list(keys)
     if len(keys) != 1:
         logging.info("file %s is empty", fn)
         return False
     tree = f.Get(keys[0].GetName())
     if type(tree) is not ROOT.TTree:
         logging.info("cannot find TTree in file %s", fn)
         return False
     if not tree.GetEntries():
         logging.info("tree is empty")
         return False
     return True
  
  

◆ convertXGBoostToRootTree()

def util.convertXGBoostToRootTree.convertXGBoostToRootTree	(	model,
		output_filename,
		tree_name = `'xgboost'`
	)

Model: - a string, in this case, it is the name of the input file containing the xgboost model
         you can get this model with xgboost with `bst.save_model('my_model.model')
       - directly a xgboost booster object

Definition at line 133 of file convertXGBoostToRootTree.py.

 def convertXGBoostToRootTree(model, output_filename, tree_name='xgboost'):
     """
     Model: - a string, in this case, it is the name of the input file containing the xgboost model
              you can get this model with xgboost with `bst.save_model('my_model.model')
            - directly a xgboost booster object
     """
     if type(model) is str:
         bst = xgb.Booster()
         bst.load_model(model)
         return dump2ROOT(bst, output_filename, tree_name)
     else:
         return dump2ROOT(model, output_filename, tree_name)
  
  

◆ dump2ROOT()

def util.convertXGBoostToRootTree.dump2ROOT	(	model,
		output_filename,
		output_treename = `'xgboost'`
	)

Definition at line 93 of file convertXGBoostToRootTree.py.

 def dump2ROOT(model, output_filename, output_treename='xgboost'):
     model.dump_model('dump_model.json', dump_format='json')
     with open('dump_model.json', 'r') as dump_json:
         model_dump = dump_json.read()
     trees = json.loads(model_dump)
     fout = ROOT.TFile.Open(output_filename, 'recreate')
  
     features_array = ROOT.std.vector('int')()
     values_array = ROOT.std.vector('float')()
     default_lefts_array = ROOT.std.vector('bool')()
  
     title = 'creator=xgboost'
     root_tree = ROOT.TTree(output_treename, title)
     root_tree.Branch('vars', 'vector<int>', ROOT.AddressOf(features_array))
     root_tree.Branch('values', 'vector<float>', ROOT.AddressOf(values_array))
     root_tree.Branch('default_left', 'vector<bool>', ROOT.AddressOf(default_lefts_array))
  
     logging.info("tree support nan: using XGBoost implementation")
  
     for tree in trees:
         tree_structure = tree
         features, values, default_lefts = dump_tree(tree_structure)
  
         features_array.clear()
         values_array.clear()
         default_lefts_array.clear()
  
         for value in values:
             values_array.push_back(value)
         for feature in features:
             features_array.push_back(feature)
         for default_left in default_lefts:
             default_lefts_array.push_back(default_left)
  
         root_tree.Fill()
  
     root_tree.Write()
     fout.Close()
     return output_treename
  

◆ dump_tree()

def util.convertXGBoostToRootTree.dump_tree ( tree_structure )

dump a single decision tree to arrays to be written into the TTree

Definition at line 67 of file convertXGBoostToRootTree.py.

 def dump_tree(tree_structure):
     """
     dump a single decision tree to arrays to be written into the TTree
     """
  
     split_values = []
     split_features = []
     default_left = []
     top = XBGoostTextNode(tree_structure)
  
     def preorder(node):
         # visit root
         split_features.append(node.get_split_feature())
         split_values.append(node.get_value())
         default_left.append(node.get_default_left())
  
         # visit (yes)left
         if node.get_left() is not None:
             preorder(node.get_left())
         # visit (no)right
         if node.get_right() is not None:
             preorder(node.get_right())
  
     preorder(top)
     return split_features, split_values, default_left
  

◆ test()

def util.convertXGBoostToRootTree.test	(	model_file,
		tree_file,
		objective,
		tree_name = `'xgboost'`,
		ntests = `10000`,
		test_file = `None`
	)

Definition at line 147 of file convertXGBoostToRootTree.py.

 def test(model_file, tree_file, objective, tree_name='xgboost', ntests=10000, test_file=None):
     bst = xgb.Booster()
     bst.load_model(model_file)
     f = ROOT.TFile.Open(tree_file)
     tree = f.Get(tree_name)
     try:
         _ = ROOT.MVAUtils.BDT
     except Exception:
         print("cannot import MVAUtils")
         return None
  
     mva_utils = ROOT.MVAUtils.BDT(tree)
  
     if 'binary' in objective:
         logging.info("testing binary")
         return test_binary(bst, mva_utils, objective, ntests, test_file)
     elif 'multi' in objective:
         logging.info("testing multi-class")
         return test_multiclass(bst,mva_utils, objective, ntests, test_file)
     else:
         logging.info("testing regression")
         return test_regression(bst, mva_utils, objective, ntests, test_file)
  

◆ test_binary()

def util.convertXGBoostToRootTree.test_binary	(	booster,
		mva_utils,
		objective,
		ntests = `10000`,
		test_file = `None`
	)

Definition at line 206 of file convertXGBoostToRootTree.py.

 def test_binary(booster, mva_utils, objective, ntests=10000, test_file=None):
     import numpy as np
     logging.info("Testing input features with binary classification")
     if test_file is not None:
         data_input = np.load(test_file)
         logging.info("using as input %s inputs from file %s", len(data_input), test_file)
     else:
         logging.error("Please provide an input test file for testing")
  
     start = time.time()
     dTest = xgb.DMatrix(data_input)
     results_xgboost = booster.predict(dTest)
     logging.info("xgboost (vectorized) timing = %s ms/input", (time.time() - start) * 1000 / len(data_input))
  
     input_values_vector = ROOT.std.vector("float")()
     results_MVAUtils = []
     start = time.time()
     for input_values in data_input:
         input_values_vector.clear()
         for v in input_values:
             input_values_vector.push_back(v)
         output_MVAUtils = mva_utils.GetClassification(input_values_vector)
         results_MVAUtils.append(output_MVAUtils)
     logging.info("mvautils (not vectorized+overhead) timing = %s ms/input", (time.time() - start) * 1000 / len(data_input))
  
     for input_values, output_xgb, output_MVAUtils in zip(data_input, results_xgboost, results_MVAUtils):
         if not np.allclose(output_xgb, output_MVAUtils):
             logging.info("output are different:"
                          "mvautils: %s\n"
                          "xgboost: %s\n"
                          "inputs: %s", output_MVAUtils, output_xgb, input_values)
             return False
     return True
  

◆ test_multiclass()

def util.convertXGBoostToRootTree.test_multiclass	(	booster,
		mva_utils,
		objective,
		ntests = `10000`,
		test_file = `None`
	)

Definition at line 240 of file convertXGBoostToRootTree.py.

 def test_multiclass(booster, mva_utils, objective, ntests=10000, test_file=None):
     import numpy as np
     logging.info("using multiclass model")
  
     if test_file is not None:
         data_input = np.load(test_file)
         logging.info("using as input %s inputs from file %s", len(data_input), test_file)
     else:
         logging.error("Please provide an input test file for testing")
  
     start = time.time()
     dTest = xgb.DMatrix(data_input)
     results_xgboost = booster.predict(dTest)
     
     nclasses = results_xgboost.shape[1]
     logging.info("xgboost (vectorized) timing = %s ms/input", (time.time() - start) * 1000 / len(data_input))
  
     input_values_vector = ROOT.std.vector("float")()
     results_MVAUtils = []
     start = time.time()
     for input_values in data_input:
         input_values_vector.clear()
         for v in input_values:
             input_values_vector.push_back(v)
         output_MVAUtils = mva_utils.GetMultiResponse(input_values_vector, nclasses)
         results_MVAUtils.append(output_MVAUtils)
  
     logging.info("mvautils (not vectorized+overhead) timing = %s ms/input", (time.time() - start) * 1000 / len(data_input))
  
     for input_values, output_xgb, output_MVAUtils in zip(data_input, results_xgboost, results_MVAUtils):
         if not np.allclose(output_xgb, output_MVAUtils):
             logging.info("output are different:"
                          "mvautils: %s\n"
                          "xgboost: %s\n"
                          "inputs: %s", output_MVAUtils, output_xgb, input_values)
             return False
     return True
  
  

◆ test_regression()

def util.convertXGBoostToRootTree.test_regression	(	booster,
		mva_utils,
		objective,
		ntests = `10000`,
		test_file = `None`
	)

Definition at line 170 of file convertXGBoostToRootTree.py.

 def test_regression(booster, mva_utils, objective, ntests=10000, test_file=None):
     import numpy as np
     logging.info("Tesing input features with regression")
  
     if test_file is not None:
         data_input = np.load(test_file)
         logging.info("using as input %s inputs from file %s", len(data_input), test_file)
     else:
         logging.error("Please provide an input test file for testing")
  
     start = time.time()
     dTest = xgb.DMatrix(data_input)
     results_xgboost = booster.predict(dTest)
     logging.info("xgboost (vectorized) timing = %s ms/input", (time.time() - start) * 1000 / len(data_input))
  
     input_values_vector = ROOT.std.vector("float")()
     results_MVAUtils = []
     start = time.time()
     for input_values in data_input:
         input_values_vector.clear()
         for v in input_values:
             input_values_vector.push_back(v)
         output_MVAUtils = mva_utils.GetResponse(input_values_vector)
         results_MVAUtils.append(output_MVAUtils)
     logging.info("mvautils (not vectorized+overhead) timing = %s ms/input", (time.time() - start) * 1000 / len(data_input))
  
     for input_values, output_xgb, output_MVAUtils in zip(data_input, results_xgboost, results_MVAUtils):
         if not np.allclose(output_xgb, output_MVAUtils, rtol=1E-4):
             logging.info("output are different:"
                          "mvautils: %s\n"
                          "xgboost: %s\n"
                          "inputs: %s", output_MVAUtils, output_xgb, input_values)
             return False
     return True
  
  