def test_make_random_decision_with_probability(self): random.random = MagicMock(return_value=0.5) result = RandomUtils.make_random_decision_with_probability(0.7) self.assertTrue(result) random.random = MagicMock(return_value=0.9) result = RandomUtils.make_random_decision_with_probability(0.7) self.assertFalse(result)
def crossover(self, parents: Tuple[Rule, Rule]) -> Tuple[Rule, Rule, 'CrossoverReport']: parents_copy = pickle.loads(pickle.dumps(parents, -1)) report = CrossoverReport() if RandomUtils.make_random_decision_with_probability(self.crossing_probability): report = self.cross_rules(parents_copy) self.adjust_rules_after_crossover(parents_copy) return parents_copy[0], parents_copy[1], report
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 cross_rules(self, pair: Tuple[Rule, Rule]) -> 'CrossoverReport': report = CrossoverReport() if RandomUtils.make_random_decision_with_probability(0.5): pair[0].right1, pair[1].right1 = pair[1].right1, pair[0].right1 report.first_right_crossed = True else: pair[0].right2, pair[1].right2 = pair[1].right2, pair[0].right2 report.second_right_crossed = True return report
def __apply_aggressive_and_final_covering(cyk_values: CykValues, i: int, j: int): """ Performs aggressive or final covering on the given cell of the cyk table :param i: :param j: :return: """ new_rule = None valid_combinations_of_indexes = [] for m in range(i): tmp_symbols_1 = __get_cell_symbols(cyk_values, m, j) tmp_symbols_2 = __get_cell_symbols(cyk_values, i - m - 1, j + m + 1) if len(tmp_symbols_1) > 0 and len(tmp_symbols_2) > 0: valid_combinations_of_indexes.append(m) if len(valid_combinations_of_indexes) > 0: random = randint(0, len(valid_combinations_of_indexes) - 1) symbols_1 = __get_cell_symbols(cyk_values, valid_combinations_of_indexes[random], j) symbols_2 = __get_cell_symbols( cyk_values, i - valid_combinations_of_indexes[random] - 1, j + valid_combinations_of_indexes[random] + 1) index_1 = randint(0, len(symbols_1) - 1) index_2 = randint(0, len(symbols_2) - 1) if i is not len(cyk_values.sequence) - 1: if RandomUtils.make_random_decision_with_probability( float( cyk_values.settings.get_value( 'covering', 'aggressive_covering_probability'))): covering = cyk_values.aggressive_covering new_rule = covering.add_new_rule(cyk_values.grammar, symbols_1[index_1], symbols_2[index_2]) elif cyk_values.settings.get_value( 'covering', 'is_full_covering_allowed') == "True": covering = cyk_values.final_covering new_rule = covering.add_new_rule(cyk_values.grammar, symbols_1[index_1], symbols_2[index_2]) if new_rule is not None: new_rule.tmp_used = True new_cell_rule = sCellRule( new_rule, Coordinates(valid_combinations_of_indexes[random], j), Coordinates(i - valid_combinations_of_indexes[random] - 1, j + valid_combinations_of_indexes[random] + 1)) cyk_values.rules_table[i][j].append(new_cell_rule) __calculate_cell( cyk_values, cyk_values.probability_array[ valid_combinations_of_indexes[random]][j][ new_rule.right1.index], cyk_values.probability_array[ i - valid_combinations_of_indexes[random] - 1][j + valid_combinations_of_indexes[random] + 1][new_rule.right2.index], cyk_values.probability_array[i][j][new_rule.left.index], new_rule)
def __apply_aggressive_and_final_covering(self, i: int, j: int): """ Performs aggressive or final covering on the given cell of the cyk table :param i: :param j: :return: """ new_rule = None valid_combinations_of_indexes = [] for m in self.iteration_generator(i): tmp_symbols_1 = self.__get_cell_symbols(m, j) tmp_symbols_2 = self.__get_cell_symbols(i - m - 1, j + m + 1) if len(tmp_symbols_1) > 0 and len(tmp_symbols_2) > 0: valid_combinations_of_indexes.append(m) if len(valid_combinations_of_indexes) > 0: random = randint(0, len(valid_combinations_of_indexes) - 1) symbols_1 = self.__get_cell_symbols( valid_combinations_of_indexes[random], j) symbols_2 = self.__get_cell_symbols( i - valid_combinations_of_indexes[random] - 1, j + valid_combinations_of_indexes[random] + 1) index_1 = randint(0, len(symbols_1) - 1) index_2 = randint(0, len(symbols_2) - 1) # print("Need rule: {}". format(symbols_1[index_1], symbols_2[index_2])) if i is not len(self.sequence) - 1: if RandomUtils.make_random_decision_with_probability( float( self.__settings.get_value( 'covering', 'aggressive_covering_probability'))): covering = self.aggressive_covering new_rule = covering.add_new_rule(self.grammar, symbols_1[index_1], symbols_2[index_2]) elif self.__settings.get_value( 'covering', 'is_full_covering_allowed') == "True": covering = self.final_covering new_rule = covering.add_new_rule(self.grammar, symbols_1[index_1], symbols_2[index_2]) if new_rule is not None: self.__generated_rules_count += 1 new_rule.tmp_used = True new_cell_rule = sCellRule( new_rule, Coordinates(valid_combinations_of_indexes[random], j), Coordinates(i - valid_combinations_of_indexes[random] - 1, j + valid_combinations_of_indexes[random] + 1)) self.rules_table[i][j].append(new_cell_rule) self.__Stochastic.calculate_cell( self.mode, self.default_value, self.probability_array, Coordinates(valid_combinations_of_indexes[random], j), Coordinates(i - valid_combinations_of_indexes[random] - 1, j + valid_combinations_of_indexes[random] + 1), Coordinates(i, j), new_rule)
def run(self, grammar: Grammar) -> None: self.save_grammar_state(grammar) ga_prob = self.get_ga_probability(grammar) if RandomUtils.make_random_decision_with_probability(ga_prob): # print("GA launched") new_rules_number = self.calculate_number_of_rules_to_add(grammar) for i in range(int(new_rules_number / 2)): self.add_new_pair(grammar) else: # print("GA not launched") pass
def test_get_random_probability(self): result = RandomUtils.get_random_probability() self.assertGreaterEqual(result, 0) self.assertLessEqual(result, 1)
def mutate_symbol(self, symbol: Symbol, grammar: Grammar) -> Symbol: if RandomUtils.make_random_decision_with_probability(self.mutation_probability): return RandomUtils.get_random_nonterminal_symbol_from(grammar) or symbol else: return symbol
def invert(self, rule: Rule) -> bool: if RandomUtils.make_random_decision_with_probability(self.inversion_probability): self.invert_rule(rule) self.adjust_rules_after_inverse(rule) return True return False