示例#1
0
    def test_find_old_classifier_none(self, cfg):
        # given
        classifier_list = ClassifiersList(cfg=cfg)
        cl = Classifier(cfg=cfg)

        # when
        old_cl = classifier_list.find_old_classifier(cl)

        assert old_cl is None
示例#2
0
    def test_find_old_classifier_only_subsumer(self, cfg):
        # given
        subsumer1 = Classifier(condition='1##0####',
                               action=3,
                               effect='##1#####',
                               quality=0.93,
                               reward=1.35,
                               experience=23,
                               cfg=cfg)

        subsumer2 = Classifier(condition='#1#0####',
                               action=3,
                               effect='##1#####',
                               quality=0.93,
                               reward=1.35,
                               experience=23,
                               cfg=cfg)

        most_general = Classifier(condition='###0####',
                                  action=3,
                                  effect='##1#####',
                                  quality=0.93,
                                  reward=1.35,
                                  experience=23,
                                  cfg=cfg)

        nonsubsumer = Classifier(cfg=cfg)

        classifier = Classifier(condition='11#0####',
                                action=3,
                                effect='##1#####',
                                quality=0.5,
                                reward=0.35,
                                experience=1,
                                cfg=cfg)

        classifiers_list = ClassifiersList(*[
            nonsubsumer, subsumer1, nonsubsumer, most_general, subsumer2,
            nonsubsumer
        ],
                                           cfg=cfg)

        # when
        actual_old_classifier = classifiers_list.find_old_classifier(
            classifier)

        # then
        assert most_general == actual_old_classifier
示例#3
0
    def test_find_old_classifier_only_similar(self, cfg):
        # given
        classifier_1 = Classifier(action=1, experience=32, cfg=cfg)
        classifier_2 = Classifier(action=1, cfg=cfg)
        classifiers = ClassifiersList(*[
            classifier_1,
            Classifier(action=2, cfg=cfg),
            Classifier(action=3, cfg=cfg), classifier_2
        ],
                                      cfg=cfg)

        # when
        actual_old_classifier = classifiers.find_old_classifier(
            Classifier(action=1, cfg=cfg))

        # then
        assert classifier_1 == actual_old_classifier
示例#4
0
    def test_find_old_classifier_similar_and_subsumer_subsumer_returned(
            self, cfg):
        # given
        subsumer = Classifier(condition='1#######',
                              action=1,
                              experience=21,
                              quality=0.95,
                              cfg=cfg)

        similar = Classifier(condition='10######', action=1, cfg=cfg)

        existing_classifiers = ClassifiersList(*[similar, subsumer], cfg=cfg)

        classifier = Classifier(condition='10######', action=1, cfg=cfg)

        # when
        old_cls = existing_classifiers.find_old_classifier(classifier)

        # then
        assert subsumer.does_subsume(classifier) is True
        assert similar == classifier
        assert subsumer == old_cls