def __is_parsed(result: float, is_learing_on: bool, settings: Settings): if result is None: return False # TODO: we use 0 in both cases, but originally it was two different settings if is_learing_on: parsing_threshold = float(settings.get_value('sgcs', 'parsing_threshold')) else: parsing_threshold = float(settings.get_value('sgcs', 'parsing_threshold')) return result > parsing_threshold
def __compute_new_tmp_value(cell_rule_1: CellRule, cell_rule_2: CellRule, settings: Settings) -> float: """ Takes the temporary values of the rule parents and calculates new temporaty value :param cell_rule_1: First parent of the checked rule :param cell_rule_2: Second parent of the checked rule :return: """ return cell_rule_1.tmp_val * float( settings.get_value('rules', 'base_amount_reduction_coefficient')) \ + cell_rule_2.tmp_val * float( settings.get_value('rules', 'base_amount_reduction_coefficient'))
def __init__(self, parallelData, grammar: sGCSGrammar, is_learning_on: bool, sentence: str, settings: Settings, start_covering: Covering = None, final_covering: Covering = None, aggressive_covering: Covering = None, terminal_covering: Covering = None): self.grammar = grammar self.is_learning_on = is_learning_on self.default_value = None self.probability_array = None self.sentence = sentence self.positive = False self.sequence = [] self.rules_table = None self.mode = settings.get_value('general', 's_mode') self.settings = settings self.is_parsed = False self.start_covering = start_covering self.final_covering = final_covering self.aggressive_covering = aggressive_covering self.terminal_covering = terminal_covering self.parallelData = parallelData self.parallelData.values['sentence'] = self.sentence self.parallelData.values[ 'start_system_index'] = self.grammar.get_start_symbol().index self.parallelData.values['positive'] = self.positive self.parallelData.values[ 'full_covering_allowed'] = self.settings.get_value( 'covering', 'is_full_covering_allowed') == "True"
def get_crowding(settings: Settings) -> Crowding: crowding_enabled = settings.get_value('crowding', 'crowding_enabled') == "True" if crowding_enabled: return StandardCrowding(settings) else: return DummyCrowding(settings)
def __init_first_row(cyk_values: CykValues, is_sentence_positive: bool, settings: Settings): for i in range(len(cyk_values.sequence)): covering = None was = False # TODO: dictionary can fasten this search for rule in cyk_values.grammar.get_rules(): if rule.right1 == cyk_values.sequence[i]: rule: sRule = rule was = True __init_cell(cyk_values, i, rule) rule.tmp_used = True cyk_values.rules_table[0][i].append(sCellRule(rule)) if not was and is_sentence_positive: if len(cyk_values.sequence) > 1: covering = cyk_values.terminal_covering elif settings.get_value('covering', 'is_start_covering_allowed') == "True": covering = cyk_values.start_covering if covering is not None: new_rule = covering.add_new_rule(cyk_values.grammar, cyk_values.sequence[i]) new_rule.tmp_used = True __init_cell(cyk_values, i, new_rule) cyk_values.rules_table[0][i].append(sCellRule(new_rule)) cyk_values.parallelData.cyk_parsed_cells['{}{}'.format(0, i)] = True cyk_values.parallelData.cyk_rules_for_cell['{}{}'.format(0, i)] = cyk_values.rules_table[0][i] cyk_values.parallelData.cyk_probability_array['{}{}'.format(0, i)] = cyk_values.probability_array[0][i]
def __update_rules_count_after_sentence_parsing(cyk_values: CykValues, learning_on: bool, cyk_start_cell_rules, cyk_start_cell_rules_probability, positive: bool, settings: Settings): if learning_on and settings.get_value('covering', 'is_terminal_covering_allowed') == "True": sentence_probability = __calculate_sentence_probability(cyk_values, cyk_start_cell_rules, cyk_start_cell_rules_probability, positive) for rule in cyk_values.grammar.get_rules(): rule: sRule = rule rule.calculate_counts(sentence_probability)
def __init_rules_value(cyk_values: CykValues, settings: Settings): """ Initiates the base amount of the first row of rules table :param sentence_length: length of the given sentence :return: """ for i in range(len(cyk_values.sentence)): for j in range(len(cyk_values.rules_table[0][i].cell_rules)): cyk_values.rules_table[0][i].cell_rules[j].tmp_val = float(settings.get_value('rules', 'base_amount'))
def get_start_covering(settings: Settings, crowding: Crowding = None) -> Covering: covering_type = settings.get_value('covering', 'start_covering_type') if covering_type == "covering_plus": return StartCoveringPlus() elif covering_type == "standard_covering": return StartStandardCovering() else: raise RuntimeError("No start covering selected")
def get_final_covering(settings: Settings, crowding: Crowding = None) -> Covering: covering_type = settings.get_value('covering', 'final_covering_type') if covering_type == "covering_plus": return FinalCoveringPlus(crowding) elif covering_type == "standard_covering": return FinalStandardCovering(crowding) else: raise RuntimeError("No final covering selected")
def get_heuristic(settings: Settings, crowding: Crowding = None) -> Heuristic: heuristic_algorithm = settings.get_value('general', 'heuristic_algorithm') if heuristic_algorithm == "ga": return GeneticAlgorithm(crowding, settings) elif heuristic_algorithm == "split_and_merge": return SplitAndMerge(settings=settings) else: raise RuntimeError("No heuristic algorithm selected")
def get_aggressive_covering(settings: Settings, crowding: Crowding = None) -> Covering: covering_type = settings.get_value('covering', 'aggressive_covering_type') if covering_type == "smart_covering_with_tabu": return AggressiveSmartCoveringWithTabu(crowding) elif covering_type == "smart_covering": return AggressiveSmartCovering(crowding) elif covering_type == "nakamura_covering": return AggressiveNakamuraCovering(crowding) elif covering_type == "covering_plus": return AggressiveCoveringPlus(crowding) elif covering_type == "standard_covering": return AggressiveStandardCovering(crowding) elif covering_type == "new_covering": return AggressiveNewCovering(crowding, settings) else: raise RuntimeError("No aggressive covering selected")
def get_terminal_covering(settings: Settings, crowding: Crowding = None) -> Covering: covering_type = settings.get_value('covering', 'terminal_covering_type') if covering_type == "new_covering": return TerminalNewCovering(crowding, settings) elif covering_type == "smart_covering": return TerminalSmartCovering(crowding) elif covering_type == "nakamura_covering": return TerminalNakamuraCovering(crowding) elif covering_type == "covering_plus": return TerminalCoveringPlus() elif covering_type == "standard_covering": return TerminalStandardCovering() elif covering_type == "no_repetition_covering": return TerminalNoRepetitionCovering(settings) else: raise RuntimeError("No terminal covering selected")
def __init__(self, settings: Settings): self.non_terminal_symbols = int(settings.get_value('general', 'non_terminal_symbols_number_for_terminal_covering')) super().__init__()
def __init__(self, settings: Settings): self.non_used_rule_fitness = float(settings.get_value('fitness', 'non_used_rule_fitness')) self.weight_fertility_fitness = float(settings.get_value('fitness', 'weight_fertility_fitness')) self.weight_proper_prased_rule = float(settings.get_value('fitness', 'weight_proper_prased_rule')) self.weight_not_proper_prased_rule = float(settings.get_value('fitness', 'weight_not_proper_parsed_rule')) self.weight_classic_fitness = float(settings.get_value('fitness', 'weight_classic_fitness'))