def prefix_to_infix_list(prefix_list):
"""
Changes prefix formulas in a list to their infix forms
Args:
prefix_list: list of prefix formulas
Returns: nothing
"""
length = len(prefix_list)
for i in range(0, length):
prefix_list.append(STL.prefix_to_infix(prefix_list[0]))
prefix_list.pop(0)
def print_detailed_result(prefix, formula, folder_name, signal_file_base,
signal_file_rest, trace_count):
"""
Args:
prefix: (bool) 1 if formula given is prefix, 0 if its infix
formula: STL formula
Returns: nothing
"""
if prefix:
infix_formula = STL.prefix_to_infix(formula)
else:
infix_formula = formula
fp_fn_tp_tn = cause_mining_heuristic.cause_mining_print_detailed_result(
infix_formula, folder_name, signal_file_base, trace_count,
signal_file_rest)
return fp_fn_tp_tn
def cause_mining_traffic_data(pc,
valuation_limit,
folder_name,
trace_count,
signal_file_base,
return_type,
operator_count_limit,
withoutS=False,
controllable_formulas=True):
"""
Calls cause_mining_algorithm from cause_mining_algo package with traffic data.
Returns: best formula in prefix form
"""
print(
"---------------------------------------------------------------------------------------"
)
print(" cause_mining_traffic_data ")
print(
"---------------------------------------------------------------------------------------"
)
start_time = time.time()
save = True
metric_list = ['6', '1', '2', '3', '4', '5', '0']
control_metrics = ['5', '6']
set_valued_metrics = ['6', '5']
parameter_domains = {
'p0': range(10, 40, 5),
'p1': range(10, 40, 5),
'p2': range(10, 40, 5),
'p3': range(5, 20, 5),
'p4': range(5, 20, 5),
'p5': range(0, 2, 1),
'p6': range(0, 2, 1),
'pA': range(0, 6, 1),
'pP': range(0, 6, 1),
'pS': range(0, 6, 2),
'pT': [1, 2]
}
result_file = 'min_max'
strictly_increasing_oc = False
best_result = cause_mining_heuristic.cause_mining_algorithm(
metric_list=metric_list,
control_metrics=control_metrics,
set_valued_metrics=set_valued_metrics,
parameter_domains=parameter_domains,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
process_count=pc,
save=save,
result_file=result_file,
return_type=return_type,
strictly_increasing_oc=strictly_increasing_oc,
valuation_limit=valuation_limit,
operator_count_limit=operator_count_limit,
withoutS=withoutS,
controllable_formulas=controllable_formulas,
time_shift=1) # type: FormulaValuation
print('### --------end of cause mining for traffic data-------- ### ')
print("Best Result in prefix form : " + best_result.formula +\
"\nBest Result in infix form: " + STL.prefix_to_infix(best_result.formula) + \
"\nWith the Valuation : " + str(best_result.valuation))
end_time = time.time()
print("")
print(
"---------------------------------------------------------------------------------------"
)
print("cause_mining_traffic_data ended in %s seconds" %
str(end_time - start_time))
print(
"---------------------------------------------------------------------------------------"
)
print("folder name: " + folder_name)
print("trace count: " + str(trace_count))
print("processor count: " + str(pc))
print("parameter domains: " + str(parameter_domains))
print("return type: " + return_type.name)
print("strictly increasing: " + str(strictly_increasing_oc))
print("searched until operator count: " + str(operator_count_limit))
return best_result.formula
def cause_mining_for_basic_example(pc,
valuation_limit,
folder_name,
trace_count,
signal_file_base,
return_type,
operator_count_limit,
withoutS=False,
controllable_formulas=True):
"""
Calls cause_mining_algorithm -with heuristic- from cause_mining_algo package with basic_example data.
Returns: best formula in prefix form
"""
print(
"---------------------------------------------------------------------------------------"
)
print(" cause_mining_for_basic_example ")
print(
"---------------------------------------------------------------------------------------"
)
start_time = time.time()
save = False
metric_list = ['0', '1']
control_metrics = ['1']
set_valued_metrics = ['1']
parameter_domains = {
'p0': range(3, 6, 1),
'p1': [-2, 1, 2],
'pA': range(0, 3, 1),
'pP': range(0, 3, 1),
'pS': range(0, 3, 1),
'pT': [1, 2]
}
result_file = 'min_max'
strictly_increasing_oc = False
best_result = cause_mining_heuristic.cause_mining_algorithm(
metric_list=metric_list,
control_metrics=control_metrics,
set_valued_metrics=set_valued_metrics,
parameter_domains=parameter_domains,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
process_count=pc,
save=save,
result_file=result_file,
return_type=return_type,
strictly_increasing_oc=strictly_increasing_oc,
valuation_limit=valuation_limit,
operator_count_limit=operator_count_limit,
withoutS=withoutS,
controllable_formulas=controllable_formulas) # type: FormulaValuation
# formula is in prefix form
print('### --------end of cause mining for basic example -------- ### ')
print("Best Result in prefix form : " + best_result.formula +\
"\nBest Result in infix form: " + STL.prefix_to_infix(best_result.formula) + \
"\nWith the Valuation : " + str(best_result.valuation))
end_time = time.time()
print("")
print(
"---------------------------------------------------------------------------------------"
)
print("cause_mining_for_basic_example ended in %s seconds" %
str(end_time - start_time))
print(
"---------------------------------------------------------------------------------------"
)
print("folder name: " + folder_name)
print("trace count: " + str(trace_count))
print("processor count: " + str(pc))
print("parameter domains: " + str(parameter_domains))
print("return type: " + return_type.name)
print("strictly increasing: " + str(strictly_increasing_oc))
print("searched until operator count: " + str(operator_count_limit))
return best_result.formula # prefix formula
def controller_n_times(n,
sabit_folder,
test_folder,
viol_formula,
return_type,
operator_count_limit,
pc,
signal_file_base,
signal_file_rest,
trace_count,
duration,
valuation_limit=0.1,
heuristic=True,
upto=True,
cause_limit=1,
withoutS=False):
"""
Args:
n: how many times will we iterate in controller refinement?
sabit_folder: if it is None, then we generate a random initial file and mine it to find the cause formula;
if it is not None, we will mine sabit_folder to find the cause formula initially.
test_folder: this is the folder in which we will create the traffic data generated by the controller and rewrite
it in every loop
viol_formula:
return_type: fitness value
operator_count_limit:
pc:
signal_file_base:
signal_file_rest:
trace_count:
duration:
valuation_limit: used iff heuristic==True. A formula stays as a component of the big formula iff the valuation
it adds to the big formula is bigger than the valuation_limit.
heuristic: (bool) if True, use cause mining heuristic algorithm, if False use search all search space.
upto: used iff heuristic == False. If True, consider all formulas with operator counts upto the given
operator_count limit, if False, consider only the formulas with operator_count = given operator_count_limit.
cause_limit: used iff heuristic == False. In search_all_search_space, find cause_formulas with cause_limit
many subformulas concatenated with |.
withoutS: (bool) if True, the formulas are generated without Since.
Returns:
"""
print(
"--------------------entering controller_n_times-----------------------"
)
violation_counts = []
cause_formula_list = []
if not sabit_folder:
traffic_signal_generator(test_folder, pc)
folder_name = test_folder
else:
folder_name = sabit_folder
vc = cma.controller_helper_funs.label_count(folder_name, 'test_', '_label',
20)
violation_counts.append(vc)
print("initial violation count : " + str(vc))
if heuristic: # heuristic cannot be used yet for oc_limit = [oc_limit_lhs, oc_limit_rhs] form
cause_formula_prefix = cause_mining_traffic_data(
pc=pc,
valuation_limit=valuation_limit,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
return_type=return_type,
operator_count_limit=operator_count_limit,
withoutS=withoutS) # best formula in prefix form
else:
best_result = search_all_search_space_traffic_data(
pc=pc,
return_type=return_type,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
cause_limit=cause_limit,
operator_count_limit=operator_count_limit,
upto=upto,
withoutS=withoutS)
cause_formula_prefix = STL.infix_to_prefix(best_result.formula)
cause_formula_infix = STL.prefix_to_infix(cause_formula_prefix)
cause_formula_list.append(cause_formula_infix)
cmm.print_detailed_result(prefix=1,
formula=cause_formula_prefix,
folder_name=folder_name,
signal_file_base=signal_file_base,
signal_file_rest=signal_file_rest,
trace_count=trace_count)
folder_name = test_folder
for i in range(1, n + 1):
print("-- -- -- In iteration number " + str(i) + " -- -- -- ")
cause_formula = helper_funs.concat_with_or_infix(cause_formula_list)
cause_formula = STL.infix_to_prefix(cause_formula)
print("- - results of the whole cause formula - - ")
cmm.print_detailed_result(prefix=1,
formula=cause_formula,
folder_name=folder_name,
signal_file_base=signal_file_base,
signal_file_rest=signal_file_rest,
trace_count=trace_count)
controller_traffic_data(folder_name=folder_name,
viol_formula=viol_formula,
trace_count=trace_count,
duration=duration,
pc=pc,
cause_formula=cause_formula)
violation_counts.append(
cma.controller_helper_funs.label_count(test_folder, 'test_',
'_label', 20))
print("violation count: " + str(violation_counts[i]))
if violation_counts[i] == 0:
break
if not i == n:
if heuristic:
last_formula_prefix = cause_mining_traffic_data(
pc=pc,
valuation_limit=valuation_limit,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
return_type=return_type,
operator_count_limit=operator_count_limit,
withoutS=withoutS) # best formula in prefix form
else:
best_result = search_all_search_space_traffic_data(
pc=pc,
return_type=return_type,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
cause_limit=cause_limit,
operator_count_limit=operator_count_limit,
upto=upto,
withoutS=withoutS)
last_formula_prefix = STL.infix_to_prefix(best_result.formula)
last_formula_infix = STL.prefix_to_infix(last_formula_prefix)
cause_formula_list.append(last_formula_infix)
print("- - results of the last formula - - ")
cmm.print_detailed_result(prefix=1,
formula=last_formula_prefix,
folder_name=folder_name,
signal_file_base=signal_file_base,
signal_file_rest=signal_file_rest,
trace_count=trace_count)
print(
"--------------------exiting controller_n_times-----------------------"
)
