def main():
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-global_step_db',
required=True,
help='Path to db holding global step results.')
args, unknown = parser.parse_known_args()
fname_prev_state = path.abspath(args.prev_state_pkl)
global_db = path.abspath(args.global_step_db)
# Load local state
local_state = StateData.load(fname_prev_state).get_data()
# Load global node output
globalStatistics = Global2Local_TD.load(global_db).get_data()['global_in']
#raise ValueError(globalStatistics,local_state['args_X'])
# Run algorithm local step
Hist = run_local_step(
local_state['args_X'], local_state['args_Y'], local_state['args_bins'],
local_state['dataSchema'],
local_state['CategoricalVariablesWithDistinctValues'],
local_state['dataFrame'], globalStatistics)
# Pack results
local_out = multipleHist2_Loc2Glob_TD(
local_state['args_X'], local_state['args_Y'],
local_state['CategoricalVariablesWithDistinctValues'], Hist)
# Return the output data
local_out.transfer()
def main():
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-cur_state_pkl',
required=True,
help='Path to the pickle file holding the current state.')
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-global_step_db',
required=True,
help='Path to db holding global step results.')
args, unknown = parser.parse_known_args()
# raise ValueError(args)
fname_cur_state = path.abspath(args.cur_state_pkl)
fname_prev_state = path.abspath(args.prev_state_pkl)
global_db = path.abspath(args.global_step_db)
# Load local state
local_state = StateData.load(fname_prev_state).data
# Load global node output
global_out = LogRegrIter_Glob2Loc_TD.load(global_db)
# Run algorithm local iteration step
local_state, local_out = logregr_local_iter(local_state=local_state,
local_in=global_out)
# Save local state
local_state.save(fname=fname_cur_state)
# Return
local_out.transfer()
def main():
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-cur_state_pkl',
required=True,
help='Path to the pickle file holding the current state.')
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-local_step_dbs',
required=True,
help='Path to db holding local step results.')
args, unknown = parser.parse_known_args()
fname_cur_state = path.abspath(args.cur_state_pkl)
fname_prev_state = path.abspath(args.prev_state_pkl)
local_dbs = path.abspath(args.local_step_dbs)
# Load global state
global_state = StateData.load(fname_prev_state).data
# Load local nodes output
local_out = LogRegrIter_Loc2Glob_TD.load(local_dbs)
# Run algorithm global step
global_state, global_out = logregr_global_iter(global_state=global_state,
global_in=local_out)
# Save global state
global_state.save(fname=fname_cur_state)
# Return the algorithm's output
global_out.transfer()
def main(args):
sys.argv =args
# Parse arguments
parser = ArgumentParser()
parser.add_argument('-no_split_points', required=True, type=int, help='Number of split points')
parser.add_argument('-cur_state_pkl', required=True, help='Path to the pickle file holding the current state.')
parser.add_argument('-prev_state_pkl', required=True, help='Path to the pickle file holding the previous state.')
parser.add_argument('-local_step_dbs', required=True, help='Path to db holding local step results.')
args, unknown = parser.parse_known_args()
fname_cur_state = path.abspath(args.cur_state_pkl)
fname_prev_state = path.abspath(args.prev_state_pkl)
local_dbs = path.abspath(args.local_step_dbs)
# Load global state
global_state = StateData.load(fname_prev_state).data
# Load local nodes output
activePaths = CartIter1_Loc2Glob_TD.load(local_dbs).get_data()
# Run algorithm global iteration step
activePaths = cart_step_1_global(global_state['args_X'], global_state['args_Y'], global_state['CategoricalVariables'], activePaths, args.no_split_points)
global_out = Cart_Glob2Loc_TD( global_state['globalTree'], activePaths )
# Save global state
# Save global state
global_state = StateData( stepsNo = global_state['stepsNo'] + 1 ,
args_X = global_state['args_X'],
args_Y = global_state['args_Y'],
CategoricalVariables = global_state['CategoricalVariables'],
globalTree = global_state['globalTree'],
activePaths = activePaths,
t1 = global_state['t1'] )
global_state.save(fname=fname_cur_state)
# Return the algorithm's output
global_out.transfer()
def main(args):
sys.argv = args
init_logger()
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-cur_state_pkl',
required=True,
help='Path to the pickle file holding the current state.')
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-local_step_dbs',
required=True,
help='Path to db holding local step results.')
args, unknown = parser.parse_known_args()
fname_cur_state = path.abspath(args.cur_state_pkl)
fname_prev_state = path.abspath(args.prev_state_pkl)
local_dbs = path.abspath(args.local_step_dbs)
# Load global state
global_state = StateData.load(fname_prev_state).data
globalTreeJ = global_state['globalTree'].tree_to_json()
myresult = {"result": [{"type": "application/json", "data": globalTreeJ}]}
t1 = global_state['t1']
t2 = time.localtime(time.time())
t0 = ['yy', 'mm', 'dd', 'hh', 'min', 'sec', 'wday', 'yday', 'isdst']
logging.info(" Time: ")
for i in range(len(t1)):
logging.info([t0[i], t2[i], t1[i], t2[i] - t1[i]])
set_algorithms_output_data(myresult)
def main(args):
sys.argv = args
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-cur_state_pkl',
required=True,
help='Path to the pickle file holding the current state.')
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-global_step_db',
required=True,
help='Path to db holding global step results.')
args, unknown = parser.parse_known_args()
fname_cur_state = path.abspath(args.cur_state_pkl)
fname_prev_state = path.abspath(args.prev_state_pkl)
global_db = path.abspath(args.global_step_db)
# Load local state
local_state = StateData.load(fname_prev_state).data
# Load global node output
globalTree, activePaths = Cart_Glob2Loc_TD.load(global_db).get_data()
# Run algorithm local iteration step
activePaths = cart_step_3_local(local_state['dataFrame'],
local_state['args_X'],
local_state['args_Y'],
local_state['CategoricalVariables'],
activePaths)
## Finished
local_state = StateData(
args_X=local_state['args_X'],
args_Y=local_state['args_Y'],
CategoricalVariables=local_state['CategoricalVariables'],
dataFrame=local_state['dataFrame'],
globalTree=globalTree,
activePaths=activePaths)
local_out = CartIter3_Loc2Glob_TD(activePaths)
# Save local state
local_state.save(fname=fname_cur_state)
# Return
local_out.transfer()
def main():
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-max_iter',
type=int,
required=True,
help='Maximum number of iterations.')
args, unknown = parser.parse_known_args()
fname_prev_state = path.abspath(args.prev_state_pkl)
max_iter = args.max_iter
global_state = StateData.load(fname_prev_state).data
termination_condition(global_state, max_iter)
def main(args):
sys.argv =args
# Parse arguments
parser = ArgumentParser()
parser.add_argument('-prev_state_pkl', required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-max_depth', type=int, required=True, help='Maximum depth of tree')
args, unknown = parser.parse_known_args()
fname_prev_state = path.abspath(args.prev_state_pkl)
#max_iter = args.max_iter
global_state = StateData.load(fname_prev_state).data
if bool(global_state['activePaths']) == False or global_state['stepsNo'] > args.max_depth :
set_algorithms_output_data('STOP')
else:
set_algorithms_output_data('CONTINUE')
def main(args):
sys.argv = args
# Parse arguments
parser = ArgumentParser()
parser.add_argument(
'-cur_state_pkl',
required=True,
help='Path to the pickle file holding the current state.')
parser.add_argument(
'-prev_state_pkl',
required=True,
help='Path to the pickle file holding the previous state.')
parser.add_argument('-global_step_db',
required=True,
help='Path to db holding global step results.')
args, unknown = parser.parse_known_args()
fname_cur_state = path.abspath(args.cur_state_pkl)
fname_prev_state = path.abspath(args.prev_state_pkl)
global_db = path.abspath(args.global_step_db)
# Load local state
local_state = StateData.load(fname_prev_state).data
# Load global node output
globalTree, activePaths = Cart_Glob2Loc_TD.load(global_db).get_data()
# Run algorithm local iteration step
activePaths = cart_step_2_local(local_state['dataFrame'],
local_state['CategoricalVariables'],
local_state['args_X'],
local_state['args_Y'], activePaths)
#
# # Run algorithm local iteration step
# for key in activePaths:
# df = local_state['dataFrame']
# # For each unfinished path, find the subset of dataFrame (df)
# for i in xrange(len(activePaths[key]['filter'])):
# df = DataFrameFilter(df, activePaths[key]['filter'][i]["variable"],
# activePaths[key]['filter'][i]["operator"],
# activePaths[key]['filter'][i]["value"])
# if local_state['args_Y'][0] in local_state['CategoricalVariables']: #Classification Algorithm
# resultJ = node_computations(df, local_state['args_X'], activePaths[key], local_state['args_Y'][0], local_state['CategoricalVariables'],"classNumbers")
# activePaths[key]["classNumbersJ"] = dict(activePaths[key]["classNumbersJ"].items() + resultJ.items())
# elif local_state['args_Y'][0] not in local_state['CategoricalVariables']: # Regression Algorithm
# resultJ = node_computations(df, local_state['args_X'], activePaths[key], local_state['args_Y'][0], local_state['CategoricalVariables'],"statistics")
# activePaths[key]["statisticsJ"] = dict(activePaths[key]["statisticsJ"].items() + resultJ.items())
# #print activePaths
## Finished
local_state = StateData(
args_X=local_state['args_X'],
args_Y=local_state['args_Y'],
CategoricalVariables=local_state['CategoricalVariables'],
dataFrame=local_state['dataFrame'],
globalTree=globalTree,
activePaths=activePaths)
local_out = CartIter2_Loc2Glob_TD(activePaths)
# Save local state
local_state.save(fname=fname_cur_state)
# Return
local_out.transfer()
