def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = NakamuraCovering(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_v = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_w = Symbol('w', SymbolType.ST_TERMINAL)
self.symbol_x = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_y = Symbol('y', SymbolType.ST_TERMINAL)
self.symbol_z = Symbol('z', SymbolType.ST_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
self.rule_2 = Rule([self.symbol_B, self.symbol_x, self.symbol_C])
self.rule_3 = Rule([self.symbol_C, self.symbol_B, self.symbol_y])
self.rule_4 = Rule([self.symbol_D, self.symbol_D, self.symbol_C])
self.rule_5 = Rule([self.symbol_E, self.symbol_w])
self.rule_6 = Rule([self.symbol_E, self.symbol_D])
self.rules = [
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5,
self.rule_6
]
def benchmark_run_testing_threshold(self):
self.learning_mode = False
self.learning_mode_off()
self.grammar_induction(Iteration(), True)
self.fill_results()
self.learning_mode = True
return self.last_results
def setUp(self):
iteration = Iteration()
self.covering = StartStandardCovering()
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = Rule([self.left_symbol, self.first_right_symbol])
def init_crowding_and_covering(self, grammar: sGCSGrammar):
self.crowding = StandardCrowding(self.__settings)
self.final_covering = CoveringDeterminer.get_final_covering(
self.__settings, self.crowding)
self.terminal_covering = CoveringDeterminer.get_terminal_covering(
self.__settings, self.crowding)
self.aggressive_covering = CoveringDeterminer.get_aggressive_covering(
self.__settings, self.crowding)
self.start_covering = CoveringDeterminer.get_start_covering(
self.__settings, self.crowding)
self.iteration = Iteration()
self.iteration.add_rules(grammar.get_rules())
self.crowding.iteration = self.iteration
self.final_covering.iteration = self.iteration
self.terminal_covering.iteration = self.iteration
self.aggressive_covering.iteration = self.iteration
self.start_covering.iteration = self.iteration
def setUp(self):
iteration = Iteration()
self.covering = StartCoveringPlus()
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = sRule.from_symbols(0.5, self.left_symbol,
self.first_right_symbol)
def __init__(self, crowding: Crowding = None, settings=None):
self.logger = logging.getLogger(self.__class__.__name__)
self.crowding = crowding
self.settings = settings
self.iteration: Iteration = Iteration()
self.first_report_rule: ReportRule = None
self.second_report_rule: ReportRule = None
self.__last_grammar_fitness: float = -1.0
self.__last_rules: Set[Rule] = None
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveNakamuraCovering(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
def setUp(self):
iteration = Iteration()
self.crowding = Crowding()
self.crowding.set_iteration(iteration)
self.covering = FinalCoveringPlus(self.crowding)
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.second_right_symbol = Symbol('b', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = sRule.from_symbols(0.5, self.left_symbol,
self.first_right_symbol,
self.second_right_symbol)
def setUp(self):
iteration = Iteration()
self.crowding = Crowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveStandardCovering(self.crowding)
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.second_right_symbol = Symbol('b', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = Rule([
self.left_symbol, self.first_right_symbol, self.second_right_symbol
])
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveSmartCoveringWithTabu(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.statistics = {self.symbol_A: 3, self.symbol_B: 7}
def benchmark_run(self, test=False):
self.__logger.info("Running benchmark")
# print("Running benchmark")
self.learning_mode_off()
self.grammar_induction(Iteration(), benchmark=True, test=test)
last_fitness: float = self.last_results.fitness if self.last_results is not None else 0.0
fitness_diff = last_fitness - self.last_results.fitness
self.fill_results()
if type(self.grammar) is sGCSGrammar:
if 0 < fitness_diff < self.io_grammar_difference_stop:
self.grammar.new_ones_only = True
else:
self.grammar.new_ones_only = False
self.learning_mode_on()
self.__logger.info("Finishing benchmark")
return self.last_results
def remove_worst_rule_by_reversed_roulette(self, current_iteration: Iteration):
rule_to_remove = self.grammar.rulesContainer.get_rule_to_remove_by_reversed_roulette()
self.__logger.info("De_lock rule to remove = {0}".format(rule_to_remove))
current_iteration.remove_selective_de_lock_rule(rule_to_remove)
self.grammar.remove_rule(rule_to_remove)
def evaluate_grammar_and_save_results_to_iteration(self, iteration: Iteration):
iteration.results = self.benchmark_run(test=False)
# iteration.result_map = self.result_map
self.__logger.info("Filling report rules")
iteration.fill_report_rules()
def process(self, collect_data, widget_process):
#random.seed(23)
#self.reset_grammar()
max_step = int(self.settings.get_value("general", "max_evolutionary_steps"))
ev_step = 0
widget_process.max = max_step
widget_process.description = "Calculating {}/{}".format(ev_step, max_step)
stop_condition = False
self.learning_mode = True
sim_result = Result()
self.__logger.info("Start elite number = " + str(self.settings.get_value("crowding", "elite_rules_number")))
self.ga.reset()
# main loop
while not stop_condition:
# print("************************************************************************************")
# print("Induction step {0} of {1} ({2}%)".format(ev_step, max_step, round(ev_step/max_step*100)))
iteration = Iteration()
iteration.add_rules(list(self.grammar.get_rules()))
self.set_iteration(iteration)
start_time = time.time()
# Genetic algorithm
if self.settings.get_value("genetic_algorithm", "is_ga_allowed") == "True" and \
len(self.grammar.rulesContainer.non_terminal_rules) > 0:
# print("[process] Running GA")
self.ga.run(self.grammar)
self.__logger.info("[process] Refreshing rules")
self.grammar.correct_grammar()
# Grammar induction
self.__logger.info("[process] grammar induction start, step " + str(ev_step + 1))
self.__logger.info("Number of rules in grammar: {0} total = {1} terminal + {2} nonterminal ({3} aaa)"
.format(len(self.grammar.get_rules()),
len(self.grammar.get_terminal_rules()),
len(self.grammar.get_non_terminal_rules()),
self.grammar.rulesContainer.count_aaa_rules()))
self.grammar_induction(iteration)
self.__logger.info("[process] grammar induction ended " + str(ev_step + 1))
self.grammar.rulesContainer.make_rules_older()
if self.settings.get_value('genetic_algorithm', 'grammar_restoring_enabled') == "True":
self.grammar.rulesContainer.reset_usages_and_points()
self.parse_dataset(self.train_data, covering_on=False)
self.refresh_rules_params(benchmark=True)
self.ga.restore_if_necessary(self.grammar)
# Saving results
self.__logger.info("Evaluating grammar")
self.evaluate_grammar_and_save_results_to_iteration(iteration)
self.__logger.info("Finished evaluating grammar")
# print(self.grammar)
if self.settings.get_value("general", "allow_adaptive_elitism") == "True":
self.adjust_elite_rules_number(iteration)
"""
# TODO - w oryginale tutaj jest obiekt MySettings, wszędzie indziej workingCopySettings
if self.settings.get_value("general", "allow_lock_removal_algorithm") == "True" and \
self.handle_lock_if_occurred(sim_result.get_last_iteration(), iteration):
self.evaluate_grammar_and_save_results_to_iteration(iteration)
"""
iteration.set_final_production_number(len(self.grammar.rulesContainer.terminal_rules),
len(self.grammar.rulesContainer.non_terminal_rules),
self.grammar.rulesContainer.count_aaa_rules(),
self.grammar.rulesContainer.terminal_rules,
self.grammar.rulesContainer.non_terminal_rules)
# Finalizing
ev_step += 1
widget_process.value = ev_step
if self.on_step_ended is not None:
self.on_step_ended(ev_step, int(self.settings.get_value("general", "max_evolutionary_steps")))
if collect_data:
if self.settings.get_value("general", "pickle_on") == "True":
pickled_iteration = pickle.loads(pickle.dumps(iteration, -1))
else:
pickled_iteration = iteration
sim_result.add_iteration(pickled_iteration)
# Checking for stop condition
met = self.grammar.calc_metrics()
Sens = met["Sensitivity"]
Spec = met["Specificity"]
stop_condition = (ev_step == int(self.settings.get_value("general", "max_evolutionary_steps")) or
self.settings.get_value("general",
"is_perfectly_fit_stop_condition_allowed") == "True" and
self.grammar.is_grammar_perfectly_fit(len(self.train_data)) or Sens > 0.9 and Spec > 0.9)
self.__logger.info('Stop condition: {0}'.format(str(stop_condition)))
end_time = time.time()
self.__logger.info("[process] Induction step ended. Elapsed time: " + str(end_time - start_time) +
" step: " + str(ev_step))
self.__logger.info("[process] True Positives = {0}, False Negatives = {1}, True Negatives = {2},"
"False Positives = {3}".format(self.grammar.truePositive, self.grammar.falseNegative,
self.grammar.trueNegative, self.grammar.falsePositive))
widget_process.description = "Calculating {}/{}:".format(ev_step, max_step)
widget_process.description = "Done {}/{}".format(max_step, max_step)
widget_process.bar_style = "success"
if self.settings.get_value("general", "remove_grammar_unused_rules_after_learning") == "True":
self.grammar.remove_unused_rules_and_symbols()
self.grammar.correct_grammar()
if isinstance(self.grammar, sGCSGrammar):
self.normalize_grammar()
sim_result.final_grammar = self.grammar
sim_result.settings = self.settings
if self.on_iteration_ended is not None:
self.on_iteration_ended(self.last_results, 1, 1)
if self.on_learning_ended is not None:
self.on_learning_ended(self.last_results)
final_rules = list(self.grammar.get_rules())
final_rules.sort(key=lambda x: str(x.left), reverse=True)
self.benchmark_run(test=True)
# print("Final rules")
# for r in final_rules:
# print("{}, {}".format(r.short(), round(r.probability, 2)))
#
# print("Evolutionary steps = {}".format(ev_step))
return sim_result, final_rules
print("Evolutionary steps = {}".format(ev_step))
return sim_result
class ScykController:
def __init__(self, settings: Settings = None):
self.__settings = settings
self.crowding = None
self.final_covering = None
self.terminal_covering = None
self.aggressive_covering = None
self.start_covering = None
self.iteration = None
def run_benchmark(self):
iterations = 10
self.empty_grammar_tests_with_learning(iterations)
def empty_grammar_tests_with_learning(self, iterations):
test_data_list = self.__settings.get_value(
"general", "parallel_test_set_path").split(",")
learning_on = False
seq_times = []
par_times = []
par_ladder_times = []
par_ordered_jobs_times = []
for test_data in test_data_list:
abbading_format_loader = AbbadingoFormatLoader()
abbading_format_loader.load(test_data)
test_data = abbading_format_loader.input_data
grammar = sGCSGrammar(self.__settings)
grammar.init_grammar(test_data)
self.init_crowding_and_covering(grammar)
# print('Starting sequential scyk testing')
for i in range(iterations):
self.benchmark_sequential_scyk(grammar, test_data, learning_on,
seq_times)
# print('Finished sequential scyk testing')
# print('Starting parallel scyk testing')
# for i in range(iterations):
# self.benchmark_parallel_scyk(grammar, test_data, self.iteration, learning_on, par_times)
# print('Finished parallel scyk testing')
#
# print('Starting parallel scyk ladder testing')
# for i in range(iterations):
# self.benchmark_parallel_scyk_ladder(grammar, test_data, self.iteration, learning_on, par_ladder_times)
# print('Finished parallel scyk ladder testing')
# print('Starting parallel scyk ordered jobs testing')
for i in range(iterations):
self.benchmark_parallel_scyk_ordered_jobs(
grammar, test_data, self.iteration, learning_on,
par_ordered_jobs_times)
# print('Finished parallel scyk scyk ordered jobs testing')
seq_dict = self.benchmark_sequential_scyk_with_dict_result(
grammar, test_data, learning_on, iterations)
# print('Starting parallel scyk dictionary generation')
# par_dict = self.benchmark_parallel_scyk_with_dict_result(grammar, test_data, self.iteration, learning_on,
# iterations)
# print('Finished parallel scyk dictionary generation')
#
# print('Starting parallel scyk ladder dictionary generation')
# par_ladder_dict = self.benchmark_parallel_ladder_scyk_with_dict_result(grammar, test_data, self.iteration,
# learning_on,
# iterations)
# print('Finished parallel scyk ladder dictionary generation')
# print('Starting parallel scyk ordered jobs dictionary generation')
par_ordered_jobs_dict = self.benchmark_parallel_ordered_scyk_with_dict_result(
grammar, test_data, self.iteration, learning_on, iterations)
# print('Finished parallel scyk ordered jobs dictionary generation')
with open("results_seq_lon", "w") as f:
f.write(str(seq_times))
with open("results_par_lon", "w") as f:
f.write(str(par_times))
with open("results_par_ladder_lon", "w") as f:
f.write(str(par_ladder_times))
with open("results_par_ordered_jobs_lon", "w") as f:
f.write(str(par_ordered_jobs_times))
with open("results_seq_lon_dict", "w") as f:
f.write(str(seq_dict))
# with open("results_par_lon_dict", "w") as f:
# f.write(str(par_dict))
#
# with open("results_par_ladder_lon_dict", "w") as f:
# f.write(str(par_ladder_dict))
with open("results_par_ordered_jobs_lon_dict", "w") as f:
f.write(str(par_ordered_jobs_dict))
def benchmark_sequential_scyk(self, grammar: sGCSGrammar, test_data,
learning_on, seq_times):
scyk = SGCSCyk(grammar, None, self.__settings, self.start_covering,
self.final_covering, self.aggressive_covering,
self.terminal_covering)
for example in test_data:
start_time = time.time()
scyk.cyk_result(example.sequence, grammar, example.positive,
learning_on)
end_time = time.time()
seq_times.append(str(end_time - start_time))
def benchmark_parallel_scyk(self, grammar: sGCSGrammar, test_data,
iteration, learning_on, par_times):
for example in test_data:
start_time = time.time()
cyk_result(example.sequence, grammar, example.positive,
learning_on, self.__settings, self.crowding, iteration)
end_time = time.time()
par_times.append(str(end_time - start_time))
def benchmark_parallel_scyk_ladder(self, grammar: sGCSGrammar, test_data,
iteration, learning_on,
par_ladder_times):
for example in test_data:
start_time = time.time()
cyk_result_ladder(example.sequence, grammar, example.positive,
learning_on, self.__settings, self.crowding,
iteration)
end_time = time.time()
par_ladder_times.append(str(end_time - start_time))
def benchmark_sequential_scyk_with_dict_result(self, grammar: sGCSGrammar,
test_data, learning_on,
iterations):
scyk = SGCSCyk(grammar, None, self.__settings, self.start_covering,
self.final_covering, self.aggressive_covering,
self.terminal_covering)
seq_example_dictionary = dict()
for example in test_data:
start_time = time.time()
for iteration in range(iterations):
scyk.cyk_result(example.sequence, grammar, example.positive,
learning_on)
end_time = time.time()
seq_example_dictionary[example.sequence] = str(end_time -
start_time)
return seq_example_dictionary
def benchmark_parallel_scyk_ordered_jobs(self, grammar: sGCSGrammar,
test_data, iteration, learning_on,
par_ordered_times):
for example in test_data:
start_time = time.time()
cyk_result_ordered_jobs(example.sequence, grammar,
example.positive, learning_on,
self.__settings, self.crowding, iteration)
end_time = time.time()
par_ordered_times.append(str(end_time - start_time))
def benchmark_parallel_ordered_scyk_with_dict_result(
self, grammar: sGCSGrammar, test_data, iteration, learning_on,
iterations):
par_example_dictionary = dict()
for example in test_data:
start_time = time.time()
for i in range(iterations):
cyk_result_ordered_jobs(example.sequence, grammar,
example.positive, learning_on,
self.__settings, self.crowding,
iteration)
end_time = time.time()
par_example_dictionary[example.sequence] = str(end_time -
start_time)
return par_example_dictionary
def benchmark_parallel_scyk_with_dict_result(self, grammar: sGCSGrammar,
test_data, iteration,
learning_on, iterations):
par_example_dictionary = dict()
for example in test_data:
start_time = time.time()
for i in range(iterations):
cyk_result(example.sequence, grammar, example.positive,
learning_on, self.__settings, self.crowding,
iteration)
end_time = time.time()
par_example_dictionary[example.sequence] = str(end_time -
start_time)
return par_example_dictionary
def benchmark_parallel_ladder_scyk_with_dict_result(
self, grammar: sGCSGrammar, test_data, iteration, learning_on,
iterations):
par_example_dictionary = dict()
for example in test_data:
start_time = time.time()
for i in range(iterations):
cyk_result_ladder(example.sequence, grammar, example.positive,
learning_on, self.__settings, self.crowding,
iteration)
end_time = time.time()
par_example_dictionary[example.sequence] = str(end_time -
start_time)
return par_example_dictionary
def init_crowding_and_covering(self, grammar: sGCSGrammar):
self.crowding = StandardCrowding(self.__settings)
self.final_covering = CoveringDeterminer.get_final_covering(
self.__settings, self.crowding)
self.terminal_covering = CoveringDeterminer.get_terminal_covering(
self.__settings, self.crowding)
self.aggressive_covering = CoveringDeterminer.get_aggressive_covering(
self.__settings, self.crowding)
self.start_covering = CoveringDeterminer.get_start_covering(
self.__settings, self.crowding)
self.iteration = Iteration()
self.iteration.add_rules(grammar.get_rules())
self.crowding.iteration = self.iteration
self.final_covering.iteration = self.iteration
self.terminal_covering.iteration = self.iteration
self.aggressive_covering.iteration = self.iteration
self.start_covering.iteration = self.iteration
def __init__(self, settings=None):
self.settings = settings
self.iteration: Iteration = Iteration()
self.logger = logging.getLogger(self.__class__.__name__)
