def unexpected_case(cl: Classifier, p0: Perception, p1: Perception, time: int) -> Optional[Classifier]: """ Controls the unexpected case of the classifier. :param cl: :param p0: :param p1: :param time: :return: specialized classifier if generation was possible, None otherwise """ cl.decrease_quality() cl.set_mark(p0) # Return if the effect is not specializable if not cl.effect.is_specializable(p0, p1): return None child = cl.copy_from(cl, time) child.specialize(p0, p1, leave_specialized=True) if child.q < 0.5: child.q = 0.5 return child
def test_should_copy_classifier(self, cfg): # given operation_time = 123 original_cl = Classifier(condition='1###1011', action=1, effect='10####1#', reward=50, quality=0.7, cfg=cfg) # when copied_cl = Classifier.copy_from(original_cl, operation_time) # Assert that we are dealing with different object assert original_cl is not copied_cl # Assert that condition is equal but points to another object assert original_cl.condition == copied_cl.condition assert original_cl.condition is not copied_cl.condition # Assert that action is equal assert original_cl.action == copied_cl.action # Assert that effect is equal but points to another object assert original_cl.effect == copied_cl.effect assert original_cl.effect is not copied_cl.effect # Assert that other properties were set accordingly assert copied_cl.is_marked() is False assert 50 == copied_cl.r assert 0.7 == copied_cl.q assert operation_time == copied_cl.tga assert operation_time == copied_cl.talp
def test_copy_from_and_mutate_does_not_influence_another_condition( self, cfg): """ Verify that not just reference to Condition copied (changing which will change the original - definitily not original C++ code did). """ # given s = cfg.mu * 0.5 # less then MU b = 1 - (1 - cfg.mu) * 0.5 # more then MU operation_time = 123 original_cl = Classifier(condition='1###1011', cfg=cfg) copied_cl = Classifier.copy_from(original_cl, operation_time) # when mutate(copied_cl, cfg.mu, RandomMock([s, b, b, b, b])) # then assert Condition('####1011') == copied_cl.condition assert Condition('1###1011') == original_cl.condition # when mutate(original_cl, cfg.mu, RandomMock([b, s, b, b, b])) # then assert Condition('1####011') == original_cl.condition assert Condition('####1011') == copied_cl.condition
def unexpected_case(cl: Classifier, p0: Perception, p1: Perception, time: int) -> Optional[Classifier]: """ Controls the unexpected case of the classifier. :param cl: :param p0: :param p1: :param time: :return: specialized classifier if generation was possible, None otherwise """ cl.decrease_quality() cl.set_mark(p0) # Return if the effect is not specializable if not cl.effect.is_specializable(p0, p1): return None child = cl.copy_from(cl, time) if cl.cfg.do_pee: # Probability-Enhanced attributes cannot appear in the effect part # if we leave already specialized attributes unchanged. # Therefore don't leave specialized. child.specialize(p0, p1, leave_specialized=False) else: child.specialize(p0, p1, leave_specialized=True) if child.q < 0.5: child.q = 0.5 return child
def expected_case(cl: Classifier, p0: Perception, time: int) -> Optional[Classifier]: """ Controls the expected case of a classifier. If the classifier is too specific it tries to add some randomness to it by generalizing some attributes. :param cl: :param p0: :param time: :return: new classifier or None """ if cl.cfg.do_pee: cl.effect.update_enhanced_effect_probs(p0, cl.cfg.beta) diff = cl.mark.get_differences(p0) if diff.specificity == 0: if cl.cfg.do_pee and cl.is_marked(): cl.ee = True cl.increase_quality() return None no_spec = len(cl.specified_unchanging_attributes) no_spec_new = diff.specificity child = cl.copy_from(cl, time) if no_spec >= cl.cfg.u_max: while no_spec >= cl.cfg.u_max: res = cl.generalize_unchanging_condition_attribute() assert res is True no_spec -= 1 while no_spec + no_spec_new > cl.cfg.u_max: if random() < 0.5: diff.generalize_specific_attribute_randomly() no_spec_new -= 1 else: if cl.generalize_unchanging_condition_attribute(): no_spec -= 1 else: while no_spec + no_spec_new > cl.cfg.u_max: diff.generalize_specific_attribute_randomly() no_spec_new -= 1 child.condition.specialize_with_condition(diff) if child.q < 0.5: child.q = 0.5 return child
def test_copy_from_and_change_does_not_influence_another_effect(self, cfg): """ Verify that not just reference to Condition copied (changing which will change the original - definitily not original C++ code did). """ # given operation_time = 123 original_cl = Classifier(effect='10####1#', cfg=cfg) # when copied_cl = Classifier.copy_from(original_cl, operation_time) # when & then copied_cl.effect[2] = '1' assert Effect('101###1#') == copied_cl.effect assert Effect('10####1#') == original_cl.effect # when & then original_cl.effect[3] = '0' assert Effect('101###1#') == copied_cl.effect assert Effect('10#0##1#') == original_cl.effect