def test_symbol_sentence_init(self):
symbol1 = Symbol("I")
symbol2 = Symbol(" ")
symbol3 = Symbol("l")
symbol4 = Symbol("i")
symbol5 = Symbol("k")
symbol6 = Symbol("e")
symbols = [symbol1, symbol2, symbol3, symbol4, symbol5, symbol6]
sentence = "I like you"
grammar = Grammar()
grammar.nonTerminalSymbols = symbols
self.cyk_base = CYKBase()
self.cyk_base.grammar = grammar
self.cyk_base.symbols = symbols
self.cyk_base._init_symbol_sequence(sentence)
sequence = self.cyk_base.sequence
self.assertEqual(symbol1, sequence[0])
self.assertEqual(symbol2, sequence[1])
self.assertEqual(symbol3, sequence[2])
self.assertEqual(symbol4, sequence[3])
self.assertEqual(symbol5, sequence[4])
self.assertEqual(symbol6, sequence[5])
self.assertEqual(symbol2, sequence[6])
self.assertEqual(None, sequence[7])
self.assertEqual(None, sequence[8])
self.assertEqual(None, sequence[9])
pass
def __restore_previous_state(self, grammar: Grammar) -> None:
to_remove = set(grammar.get_rules())
for rule in to_remove:
grammar.remove_rule(rule)
self.iteration.remove_crowding_rule(rule)
for rule in self.__last_rules:
grammar.add_rule(rule)
self.iteration.add_rule(rule)
def add_new_rule(self,
grammar: Grammar,
first_symbol: Symbol,
second_symbol: Symbol = None) -> Rule:
new_rule = Rule([grammar.get_start_symbol(), first_symbol])
new_rule.origin = RuleOrigin.COVERING
grammar.add_rule(new_rule)
self.iteration.add_covering_rule(new_rule)
return new_rule
def test_rule_is_effective(self):
grammar = Grammar()
grammar.get_rules = MagicMock(return_value=self.rules)
rule = Rule([self.symbol_C, self.symbol_B, self.symbol_x])
result = self.covering.rule_is_effective(grammar, rule.left)
self.assertTrue(result)
rule = Rule([self.symbol_E, self.symbol_B, self.symbol_x])
result = self.covering.rule_is_effective(grammar, rule.left)
self.assertFalse(result)
def test_count_symbols_statistics(self):
grammar = Grammar()
grammar.get_rules = MagicMock(return_value=self.rules)
result = self.covering.count_symbols_statistics(grammar)
expected = {
self.symbol_B: 2,
self.symbol_C: 3,
self.symbol_D: 1,
self.symbol_E: 1
}
self.assertEqual(result, expected)
def __replace_all_symbols_in_rules(self, replacement: Symbol,
replaced: Symbol,
grammar: Grammar) -> None:
rules: Set[Rule] = grammar.get_rules()
rules_copy = set(rules)
for rule in rules_copy:
if self.__rule_contains_replaced_symbol(rule, replaced):
new_rule = self.__replace_symbols_in_rule(
replacement, replaced, rule)
grammar.remove_rule(rule)
grammar.add_rule(new_rule)
def calculate_number_of_rules_to_add(self, grammar: Grammar):
grammar_size = len(grammar.get_non_terminal_rules())
round_to_even = lambda x: round((x - 0.5) / 2) * 2
if self.new_rules_number_percent_unit:
if self.new_rules_number >= 100:
return round_to_even(grammar_size)
else:
return round((grammar_size * self.new_rules_number) / 200) * 2
else:
if self.new_rules_number >= len(grammar.get_non_terminal_rules()):
return round_to_even(grammar_size)
else:
return round_to_even(self.new_rules_number)
def initialize_rules(self):
self.crowding.is_non_terminal_type = MagicMock(return_value=True)
self.crowding.filter_non_terminal_to_terminal_terminal_rule = MagicMock()
grammar = Grammar()
grammar.get_non_terminal_rules = MagicMock(return_value=self.rules)
rule = self.__create_rule(["x", "y", "z"])
self.crowding.initialize_rules(rule, grammar)
self.crowding.filter_non_terminal_to_terminal_terminal_rule.assert_called_once_with(self.rules)
self.crowding.is_non_terminal_type = MagicMock(return_value=False)
result = self.crowding.initialize_rules(rule, grammar)
self.assertEqual(result, self.rules)
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 get_ga_probability(self, grammar: Grammar) -> float:
if self.dynamic_ga_probability_enabled:
metrics = grammar.calc_metrics()
ga_prob = math.exp(-2 * metrics['F1'])
# print("MCC = {}, GA probability = {}".format(metrics['MCC'], ga_prob))
return ga_prob
else:
return self.const_ga_probability
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 test_add_new_rule(self):
grammar: Grammar = Grammar()
self.covering.produce_rule = MagicMock(return_value=self.rule_1)
self.covering.crowding.add_rule = MagicMock()
result = self.covering.add_new_rule(grammar, self.symbol_C)
self.assertEqual(self.rule_1, result)
self.covering.crowding.add_rule.assert_called_once_with(
grammar, self.rule_1)
def test_is_non_terminal_type(self):
self.crowding.aaa_rules_handling_type = AaaRulesHandlingType.NON_TERMINALS
self.crowding.non_terminal_productions_number = 20
rule = self.__create_rule(["x", "y", "z"])
rule.is_non_terminal_to_terminal_terminal_rule = MagicMock(return_value=False)
grammar = Grammar()
grammar.count_Aaa_rules = MagicMock(return_value=10)
self.assertTrue(self.crowding.is_non_terminal_type(rule, grammar))
rule.is_non_terminal_to_terminal_terminal_rule = MagicMock(return_value=True)
self.assertFalse(self.crowding.is_non_terminal_type(rule, grammar))
self.crowding.aaa_rules_handling_type = 'TERMINALS'
self.assertFalse(self.crowding.is_non_terminal_type(rule, grammar))
self.crowding.non_terminal_productions_number = 5
self.assertFalse(self.crowding.is_non_terminal_type(rule, grammar))
def test_get_random_nonterminal_symbol_from(self):
grammar = Grammar()
symbol_1 = Symbol('a', SymbolType.ST_TERMINAL)
symbol_2 = Symbol('b', SymbolType.ST_TERMINAL)
grammar.nonTerminalSymbols = [symbol_1, symbol_2]
result = RandomUtils.get_random_nonterminal_symbol_from(grammar)
self.assertIsNotNone(result)
self.assertEqual(2, len(grammar.nonTerminalSymbols))
grammar.nonTerminalSymbols = []
result = RandomUtils.get_random_nonterminal_symbol_from(grammar)
self.assertIsNone(result)
grammar.nonTerminalSymbols = [symbol_1, symbol_2]
random.choice = MagicMock(return_value=symbol_1)
result = RandomUtils.get_random_nonterminal_symbol_from(grammar)
self.assertEqual(result, symbol_1)
def __get_non_terminals_in_use(self, grammar: Grammar) -> Set[Symbol]:
rules = grammar.get_rules()
symbols_in_use = set()
for rule in rules:
symbols_in_use.add(rule.left)
symbols_in_use.add(rule.right1)
if rule.right2 is not None:
symbols_in_use.add(rule.right2)
return set(
filter(lambda symbol: symbol.is_non_terminal(), symbols_in_use))
def test_produce_rule(self):
grammar = Grammar()
RandomUtils.get_random_nonterminal_symbol_from = MagicMock(
return_value=self.symbol_D)
RandomUtils.get_random_probability = MagicMock(return_value=0.7)
result = self.covering.produce_rule(grammar, self.symbol_C)
expected = sRule.from_symbols(0.7, self.symbol_D, self.symbol_C)
self.assertEqual(result, expected)
def test_get_left_symbol_condition_true(self):
grammar = Grammar()
self.covering.find_left_symbol_wisely = MagicMock()
RandomUtils.get_random_nonterminal_symbol_from = MagicMock()
RandomUtils.make_random_decision_with_probability = MagicMock(
return_value=True)
self.covering.get_left_symbol(grammar)
self.covering.find_left_symbol_wisely.assert_called_once_with(grammar)
RandomUtils.get_random_nonterminal_symbol_from.assert_not_called()
def __grammar_is_worse_than_previously(self, grammar: Grammar) -> bool:
print("[heuristic] grammar fitness = {}".format(
self.__count_grammar_fitness(grammar)))
print("[heuristic] last grammar fitness = {}".format(
self.__last_grammar_fitness))
if len(grammar.get_rules()) > 5 * int(
self.settings.get_value('general',
'non_terminal_productions_number')):
return True
return self.__count_grammar_fitness(
grammar) < self.__last_grammar_fitness
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 test_find_left_symbol_wisely_condition_true(self):
grammar = Grammar()
self.covering.count_symbols_statistics = MagicMock(return_value={})
RandomUtils.get_random_nonterminal_symbol_from = MagicMock()
self.covering.find_the_best_symbols = MagicMock()
self.covering.roulette_selection.select = MagicMock()
self.covering.find_left_symbol_wisely(grammar)
RandomUtils.get_random_nonterminal_symbol_from.assert_called_once_with(
grammar)
self.covering.find_the_best_symbols.assert_not_called()
self.covering.roulette_selection.select.assert_not_called()
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 run(self, grammar: Grammar) -> None:
if self.__run_counter != 0:
self.save_grammar_state(grammar)
if len(grammar.get_non_terminal_rules()) > 2 * int(
self.settings.get_value(
'general', 'non_terminal_productions_number')):
self.merge(grammar)
else:
if self.__run_counter % 2 == 1:
self.split(grammar)
else:
self.merge(grammar)
self.__run_counter += 1
def test_add_new_rule_when_rule_effective(self):
grammar = Grammar()
self.covering.produce_rule = MagicMock(return_value=self.rule_1)
self.covering.rule_is_effective = MagicMock(return_value=False)
self.covering.make_rule_effective = MagicMock()
self.covering.crowding.add_rule = MagicMock()
result = self.covering.add_new_rule(grammar, self.symbol_A)
self.assertEqual(self.rule_1, result)
self.covering.rule_is_effective.assert_called_once_with(
grammar, self.rule_1.left)
self.covering.make_rule_effective.assert_called_once_with(
grammar, self.rule_1)
self.covering.crowding.add_rule.assert_not_called()
def test_make_rule_effective(self):
grammar = Grammar()
self.covering.rule_is_effective = MagicMock(side_effect=4 * [False] +
[True])
self.covering.produce_rule_based_on_random_decision = MagicMock(
side_effect=[self.rule_1, self.rule_2, self.rule_3, self.rule_4])
self.covering.crowding.add_rule = MagicMock()
self.covering.crowding.add_rules = MagicMock()
self.covering.make_rule_effective(grammar, self.rule_1)
self.assertEqual(self.covering.rule_is_effective.call_count, 5)
self.assertEqual(
self.covering.produce_rule_based_on_random_decision.call_count, 4)
self.assertEqual(self.covering.crowding.add_rule.call_count, 4)
self.covering.crowding.add_rules.assert_called_once()
def test_find_left_symbol_wisely_condition_false(self):
grammar = Grammar()
self.covering.count_symbols_statistics = MagicMock(return_value=self.statistics)
RandomUtils.get_random_nonterminal_symbol_from = MagicMock()
self.covering.find_the_best_symbols = MagicMock()
self.covering.roulette_selection.select = MagicMock(return_value=self.symbol_D)
self.covering.purify_statistics_based_on_tabu = MagicMock()
self.covering.add_to_tabu = MagicMock()
self.covering.find_left_symbol_wisely(grammar)
RandomUtils.get_random_nonterminal_symbol_from.assert_not_called()
self.covering.find_the_best_symbols.assert_called_once_with(self.statistics, number_of_symbols=5)
self.covering.roulette_selection.select.assert_called_once()
self.covering.purify_statistics_based_on_tabu.assert_called_once_with(self.statistics)
self.covering.add_to_tabu.assert_called_once_with(self.symbol_D)
def setUp(self):
self.genetic_algorithm = GeneticAlgorithm(Crowding(), None)
self.grammar = Grammar()
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 = sRule.from_symbols(0.1, self.symbol_A, self.symbol_B,
self.symbol_C)
self.rule_2 = sRule.from_symbols(0.5, self.symbol_B, self.symbol_x,
self.symbol_C)
self.rule_3 = sRule.from_symbols(0.4, self.symbol_C, self.symbol_B,
self.symbol_y)
self.rule_4 = sRule.from_symbols(0.9, self.symbol_D, self.symbol_D,
self.symbol_C)
self.rule_5 = sRule.from_symbols(0.2, self.symbol_E, self.symbol_w)
self.rule_1.fitness = 9
self.rule_2.fitness = 12
self.rule_3.fitness = 15
self.rule_4.fitness = 6
self.rule_5.fitness = 3
self.rules = {
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5
}
self.rules_list = [
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5
]
self.grammar.get_non_terminal_rules = MagicMock(
return_value=self.rules)
self.random_decision = RandomUtils.make_random_decision_with_probability
self.random_non_terminal = RandomUtils.get_random_nonterminal_symbol_from
def test_produce_rule_based_on_random_decision(self):
grammar = Grammar()
RandomUtils.get_random_probability = MagicMock(return_value=0.9)
RandomUtils.get_random_nonterminal_symbol_from = MagicMock(
return_value=self.symbol_A)
RandomUtils.make_random_decision_with_probability = MagicMock(
return_value=True)
result: sRule = self.covering.produce_rule_based_on_random_decision(
grammar, self.symbol_x)
expected: sRule = sRule.from_symbols(0.9, self.symbol_A, self.symbol_x,
self.symbol_A)
self.assertEqual(expected, result)
RandomUtils.make_random_decision_with_probability = MagicMock(
return_value=False)
result: sRule = self.covering.produce_rule_based_on_random_decision(
grammar, self.symbol_x)
expected: sRule = sRule.from_symbols(0.9, self.symbol_A, self.symbol_A,
self.symbol_x)
self.assertEqual(expected, result)
def setUp(self):
self.grammar = Grammar()
self.grammar.terminalSymbols = self.__create_terminal_symbols__()
self.grammar.nonTerminalSymbols = self.__create_non_terminal_symbols()
class GrammarTest(TestCase):
def setUp(self):
self.grammar = Grammar()
self.grammar.terminalSymbols = self.__create_terminal_symbols__()
self.grammar.nonTerminalSymbols = self.__create_non_terminal_symbols()
def test_should_not_find_symbol_index(self):
symbol = Symbol("d")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, -1)
def test_should_find_first_terminal_symbol(self):
symbol = Symbol("o")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 0)
def test_should_find_second_terminal_symbol(self):
symbol = Symbol("t")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 1)
def test_should_find_third_terminal_symbol(self):
symbol = Symbol("s")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 2)
def test_should_find_first_non_terminal_symbol(self):
symbol = Symbol("a")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 3)
def test_should_find_second_non_terminal_symbol(self):
symbol = Symbol("b")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 4)
def test_should_find_third_non_terminal_symbol(self):
symbol = Symbol("c")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 5)
def test_should_find_symbol_by_index(self):
index = 0
symbol = self.grammar.find_symbol_by_given_index(index)
self.assertEqual(symbol, Symbol("o", SymbolType.ST_TERMINAL))
def test_should_find_symbol_by_index_1(self):
index = 1
symbol = self.grammar.find_symbol_by_given_index(index)
self.assertEqual(symbol, Symbol("t", SymbolType.ST_TERMINAL))
def test_should_find_symbol_by_index_5(self):
index = 5
symbol = self.grammar.find_symbol_by_given_index(index)
self.assertEqual(symbol, Symbol("c", SymbolType.ST_NON_TERMINAL))
def test_should_not_find_symbol(self):
index = -1
index2 = 100000000000
symbol = self.grammar.find_symbol_by_given_index(index)
symbol2 = self.grammar.find_symbol_by_given_index(index2)
self.assertEqual(symbol, None)
self.assertEqual(symbol2, None)
def test_should_find_non_terminal_symbol_index(self):
symbol = Symbol("a", SymbolType.ST_NON_TERMINAL)
index = self.grammar.find_non_terminal_symbol_index(symbol)
self.assertEqual(index, 0)
def test_should_find_non_terminal_symbol_index_2(self):
symbol = Symbol("b", SymbolType.ST_NON_TERMINAL)
index = self.grammar.find_non_terminal_symbol_index(symbol)
self.assertEqual(index, 1)
def test_should_find_non_terminal_symbol_index_3(self):
symbol = Symbol("c", SymbolType.ST_NON_TERMINAL)
index = self.grammar.find_non_terminal_symbol_index(symbol)
self.assertEqual(index, 2)
def test_should_not_find_non_terminal_symbol_index(self):
symbol = Symbol("d", SymbolType.ST_NON_TERMINAL)
index = self.grammar.find_non_terminal_symbol_index(symbol)
self.assertEqual(index, -1)
def test_find_symbol_by_value(self):
value = 'c'
symbol = self.grammar.find_symbol_by_value(value)
self.assertEqual(symbol, Symbol("c", SymbolType.ST_NON_TERMINAL))
def test_should_not_find_symbol_by_value(self):
value = 'z'
symbol = self.grammar.find_symbol_by_value(value)
self.assertEqual(symbol, None)
def test_should_calculate_grammar_fitness(self):
self.grammar.trueNegative = 3
self.grammar.truePositive = 5
all_examples = 8
fitness = self.grammar.calculate_grammar_fitness(all_examples)
self.assertEqual(fitness, 1)
def test_should_calculate_grammar_fitness_2(self):
self.grammar.trueNegative = 3
self.grammar.truePositive = 5
all_examples = 16
fitness = self.grammar.calculate_grammar_fitness(all_examples)
self.assertEqual(fitness, 0.5)
def test_should_calculate_grammar_fitness_3(self):
self.grammar.trueNegative = 3
self.grammar.truePositive = 5
all_examples = 32
fitness = self.grammar.calculate_grammar_fitness(all_examples)
self.assertEqual(fitness, 0.25)
def test_should_calculate_grammar_fitness_4(self):
self.grammar.trueNegative = 3
self.grammar.truePositive = 5
all_examples = 64
fitness = self.grammar.calculate_grammar_fitness(all_examples)
self.assertEqual(fitness, 0.125)
def test_should_calculate_grammar_fitness_no_examples(self):
all_examples = 0
fitness = self.grammar.calculate_grammar_fitness(all_examples)
self.assertEqual(fitness, 0)
def test_should_calculate_grammar_sensitivity_no_positive_and_negative(
self):
sensitivity = self.grammar.calculate_sensitivity()
self.assertEqual(sensitivity, 0)
def test_should_calculate_grammar_sensitivity(self):
self.grammar.falseNegative = 3
self.grammar.truePositive = 5
sensitivity = self.grammar.calculate_sensitivity()
self.assertEqual(sensitivity, 0.625)
def test_should_calculate_grammar_sensitivity_2(self):
self.grammar.falseNegative = 4
self.grammar.truePositive = 4
sensitivity = self.grammar.calculate_sensitivity()
self.assertEqual(sensitivity, 0.5)
def test_should_calculate_grammar_sensitivity_3(self):
self.grammar.falseNegative = 9
self.grammar.truePositive = 1
sensitivity = self.grammar.calculate_sensitivity()
self.assertEqual(sensitivity, 0.1)
def test_should_calculate_precision_no_positives(self):
precision = self.grammar.calculate_precision()
self.assertEqual(precision, 0)
def test_should_calculate_precision(self):
self.grammar.truePositive = 2
self.grammar.falsePositive = 8
precision = self.grammar.calculate_precision()
self.assertEqual(precision, 0.2)
def test_should_calculate_precision_2(self):
self.grammar.truePositive = 1
self.grammar.falsePositive = 7
precision = self.grammar.calculate_precision()
self.assertEqual(precision, 0.125)
def test_should_calculate_precision_3(self):
self.grammar.truePositive = 3
self.grammar.falsePositive = 5
precision = self.grammar.calculate_precision()
self.assertEqual(precision, 0.375)
def test_should_calculate_precision_4(self):
self.grammar.truePositive = 3
self.grammar.falsePositive = 0
precision = self.grammar.calculate_precision()
self.assertEqual(precision, 1.00)
def test_should_calculate_specificity_no_data(self):
specificity = self.grammar.calculate_specificity()
self.assertEqual(specificity, 0)
def test_should_calculate_specificity(self):
self.grammar.trueNegative = 3
self.grammar.falsePositive = 7
specificity = self.grammar.calculate_specificity()
self.assertEqual(specificity, 0.3)
def test_should_calculate_specificity_2(self):
self.grammar.trueNegative = 1
self.grammar.falsePositive = 9
specificity = self.grammar.calculate_specificity()
self.assertEqual(specificity, 0.1)
def test_should_calculate_specificity_3(self):
self.grammar.trueNegative = 0
self.grammar.falsePositive = 10
specificity = self.grammar.calculate_specificity()
self.assertEqual(specificity, 0)
def test_should_calculate_specificity_4(self):
self.grammar.trueNegative = 10
self.grammar.falsePositive = 0
specificity = self.grammar.calculate_specificity()
self.assertEqual(specificity, 1.0)
def test_should_calculate_specificity_5(self):
self.grammar.trueNegative = 3
self.grammar.falsePositive = 5
specificity = self.grammar.calculate_specificity()
self.assertEqual(specificity, 0.375)
def test_should_calculate_f1(self):
self.grammar.truePositive = 2
self.grammar.falseNegative = 2
self.grammar.falsePositive = 2
f1 = self.grammar.calculate_f1()
self.assertEqual(f1, 0.5)
def test_should_calculate_f1_2(self):
self.grammar.truePositive = 2
self.grammar.falseNegative = 4
self.grammar.falsePositive = 4
f1 = self.grammar.calculate_f1()
self.assertEqual(f1, 1 / 3)
def test_grammar_should_be_perfectly_fit(self):
self.grammar.trueNegative = 2
self.grammar.truePositive = 2
all_examples = 4
is_perfectly_fit = self.grammar.is_grammar_perfectly_fit(all_examples)
self.assertTrue(is_perfectly_fit)
def test_grammar_should_not_be_perfectly_fit(self):
self.grammar.trueNegative = 2
self.grammar.truePositive = 2
all_examples = 5
is_perfectly_fit = self.grammar.is_grammar_perfectly_fit(all_examples)
self.assertFalse(is_perfectly_fit)
def __create_terminal_symbols__(self):
terminal_symbols = []
symbol_one = Symbol("o", SymbolType.ST_TERMINAL)
symbol_two = Symbol("t", SymbolType.ST_TERMINAL)
symbol_three = Symbol("s", SymbolType.ST_TERMINAL)
terminal_symbols.append(symbol_one)
terminal_symbols.append(symbol_two)
terminal_symbols.append(symbol_three)
return terminal_symbols
def __create_non_terminal_symbols(self):
non_terminal_symbols = []
symbol_one = Symbol("a", SymbolType.ST_NON_TERMINAL)
symbol_two = Symbol("b", SymbolType.ST_NON_TERMINAL)
symbol_three = Symbol("c", SymbolType.ST_NON_TERMINAL)
non_terminal_symbols.append(symbol_one)
non_terminal_symbols.append(symbol_two)
non_terminal_symbols.append(symbol_three)
return non_terminal_symbols
def setUp(self):
settings = MagicMock()
settings.get_value = MagicMock(
side_effect=["TERMINALS", 0.5, 1.0, 1.0, 1.0, 1.0])
self.grammar = Grammar(settings)
self.symbol_a = Symbol('a', SymbolType.ST_TERMINAL)
self.symbol_S = Symbol('S', SymbolType.ST_NON_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_A1 = Symbol('A1', SymbolType.ST_NON_TERMINAL)
self.symbol_A2 = Symbol('A2', SymbolType.ST_NON_TERMINAL)
self.rule_1 = sRule.from_symbols(0.1, self.symbol_S, self.symbol_A,
self.symbol_B)
self.rule_2 = sRule.from_symbols(0.5, self.symbol_A, self.symbol_A,
self.symbol_B)
self.rule_3 = sRule.from_symbols(0.4, self.symbol_A, self.symbol_a)
self.rule_4 = sRule.from_symbols(0.9, self.symbol_B, self.symbol_B,
self.symbol_B)
self.rule_5 = sRule.from_symbols(0.2, self.symbol_B, self.symbol_a)
self.rules = {
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5
}
self.non_terminal_rules = {self.rule_1, self.rule_2, self.rule_4}
self.terminal_rules = {self.rule_3, self.rule_5}
self.grammar.rulesContainer.terminal_rules = self.terminal_rules
self.grammar.rulesContainer.non_terminal_rules = self.non_terminal_rules
self.grammar.rulesContainer.rules = self.rules
self.grammar.get_rules = MagicMock(return_value=self.rules)
self.grammar.get_non_terminal_rules = MagicMock(
return_value=self.non_terminal_rules)
settings.get_value = MagicMock(
side_effect=['RANDOM', 'False', 0.5, 20])
self.split_and_merge = SplitAndMerge(settings)
self.split_and_merge.iteration.add_rule = MagicMock()
self.split_and_merge.iteration.remove_crowding_rule = MagicMock()
self.merge_result = {
sRule.from_symbols(0.1, self.symbol_S, self.symbol_A,
self.symbol_A),
sRule.from_symbols(0.1, self.symbol_A, self.symbol_A,
self.symbol_A),
sRule.from_symbols(0.1, self.symbol_A, self.symbol_a)
}
self.split_result = {
sRule.from_symbols(0.1, self.symbol_S, self.symbol_A1,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_S, self.symbol_A2,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A1, self.symbol_A1,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A1, self.symbol_A2,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A2, self.symbol_A2,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A2, self.symbol_A1,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A1, self.symbol_a),
sRule.from_symbols(0.1, self.symbol_A2, self.symbol_a),
sRule.from_symbols(0.1, self.symbol_B, self.symbol_a),
sRule.from_symbols(0.1, self.symbol_B, self.symbol_B,
self.symbol_B),
}