Ejemplo n.º 1
0
    def fit(self):
        begin = datetime.now()

        # Initialization
        self._TermsManager = TermsManager(self._Dataset,
                                          self.min_case_per_rule)
        self._Pruner = Pruner(self._Dataset, self._TermsManager, self.alpha)
        self._no_of_uncovered_cases = self._Dataset.get_no_of_uncovered_cases()
        self._get_population_Survival()

        while not self._global_stopping_condition():

            # local variables
            ant_index = 0
            converg_test_index = 1

            # Initialize rules
            previous_rule = Rule(self._Dataset, self.alpha)
            best_rule = copy.deepcopy(previous_rule)

            # Local search
            while not self._local_stopping_condition(ant_index,
                                                     converg_test_index):

                current_rule = Rule(self._Dataset, self.alpha)
                current_rule.construct(self._TermsManager,
                                       self.min_case_per_rule)
                current_rule = self._Pruner.prune(current_rule)

                if current_rule.equals(previous_rule):
                    converg_test_index += 1
                else:
                    converg_test_index = 1
                    if current_rule.fitness > best_rule.fitness:
                        best_rule = copy.deepcopy(current_rule)

                self._TermsManager.pheromone_updating(current_rule.antecedent,
                                                      current_rule.fitness)
                previous_rule = copy.deepcopy(current_rule)
                ant_index += 1

            # case: local search didnt find any exceptional rules
            if best_rule.fitness < 1 - self.alpha:
                break
            # saving local search results
            elif self._can_add_rule(
                    best_rule):  # check if rule already exists on the list
                self.discovered_rule_list.append(best_rule)
                self._Dataset.update_covered_cases(best_rule.sub_group_cases)
                self._no_of_uncovered_cases = self._Dataset.get_no_of_uncovered_cases(
                )
            self._TermsManager.pheromone_init()
            self._iterations += 1
        self._run_time = datetime.now() - begin

        # generates the rules representative strings
        for index, rule in enumerate(self.discovered_rule_list):
            rule.set_string_repr(index)
            rule.set_KMmodel()
        return
    def fit(self):
        # Initialization
        self._TermsManager = TermsManager(self._Dataset,
                                          self.min_case_per_rule)
        self._Pruner = Pruner(self._Dataset, self._TermsManager)
        self._no_of_uncovered_cases = self._Dataset.get_no_of_uncovered_cases()

        converg_list_index = 0
        while not self._global_stopping_condition(converg_list_index):

            # local variables
            ant_index = 0
            converg_test_index = 1

            # Initialize rules
            previous_rule = Rule(self._Dataset)
            best_rule = copy.deepcopy(previous_rule)
            best_rule.quality = 1 - UserInputs.alpha

            while not self._local_stopping_condition(ant_index,
                                                     converg_test_index):

                current_rule = Rule(self._Dataset)
                current_rule.construct(self._TermsManager,
                                       self.min_case_per_rule)
                current_rule = self._Pruner.prune(current_rule)

                if current_rule.equals(previous_rule):
                    converg_test_index += 1
                else:
                    converg_test_index = 1
                    if current_rule.quality > best_rule.quality:
                        best_rule = copy.deepcopy(current_rule)

                self._TermsManager.pheromone_updating(current_rule.antecedent,
                                                      current_rule.quality)
                previous_rule = copy.deepcopy(current_rule)
                ant_index += 1

            if best_rule.quality == 1 - UserInputs.alpha:  # did not generate any rules
                break
            else:
                if self._can_add_rule(
                        best_rule):  # check if rule already exists on the list
                    self.discovered_rule_list.append(best_rule)
                    self._Dataset.update_covered_cases(
                        best_rule.sub_group_cases)
                    self._no_of_uncovered_cases = self._Dataset.get_no_of_uncovered_cases(
                    )
                    converg_list_index = 0
                else:
                    converg_list_index += 1

            self._TermsManager.pheromone_init()
            self._iterations += 1
        # END OF WHILE (AVAILABLE_CASES > MAX_UNCOVERED_CASES)

        # generates the rules representative strings
        for index, rule in enumerate(self.discovered_rule_list):
            rule.set_string_repr(index)

        return