def parameter_search_for_formula(formula, parameter_domains_for_formula, folder_name, trace_count, signal_file_base,
process_count, return_type, past_results=[]):
parameter_list = list(parameter_domains_for_formula.keys())
parameter_domain = [parameter_domains_for_formula[pa] for pa in parameter_list]
prefix_formula = STL.infix_to_prefix(formula)
best_v, params, time_passed = grid_search.grid_search(formula=prefix_formula, parameter_list=parameter_list,
parameter_domain=parameter_domain, folder_name=folder_name,
signal_file_base=signal_file_base, trace_count=trace_count,
signal_file_rest='', process_count=process_count,
return_type=return_type, past_results=past_results)
#result_file = folder_name + "".join(formula.split()) + ".mat"
#_ = plot.convert_save_results(parameter_list, parameter_domain, all_results, result_file, formula,
# time_passed, trace_count, process_count, best_v, params)
formula_n = formula
if params == None:
print( "There are no best parameters for the formula: " + formula )
else:
for p, v in zip(parameter_list, params):
formula_n = formula_n.replace(p, str(v))
print("With valuation " + str(best_v) + " ,best parameters form " + formula_n + " ,with prefix form: " +
STL.infix_to_prefix(formula_n) + " ,in time: " + str(time_passed))
return stl_constants.FormulaValuation(formula=formula_n, valuation=best_v)
def cause_mining_print_detailed_result(infix_formula, folder_name, signal_file_base, trace_count, signal_file_rest):
"""
Written as a function to see how "good" a formula is, mainly to help us debug.
This function prints the false positive, false negative, true positive, true negative, precision,
recall and various f scores of the infix formula given as an input.
"""
prefix_formula = STL.infix_to_prefix(infix_formula)
fp_fn_tp_tn = evaluator.evaluate_signals(formula=prefix_formula, folder_name=folder_name,
signal_file_base=signal_file_base, trace_count=trace_count,
signal_file_rest=signal_file_rest, return_type=stl_constants.__DETAILED)
print(infix_formula)
fp = str(fp_fn_tp_tn[0])
fn = str(fp_fn_tp_tn[1])
tp = str(fp_fn_tp_tn[2])
tn = str(fp_fn_tp_tn[3])
precision = str(metrics_util.calculate_precision(fp_fn_tp_tn))
recall = str(metrics_util.calculate_recall(fp_fn_tp_tn))
f1 = str(metrics_util.calculate_f1_score(fp_fn_tp_tn))
f05 = str(metrics_util.calculate_fhalf_score(fp_fn_tp_tn))
f09 = str(metrics_util.calculate_f_Beta_score(fp_fn_tp_tn, 0.9))
f01 = str(metrics_util.calculate_f_Beta_score(fp_fn_tp_tn, 0.1))
f015 = str(metrics_util.calculate_f_Beta_score(fp_fn_tp_tn, 0.15))
f02 = str(metrics_util.calculate_f_Beta_score(fp_fn_tp_tn, 0.2))
f03 = str(metrics_util.calculate_f_Beta_score(fp_fn_tp_tn, 0.3))
f04 = str(metrics_util.calculate_f_Beta_score(fp_fn_tp_tn, 0.4))
print('fp: ' + fp + ' fn: ' + fn + ' tp: ' + tp + ' tn: ' + tn +
' precision: ' + precision + ' recall: ' + recall +
' \nf1 score: ' + f1 + ' f0.5 score: ' + f05 + ' f0.9 score: ' + f09 +
' \nf0.1 score: ' + f01 + ' f0.15 score: ' + f015 + ' f0.2 score: ' + f02 +
' f0.3 score: ' + f03 + ' \nf0.4 score: ' + f04)
return fp_fn_tp_tn
def formula_val_list_into_concat_formula_list(prefix_formula_val_list,
folder_name, signal_file_base,
trace_count, signal_file_rest,
return_type):
"""
Designed for debug purposes of cause mining algorithm
Takes only the formula parts of a Formula_Valuation list, turns them into their infix forms,
concatenates them with or and calculates the valuation of the resulting formula. Returns the resulting formula and
the valuation as a FormulaValuation.
Args:
prefix_formula_val_list: A list of Formula Valuations where formulas are in prefix forms.
Ex: [FormulaValuation(formula='A 0 4 x5 = 0', valuation=0.7824),
FormulaValuation(formula='& A 0 2 x5 = 0 P 1 1 x3 > 10', valuation=0.921521)]
return_type:
Returns: a FormulaValuation
"""
infix_formula_list = [fv.formula for fv in prefix_formula_val_list]
prefix_to_infix_list(infix_formula_list)
concat_with_or_infix(infix_formula_list)
formula = STL.infix_to_prefix(infix_formula_list[0])
valuation = optimization.evaluator.evaluate_signals(
formula, folder_name, signal_file_base, trace_count, signal_file_rest,
return_type)
return stl_constants.FormulaValuation(formula=infix_formula_list[0],
valuation=valuation)
def controller_traffic_data(viol_formula, folder_name, trace_count, duration,
pc, cause_formula):
"""
Args:
cause_formula: formula got from cause_mining_traffic_data (in prefix form)
Returns: nothing
"""
#traffic_file = "test_data/traffic_data/l5_system"
#traffic_file_no_soln = "test_data/traffic_data/l5_system_no_soln"
#traffic_file_no_soln2 = "test_data/traffic_data/l5_system_no_soln2"
traffic_file_no_soln3 = "test_data/traffic_data/l5_system_no_soln3"
link_dict, intersection_dict = read_input.load_from_annotated_file(
traffic_file_no_soln3)
tn = network.Network(link_dict, intersection_dict, scale=5)
uk_count = tn.get_intersection_count()
xk_initialized = np.zeros(tn.get_link_count())
tn.initialize_links(xk_initialized, 0.1)
viol_formula_prefix = STL.infix_to_prefix(viol_formula)
sg.controller(folder_name=folder_name,
name='test',
trace_count=trace_count,
duration=duration,
viol_formula=viol_formula_prefix,
cause_formula=cause_formula,
step_function=tn.step,
xk_initialized=xk_initialized,
uk_domain=[0, 1],
uk_count=uk_count,
num_to_let=True)
def find_best_formula(folder_name,
trace_count,
heuristic,
duration,
signal_file_base,
signal_file_rest,
return_type,
operator_count_limit,
pc,
upto,
cause_limit,
withoutS,
valuation_limit=None):
"""
Returns: the best formula found with heuristic algorithm if heuristic == True, found with search_all_search_space if
heuristic == False.
"""
if not heuristic:
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)
else:
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
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)
return cause_formula_prefix
def print_past_formulas_prefix_infix_valuation(past_results, folder_name,
signal_file_base, trace_count,
signal_file_rest, return_type):
"""
Debugging tool for past formulas.
Calls formula_val_list_into_concat_formula_list and calculates the resulting formula from past_results list
(or any FormulaValuation list with formulas in prefix forms), returns the prefix and infix form and the
valuation of the resulting formula
"""
forVal = formula_val_list_into_concat_formula_list(
past_results, folder_name, signal_file_base, trace_count,
signal_file_rest, return_type)
print("Infix Formula: " + forVal.formula)
print("Prefix Formula: " + STL.infix_to_prefix(forVal.formula))
print("Valuation: " + str(forVal.valuation))
def look_for_any_formula(folder_name,
trace_count,
heuristic,
duration,
signal_file_base,
signal_file_rest,
return_type,
operator_count_limit,
pc,
upto,
cause_limit,
withoutS,
valuation_limit=None):
if not heuristic:
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,
controllable_formulas=False)
cause_formula_prefix = STL.infix_to_prefix(best_result.formula)
else:
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,
controllable_formulas=False) # best formula in prefix form
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)
return cause_formula_prefix
def convert_and_evaluate(formula_list, parallel_process_count, parameter_domains, folder_name, signal_file_base,
return_type, trace_count, metric_list, set_valued_metrics):
nodes_list = []
for formula in formula_list:
formula = inject_parameters(formula, parameter_domains, metric_list, set_valued_metrics)
formula = STL.infix_to_prefix(formula)
syntax_tree_node = STL.SyntaxTreeNode()
syntax_tree_node.initialize_node(formula.split(), 0)
nodes_list.append(syntax_tree_node)
pool = Pool(processes=parallel_process_count)
fitness_partial = partial(insert_fitness_value_to_individual, folder_name, signal_file_base, return_type,
trace_count)
results = (pool.map(fitness_partial, nodes_list))
pool.close()
pool.join()
return results
def return_sc_form(formula, prefix=True):
"""
Args:
formula: formula to be written with "next" statements
prefix: bool value that indicates whether the given formula is prefix or infix
Returns: formula written with only X and !. For example, return_sc_form('P 1 1 ( x0 = 0 ))', False) = 'X (x0=0.0)'
"""
if not prefix:
formula = STL.infix_to_prefix(formula)
stn = STL.SyntaxTreeNode()
stn.initialize_node(formula.split(), 0)
next_form_str = return_next_form(stn)
#print(next_form_str)
return next_form_str
def traffic_signal_generator(folder_name, pc):
# This function uses the package "signal_generation". This is for "cause mining."
# generates new traffic_signal data with given violation_formula, trace_count and duration.
#viol_formula = "( ( ( ( ( x0 < 30 ) & ( x1 < 30 ) ) & ( x2 < 30 ) ) & ( x3 < 15 ) ) & ( x4 < 15 ) )"
#viol_formula_no_soln = "( ( ( ( ( x0 < 32 ) & ( x1 < 32 ) ) & ( x2 < 32 ) ) & ( x3 < 16 ) ) & ( x4 < 16 ) )"
#viol_formula_no_soln2 = "( ( ( ( ( x0 < 30 ) & ( x1 < 30 ) ) & ( x2 < 30 ) ) & ( x3 < 15 ) ) & ( x4 < 15 ) )"
viol_formula_no_soln3 = "( ( ( ( ( x0 < 30 ) & ( x1 < 30 ) ) & ( x2 < 30 ) ) & ( x3 < 15 ) ) & ( x4 < 15 ) )"
viol_formula_prefix = STL.infix_to_prefix(viol_formula_no_soln3)
trace_count = 20
duration = 100
#traffic_file = "test_data/traffic_data/l5_system"
#traffic_file_no_soln = "test_data/traffic_data/l5_system_no_soln"
#traffic_file_no_soln2 = "test_data/traffic_data/l5_system_no_soln2"
traffic_file_no_soln3 = "test_data/traffic_data/l5_system_no_soln3"
generator.generate_traffic_traces(folder_name=folder_name,
file_name="test",
trace_count=trace_count,
viol_formula=viol_formula_prefix,
traffic_file=traffic_file_no_soln3,
duration=duration,
pc=pc)
def cause_mining_algorithm(metric_list, control_metrics, set_valued_metrics, parameter_domains, folder_name,
trace_count, signal_file_base, process_count, save, result_file, return_type,
strictly_increasing_oc, valuation_limit, operator_count_limit, withoutS=False,
controllable_formulas=True, time_shift=0):
"""
Args:
metric_list:
control_metrics:
set_valued_metrics:
parameter_domains:
folder_name:
trace_count:
signal_file_base:
process_count:
save:
result_file:
return_type:
strictly_increasing_oc: (bool) If False, the heuristic is applied while increasing operator count, if True,
operator count increases by one in each loop.
valuation_limit: the predefined limit which decides how much of a value addition is enough for a best formula of
an operator count to enter the past_formula list.
operator_count_limit: Last operator count. The best_formulas are searched for until operator count reaches this
integer value.
controllable_formulas: (bool) if True, cause_mining input is given to formula_search as True, and
generate_formula_tree_cause_mining is called inside formula_search_operator_count as a
consequence. That is, controllable formulas are synthesized.
if False, cause_mining input is given to formula_search as False, and
generate_formula_tree_iterative is called inside formula_search_operator_count as a
consequence. That is, all kinds of formulas are generated.
By default, controllable_formulas = True, so only controllable formulas are generated.
Returns: FormulaValuation(the resulting formula -small best formulas concatenated with ors- in prefix form, its valuation)
"""
if type(operator_count_limit) is int:
oc_rhs_limit = operator_count_limit
else:
_, oc_rhs_limit = operator_count_limit
if controllable_formulas: # we do this since if controllable_formulas == True, the code will enter generate_formula_tree_iterative and this function cannot process oc = -1
current_oc = -1
else:
current_oc = 0
past_results = [] # all formulas in past_results must be in prefix form
if not strictly_increasing_oc:
last_used_oc = current_oc
while True:
results, best_formula = formula_search.formula_search(metric_list=metric_list,
set_valued_metrics=set_valued_metrics,
operator_counts=[current_oc],
parameter_domains=parameter_domains,
folder_name=folder_name,
trace_count=trace_count, generate_signals="",
signal_file_base=signal_file_base,
process_count=process_count,
save=save, cause_mining=controllable_formulas,
return_type=return_type,
result_file=result_file,
control_metrics=control_metrics,
past_results=past_results, withoutS=withoutS,
time_shift=time_shift)
# turn the formula into prefix form, and then append it to past_results.
best_formula_prefix = stl_constants.FormulaValuation(formula=STL.infix_to_prefix(best_formula.formula),
valuation=best_formula.valuation)
past_results.append(best_formula_prefix)
if len(past_results) > 1 and (past_results[-1].valuation - past_results[-2].valuation) < valuation_limit:
past_results.pop()
if last_used_oc < current_oc:
print("break 1")
break
current_oc += 1
print("oc change to " + str(current_oc))
elif len(past_results) > 1 and (past_results[-1].valuation - past_results[-2].valuation) > valuation_limit:
last_used_oc = current_oc
print("last used oc : " + str(last_used_oc))
print("?????????????????? PAST RESULTS SO FAR ???????????????????????????")
print(past_results)
#helper_funs.print_past_formulas_prefix_infix_valuation(past_results=past_results, folder_name=folder_name,
# signal_file_base=signal_file_base,
# trace_count=trace_count,
# signal_file_rest='', return_type=return_type)
if current_oc == oc_rhs_limit+1:
break
else: # i.e. if strictly_increasing_oc:
while True:
results, best_formula = formula_search.formula_search(metric_list=metric_list,
set_valued_metrics=set_valued_metrics,
operator_counts=[current_oc],
parameter_domains=parameter_domains,
folder_name=folder_name,
trace_count=trace_count, generate_signals="",
signal_file_base=signal_file_base,
process_count=process_count,
save=save, cause_mining=controllable_formulas,
return_type=return_type,
result_file=result_file,
control_metrics=control_metrics,
past_results=past_results,
time_shift=time_shift)
# turn the formula into prefix form, and the append it to past_results.
best_formula_prefix = stl_constants.FormulaValuation(formula=STL.infix_to_prefix(best_formula.formula),
valuation=best_formula.valuation)
past_results.append(best_formula_prefix)
if len(past_results) > 1 and (past_results[-1].valuation - past_results[-2].valuation) < valuation_limit:
past_results.pop()
print("break 2")
break
current_oc += 1
if current_oc == operator_count_limit+1:
break
print("?????????????????? PAST RESULTS SO FAR ???????????????????????????")
print(past_results)
past_formulas = [fv.formula for fv in past_results]
#for formula_valuation in past_results:
#past_formulas.append(STL.prefix_to_infix(formula_valuation.formula))
# now the list is consisted of infix formulas, it can go into concat_with_or
result = stl_constants.FormulaValuation(formula=helper_funs.concat_with_or_prefix(past_formulas),
valuation=past_results[-1].valuation)
return result
def give_average_violation_cnt_reducement_ratio_fp_count_and_formula_length(
sabit_folder,
test_folder,
viol_formula,
return_type,
operator_count_limit,
pc,
loop_count,
signal_file_base,
signal_file_rest,
trace_count,
duration,
valuation_limit=0.1,
heuristic=True,
upto=True,
cause_limit=1,
withoutS=False):
"""
Args:
sabit_folder: if it is None, then we generate signals and find cause formulas all over again in every loop,
if not, we find the cause formula once and generate controllers with it loop_count many times.
test_folder:
viol_formula:
return_type:
operator_count_limit:
pc:
loop_count:
signal_file_base:
signal_file_rest:
trace_count:
duration:
valuation_limit:
heuristic: (bool) if True, use cause mining heuristic algorithm, if False use search all search space.
upto:
cause_limit:
withoutS: (bool) if True, the formulas are generated without Since
Returns: nothing
"""
average_reducement_ratio = 0
average_formula_fp_count = 0
average_formula_length = 0
average_violation_count = 0
if sabit_folder == None:
for i in range(loop_count):
traffic_signal_generator(test_folder, pc)
violation_count_1 = cma.controller_helper_funs.label_count(
test_folder, 'test_', '_label', 20)
print("violation count beginning: " + str(violation_count_1))
if heuristic:
cause_formula_prefix = cause_mining_traffic_data(
pc=pc,
valuation_limit=valuation_limit,
folder_name=test_folder,
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=test_folder,
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)
average_formula_length += helper_funs.count_formula_components(
cause_formula_prefix) + 1
cmm.print_detailed_result(prefix=1,
formula=cause_formula_prefix,
folder_name=test_folder,
signal_file_base=signal_file_base,
signal_file_rest=signal_file_rest,
trace_count=trace_count)
fp_fn_tp_tn = evaluator.evaluate_signals(
formula=cause_formula_prefix,
folder_name=test_folder,
signal_file_base=signal_file_base,
trace_count=trace_count,
signal_file_rest=signal_file_rest,
return_type=stl_constants.__DETAILED)
formula_fp_count = fp_fn_tp_tn[0]
average_formula_fp_count += formula_fp_count
controller_traffic_data(folder_name=test_folder,
viol_formula=viol_formula,
trace_count=trace_count,
duration=duration,
pc=pc,
cause_formula=cause_formula_prefix)
violation_count_2 = cma.controller_helper_funs.label_count(
test_folder, 'test_', '_label', 20)
print("violation count end: " + str(violation_count_2))
violation_red_ratio = 1 - (float(violation_count_2) /
float(violation_count_1))
average_violation_count += violation_count_2
average_reducement_ratio += violation_red_ratio
print("v_c_1: " + str(violation_count_1) + " v_c_2: " +
str(violation_count_2))
average_formula_fp_count /= float(loop_count)
average_formula_length /= float(loop_count)
else:
violation_count_beginning = cma.controller_helper_funs.label_count(
sabit_folder, 'test_', '_label', 20)
print("violation count of sabit folder is " +
str(violation_count_beginning))
if heuristic:
cause_formula_prefix = cause_mining_traffic_data(
pc=pc,
valuation_limit=valuation_limit,
folder_name=sabit_folder,
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=sabit_folder,
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)
average_formula_length = helper_funs.count_formula_components(
cause_formula_prefix) + 1
cmm.print_detailed_result(prefix=1,
formula=cause_formula_prefix,
folder_name=sabit_folder,
ignal_file_base=signal_file_base,
signal_file_rest=signal_file_rest,
trace_count=trace_count)
fp_fn_tp_tn = evaluator.evaluate_signals(
formula=cause_formula_prefix,
folder_name=sabit_folder,
signal_file_base=signal_file_base,
trace_count=trace_count,
signal_file_rest=signal_file_rest,
return_type=stl_constants.__DETAILED)
average_formula_fp_count = fp_fn_tp_tn[0]
for i in range(loop_count):
controller_traffic_data(folder_name=test_folder,
viol_formula=viol_formula,
trace_count=trace_count,
duration=duration,
pc=pc,
cause_formula=cause_formula_prefix)
violation_count = cma.controller_helper_funs.label_count(
test_folder, 'test_', '_label', 20)
print("violation count in loop: " + str(i) + " is " +
str(violation_count))
average_violation_count += violation_count
violation_red_ratio = 1 - (float(violation_count) /
float(violation_count_beginning))
average_reducement_ratio += violation_red_ratio
average_reducement_ratio /= float(loop_count)
average_violation_count /= float(loop_count)
return average_violation_count, average_reducement_ratio, average_formula_fp_count, average_formula_length
import sys
from trace_checker import STL
import evaluator
import stl_constants
#( XX p0 & ( p1 & p2 ) ) {'x5=0.0': 'p0', 'x3>10.0': 'p1', 'x2<20.0': 'p2'}
#( p0 & XX p1 ) {'x5=0.0': 'p0', 'x3>10.0': 'p1'}
#( P 1 1 ( ( x1 > 15 ) & ( x7 = 1 ) & ( x6 = 0 ) ) ) | ( P 1 1 ( ( x1 > 25 ) & ( x7 = 1 ) ) ) | ( P 1 1 ( ( x4 < 10 ) & ( x7 = 1 ) & ( x6 = 0 ) ) )
#print(sys.argv[1])
#optimized_formula=sys.argv[1]
optimized_formula='( P 1 1 ( ( v1 > 15 ) & ( v7 = 1 ) & ( v6 = 0 ) ) ) | ( P 1 1 ( ( v1 > 25 ) & ( v7 = 1 ) ) ) | ( P 1 1 ( ( v4 < 10 ) & ( v7 = 1 ) & ( v6 = 0 ) ) )'
folder_name = 'D:/CASE STUDY/ptSTL/stl_fs_sm-master/stl_fs_sm-master/test_data/traffic_data/traffic_data_l6/'
signal_file_base = 'test'
result = evaluator.evaluate_signals(STL.infix_to_prefix(optimized_formula), folder_name, signal_file_base, 20,
'',
stl_constants.__DETAILED, stn=None,
past_results=[])
# print('for formula = ' + optimized_formula + ' result is: ' + str(result))
print(str(result))
#[22, 2, 454, 1322]
def find_best_formula(heuristic, controllable_formulas):
folder_name = 'test_data/toy_example_data/'
trace_count = 20
signal_file_base = 'test'
signal_file_rest = ""
duration = 100
if controllable_formulas:
oc_limit_lhs = 1
oc_limit_rhs = 0
oc_limit = [oc_limit_lhs, oc_limit_rhs]
else:
oc_limit = 2
cause_limit = 1
pc = 8
return_type = stl_constants.__F_03_SCORE
withoutS = True
upto = False
valuation_limit = 0.0001
operator_count_limit_heuristic = 100
print("operator_count_limit = " + str(oc_limit))
print("pc = " + str(pc))
print("return type = " + str(return_type.category))
print("withoutS = " + str(withoutS))
print("heuristic = " + str(heuristic))
if heuristic:
print("valuation_limit = " + str(valuation_limit))
else:
print("cause_limit = " + str(cause_limit))
print("upto = " + str(upto))
if heuristic:
cause_formula_prefix = heuristic_toy_example(
pc=pc,
folder_name=folder_name,
valuation_limit=valuation_limit,
trace_count=trace_count,
signal_file_base=signal_file_base,
operator_count_limit=operator_count_limit_heuristic,
return_type=return_type,
withoutS=withoutS,
controllable_formulas=controllable_formulas
) # returns prefix formula (string)
else:
best_formula = search_all_search_space_toy_example(
cause_limit=cause_limit,
pc=pc,
return_type=return_type,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
upto=upto,
operator_count_limit=oc_limit,
withoutS=withoutS,
controllable_formulas=controllable_formulas)
cause_formula_prefix = STL.infix_to_prefix(best_formula)
cma.cause_mining_main.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)
return cause_formula_prefix
def controller_n_iterations(n, heuristic):
folder_name = 'test_data/toy_example_data/'
trace_count = 20
signal_file_base = 'test'
signal_file_rest = ""
duration = 100
cause_limit = 1
oc_limit = 0
pc = 8
return_type = stl_constants.__F_03_SCORE
withoutS = True
upto = False
uk_domain = [1, 2, 3, 4]
uk_count = 1
violation_formula = ' ! ( x0 = 0 ) & ! ( x1 = 5 ) & ! ( x1 = 6 ) ' # violation formula of game_map2
violation_formula2 = '! ( ( x0 < 2 ) & ( x1 < 4 ) ) & ! ( ( x0 > 3 ) & ( x1 > 3 ) )' # violation formula of game_map
viol_formula_prefix = STL.infix_to_prefix(violation_formula2)
formula_list = []
valuation_limit = 0.1
operator_count_limit_heuristic = 100
label_cnt = hf.label_count(folder_name=folder_name,
label_file_base='test_',
label_file_rest='_label',
trace_count=trace_count)
print("label count before the controller: " + str(label_cnt))
for i in range(0, n):
if heuristic:
cause_formula_prefix = heuristic_toy_example(
pc=pc,
folder_name=folder_name,
valuation_limit=valuation_limit,
trace_count=trace_count,
signal_file_base=signal_file_base,
operator_count_limit=operator_count_limit_heuristic,
return_type=return_type,
withoutS=withoutS) # returns prefix formula (string)
else:
best_formula = search_all_search_space_toy_example(
cause_limit=cause_limit,
pc=pc,
return_type=return_type,
folder_name=folder_name,
trace_count=trace_count,
signal_file_base=signal_file_base,
upto=upto,
operator_count_limit=oc_limit,
withoutS=withoutS)
if best_formula == "":
print("no formula with positive valuation")
break
cause_formula_prefix = STL.infix_to_prefix(best_formula)
cma.cause_mining_main.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)
formula_list.append(cause_formula_prefix)
cause_formula_prefix = cma.helper_funs.concat_with_or_prefix(
formula_list)
sg.controller(folder_name=folder_name,
name='test',
trace_count=trace_count,
duration=duration,
viol_formula=viol_formula_prefix,
cause_formula=cause_formula_prefix,
step_function=toy_example_step_function,
xk_initialized=(3, 4),
uk_domain=uk_domain,
uk_count=uk_count,
num_to_let=False)
label_cnt = hf.label_count(folder_name=folder_name,
label_file_base='test_',
label_file_rest='_label',
trace_count=trace_count)
print("label count after controller " + str(i) + " is: " +
str(label_cnt))
if label_cnt == 0:
break
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-----------------------"
)
def find_best_formula(heuristic, controllable_formulas=True):
"""
Args:
heuristic: (bool) True -> search the best formula by heuristic algorithm,
False -> search the best formula bu search_all_search_space
Returns: the best formula in prefix form
"""
folder_name = 'test_data/basic_example_data/'
trace_count = 20
duration = 100
pc = 0
return_type = stl_constants.__F_03_SCORE
cause_limit = 1
upto = False
withoutS = True
if controllable_formulas:
oc_limit_lhs = 1
oc_limit_rhs = 0
oc_limit = [oc_limit_lhs, oc_limit_rhs]
else:
oc_limit = 0
# for heuristic==True and print_detailed_results
valuation_limit = 0.01
signal_file_base = 'test'
signal_file_rest = ''
operator_count_limit = 1
print("operator_count_limit = " + str(oc_limit))
print("pc = " + str(pc))
print("return type = " + str(return_type.category))
print("withoutS = " + str(withoutS))
print("heuristic = " + str(heuristic))
if heuristic:
print("valuation_limit = " + str(valuation_limit))
else:
print("cause_limit = " + str(cause_limit))
print("upto = " + str(upto))
# generate random traces and check the label count
generate_basic_traces(folder_name, trace_count, duration)
if not heuristic:
best_formula = search_all_search_space_for_basic_example(
cause_limit=cause_limit,
pc=pc,
return_type=return_type,
operator_count_limit=oc_limit,
upto=upto,
withoutS=withoutS,
controllable_formulas=controllable_formulas)
cause_formula_prefix = STL.infix_to_prefix(best_formula)
else:
cause_formula_prefix = cause_mining_for_basic_example(
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,
controllable_formulas=controllable_formulas
) # best formula in prefix form
cma.cause_mining_main.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)
return cause_formula_prefix
def basic_example(heuristic):
"""
finds the best formula with heuristic or search_all_search_space and applies controller refinement loop_count times.
Args:
heuristic: (bool) True -> search the best formula by heuristic algorithm,
False -> search the best formula bu search_all_search_space
Returns: nothing
"""
loop_count = 6
folder_name = 'test_data/basic_example_data/'
trace_count = 20
duration = 100
pc = 24
return_type = stl_constants.__F_03_SCORE
oc_limit = 0
cause_limit = 1
upto = False
withoutS = True
#for heuristic==True and print_detailed_results
valuation_limit = 0.01
signal_file_base = 'test'
signal_file_rest = ''
operator_count_limit = 1
viol_formula = 'x0 < 5'
viol_formula_prefix = STL.infix_to_prefix(viol_formula)
uk_domain = [-2, 1, 2]
uk_count = 1
#generate random traces and check the label count
generate_basic_traces(folder_name, trace_count, duration)
label_cnt = hf.label_count(folder_name=folder_name,
label_file_base='test_',
label_file_rest='_label',
trace_count=trace_count)
print("label count before the controller: " + str(label_cnt))
formula_list = []
for i in range(loop_count):
if not heuristic:
best_formula = search_all_search_space_for_basic_example(
cause_limit=cause_limit,
pc=pc,
return_type=return_type,
operator_count_limit=oc_limit,
upto=upto,
withoutS=withoutS)
cause_formula_prefix = STL.infix_to_prefix(best_formula)
else:
cause_formula_prefix = cause_mining_for_basic_example(
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
cma.cause_mining_main.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)
formula_list.append(cause_formula_prefix)
cause_formula_prefix = helper_funs.concat_with_or_prefix(formula_list)
sg.controller(folder_name=folder_name,
name='test',
trace_count=trace_count,
duration=duration,
viol_formula=viol_formula_prefix,
cause_formula=cause_formula_prefix,
step_function=basic_example_step_function,
xk_initialized=[0],
uk_domain=uk_domain,
uk_count=uk_count,
num_to_let=False)
label_cnt = hf.label_count(folder_name=folder_name,
label_file_base='test_',
label_file_rest='_label',
trace_count=trace_count)
print("label count after controller " + str(i) + " is: " +
str(label_cnt))
if label_cnt == 0:
break
