def test_should_handle_expected_case_4(self, cfg):
# given
p0 = Perception('11101101')
time = 703
cls = Classifier(condition='1##01#0#',
action=7,
effect='0##10#1#',
quality=0.47,
cfg=cfg)
cls.mark[1].update(['0', '2'])
cls.mark[2].update(['1'])
cls.mark[5].update(['0', '1'])
cls.mark[7].update(['1'])
# when
new_cls = expected_case(cls, p0, time)
# then
assert new_cls is not None
# One `random` attribute gets specified
assert new_cls.condition.specificity in [4, 5]
assert Effect('0##10#1#') == new_cls.effect
assert 7 == new_cls.action
assert new_cls.is_marked() is False
assert 0.5 == new_cls.q
def test_should_handle_expected_case_3(self, cfg):
# given
p0 = Perception('00110000')
time = 26
cls = Classifier(action=5, quality=0.46, cfg=cfg)
cls.mark[0].add('0')
cls.mark[1].add('1')
cls.mark[2].add('0')
cls.mark[3].add('1')
cls.mark[4].add('0')
cls.mark[5].add('1')
cls.mark[6].add('1')
cls.mark[7].add('1')
# when
new_cls = expected_case(cls, p0, time)
# then
assert new_cls is not None
# One `random` attribute gets specified
assert 1 == new_cls.condition.specificity
assert Effect('########') == new_cls.effect
assert 5 == new_cls.action
assert new_cls.is_marked() is False
assert 0.5 == new_cls.q
def apply_alp(self, previous_situation: Perception, action: int,
situation: Perception, time: int,
population: ClassifiersList,
match_set: ClassifiersList) -> None:
"""
The Anticipatory Learning Process. Handles all updates by the ALP,
insertion of new classifiers in pop and possibly matchSet, and
deletion of inadequate classifiers in pop and possibly matchSet.
:param previous_situation:
:param action:
:param situation:
:param time:
:param population:
:param match_set:
"""
new_list = ClassifiersList(cfg=self.cfg)
new_cl: Optional[Classifier] = None
was_expected_case = False
delete_count = 0
for cl in self:
cl.increase_experience()
cl.set_alp_timestamp(time)
if cl.does_anticipate_correctly(previous_situation, situation):
new_cl = expected_case(cl, previous_situation, time)
was_expected_case = True
else:
new_cl = unexpected_case(cl, previous_situation, situation,
time)
if cl.is_inadequate():
# Removes classifier from population, match set
# and current list
delete_count += 1
lists = [x for x in [population, match_set, self] if x]
for lst in lists:
lst.safe_remove(cl)
if new_cl is not None:
new_cl.tga = time
self.add_alp_classifier(new_cl, new_list)
# No classifier anticipated correctly - generate new one
if not was_expected_case:
new_cl = cover(previous_situation, action, situation, time,
self.cfg)
self.add_alp_classifier(new_cl, new_list)
# Merge classifiers from new_list into self and population
self.extend(new_list)
population.extend(new_list)
if match_set is not None:
new_matching = [
cl for cl in new_list if cl.condition.does_match(situation)
]
match_set.extend(new_matching)
def test_should_handle_expected_case_2(self, cfg):
# given
cls = Classifier(condition='#0######', quality=0.521, cfg=cfg)
p0 = Perception('10101001')
time = 59
# when
new_cls = expected_case(cls, p0, time)
# then
assert new_cls is None
assert abs(0.54 - cls.q) < 0.01
def apply_alp(population: ClassifiersList, match_set: ClassifiersList,
action_set: ClassifiersList, p0: Perception, action: int,
p1: Perception, time: int, theta_exp: int,
cfg: Configuration) -> None:
"""
The Anticipatory Learning Process. Handles all updates by the ALP,
insertion of new classifiers in pop and possibly matchSet, and
deletion of inadequate classifiers in pop and possibly matchSet.
Parameters
----------
population
match_set
action_set
p0: Perception
action: int
p1: Perception
time: int
theta_exp
cfg: Configuration
Returns
-------
"""
new_list = ClassifiersList()
new_cl: Optional[Classifier] = None
was_expected_case = False
delete_count = 0
for cl in action_set:
cl.increase_experience()
cl.update_application_average(time)
if cl.does_anticipate_correctly(p0, p1):
new_cl = alp_acs2.expected_case(cl, p0, time)
was_expected_case = True
else:
new_cl = alp_acs2.unexpected_case(cl, p0, p1, time)
if cl.is_inadequate():
# Removes classifier from population, match set
# and current list
delete_count += 1
lists = [
x for x in [population, match_set, action_set] if x
]
for lst in lists:
lst.safe_remove(cl)
if new_cl is not None:
new_cl.tga = time
alp.add_classifier(new_cl, action_set, new_list, theta_exp)
# No classifier anticipated correctly - generate new one
if not was_expected_case:
new_cl = alp_acs2.cover(p0, action, p1, time, cfg)
alp.add_classifier(new_cl, action_set, new_list, theta_exp)
# Merge classifiers from new_list into self and population
action_set.extend(new_list)
population.extend(new_list)
if match_set is not None:
new_matching = [
cl for cl in new_list if matching(cl.condition, p1)
]
match_set.extend(new_matching)