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'))