fix linter errors + rename consequence to consequent

Author: zStupan

niaarm/association_rule.py

@@ -74,55 +74,60 @@ def feature_position(self, feature):
                 position = position + 2
         return position
 
-    def support_confidence(self, antecedent, consequence, transactions):
+    def __match_antecedent(self, i, antecedent, transactions):
+        match = 0
+        for j in range(len(antecedent)):
+            dtype = self.features[self.permutation[j]].dtype
+            if dtype == 'float' or dtype == 'int':
+                if antecedent[j] != 'NO':
+                    border = antecedent[j]
+                    if border[0] <= transactions[i, self.permutation[j]] <= border[1]:
+                        match = match + 1
+            elif dtype == 'cat':
+                if antecedent[j] != 'NO':
+                    ant = antecedent[j]
+                    if transactions[i, self.permutation[j]] == ant[0]:
+                        match = match + 1
+        return match
+
+    def __match_consequent(self, i, antecedent, consequent, transactions):
+        match = 0
+        con_counter = 0
+        for ll in range(len(antecedent), len(antecedent) + len(consequent)):
+            dtype = self.features[self.permutation[ll]].dtype
+            if dtype == 'float' or dtype == 'int':
+                if consequent[con_counter] != 'NO':
+                    border = consequent[con_counter]
+                    if border[0] <= transactions[i, self.permutation[ll]] <= border[1]:
+                        match = match + 1
+            elif dtype == 'cat':
+                if consequent[con_counter] != 'NO':
+                    con = consequent[con_counter]
+
+                    if transactions[i, self.permutation[ll]] == con[0]:
+                        match = match + 1
+
+            con_counter = con_counter + 1
+        return match
+
+    def support_confidence(self, antecedent, consequent, transactions):
         supp = 0
         conf = 0
         conf_counter = 0
 
-        # firstly antecedent
         for i in range(len(transactions)):
-            match1 = 0
-            match2 = 0
-            for j in range(len(antecedent)):
-                dtype = self.features[self.permutation[j]].dtype
-                if dtype == 'float' or dtype == 'int':
-                    if antecedent[j] != 'NO':
-                        border = antecedent[j]
-                        if border[0] <= transactions[i, self.permutation[j]] <= border[1]:
-                            match1 = match1 + 1
-                elif dtype == 'cat':
-                    if antecedent[j] != 'NO':
-                        ant = antecedent[j]
-                        if transactions[i, self.permutation[j]] == ant[0]:
-                            match1 = match1 + 1
-
-            # secondly consequence
-            con_counter = 0
-            for ll in range(len(antecedent), len(antecedent) + len(consequence)):
-                dtype = self.features[self.permutation[ll]].dtype
-                if dtype == 'float' or dtype == 'int':
-                    if consequence[con_counter] != 'NO':
-                        border = consequence[con_counter]
-                        if border[0] <= transactions[i, self.permutation[ll]] <= border[1]:
-                            match2 = match2 + 1
-                elif dtype == 'cat':
-                    if consequence[con_counter] != 'NO':
-                        con = consequence[con_counter]
-
-                        if transactions[i, self.permutation[ll]] == con[0]:
-                            match2 = match2 + 1
-
-                con_counter = con_counter + 1
+            match_antecedent = self.__match_antecedent(i, antecedent, transactions)
+            match_consequent = self.__match_consequent(i, antecedent, consequent, transactions)
 
             missing_ant = antecedent.count('NO')
-            missing_con = consequence.count('NO')
+            missing_con = consequent.count('NO')
 
-            if (missing_ant + match1) == len(antecedent):
+            if (missing_ant + match_antecedent) == len(antecedent):
                 conf_counter += 1
-                if (missing_con + match2) == len(consequence):
+                if (missing_con + match_consequent) == len(consequent):
                     conf = conf + 1
 
-            total = match1 + match2 + missing_ant + missing_con
+            total = match_antecedent + match_consequent + missing_ant + missing_con
 
             if total == len(self.features):
                 supp = supp + 1
@@ -138,11 +143,11 @@ def support_confidence(self, antecedent, consequence, transactions):
 
         return total_supp, total_conf
 
-    def coverage(self, antecedent, consequence):
-        missing_total = antecedent.count("NO") + consequence.count("NO")
+    def coverage(self, antecedent, consequent):
+        missing_total = antecedent.count("NO") + consequent.count("NO")
         return 1 - missing_total / len(self.features)
 
-    def shrinkage(self, antecedent, consequence):
+    def shrinkage(self, antecedent, consequent):
         differences = []
 
         for i in range(len(antecedent)):
@@ -156,11 +161,11 @@ def shrinkage(self, antecedent, consequence):
                     differences.append(diff)
 
         con_counter = 0
-        for ll in range(len(antecedent), len(antecedent) + len(consequence)):
+        for ll in range(len(antecedent), len(antecedent) + len(consequent)):
             feature = self.features[self.permutation[ll]]
             if feature.dtype == 'float' or feature.dtype == 'int':
-                if consequence[con_counter] != 'NO':
-                    borders = consequence[con_counter]
+                if consequent[con_counter] != 'NO':
+                    borders = consequent[con_counter]
                     diff_borders = borders[1] - borders[0]
                     total_borders = feature.max_val - feature.min_val
                     diff = diff_borders / total_borders
@@ -175,9 +180,9 @@ def shrinkage(self, antecedent, consequence):
             return 0.0
         return 1 - normalized
 
-    def format_rules(self, antecedent, consequence):
+    def format_rules(self, antecedent, consequent):
         antecedent1 = []
-        consequence1 = []
+        consequent1 = []
 
         for i in range(len(antecedent)):
             if antecedent[i] != "NO":
@@ -188,15 +193,15 @@ def format_rules(self, antecedent, consequence):
                     rule = feature.name + "(" + str(antecedent[i]) + ")"
                 antecedent1.append(rule)
 
-        for i in range(len(consequence)):
-            if consequence[i] != "NO":
+        for i in range(len(consequent)):
+            if consequent[i] != "NO":
                 feature = self.features[self.permutation[i + len(antecedent)]]
                 if feature.dtype == "cat":
-                    rule = feature.name + "(" + str(consequence[i][0]) + ")"
+                    rule = feature.name + "(" + str(consequent[i][0]) + ")"
                 else:
-                    rule = feature.name + "(" + str(consequence[i]) + ")"
-                consequence1.append(rule)
-        return antecedent1, consequence1
+                    rule = feature.name + "(" + str(consequent[i]) + ")"
+                consequent1.append(rule)
+        return antecedent1, consequent1
 
 
 def _normalize(value, actual_bounds, real_bounds):

niaarm/dataset.py

@@ -41,7 +41,7 @@ def __analyse_types(self):
                 unique_categories = None
             else:
                 dtype = "cat"
-                unique_categories = sorted(col.astype('string').unique().tolist(), key=str.lower)  # convert to str just in case
+                unique_categories = sorted(col.astype('string').unique().tolist(), key=str.lower)
                 min_value = None
                 max_value = None
 

niaarm/niaarm.py

@@ -11,9 +11,15 @@ class NiaARM(Problem):
     Reference:
         The implementation is composed of ideas found in the following papers:
 
-        I. Fister Jr., A. Iglesias, A. Gálvez, J. Del Ser, E. Osaba, I Fister. [Differential evolution for association rule mining using categorical and numerical attributes](http://www.iztok-jr-fister.eu/static/publications/231.pdf) In: Intelligent data engineering and automated learning - IDEAL 2018, pp. 79-88, 2018.
+        I. Fister Jr., A. Iglesias, A. Gálvez, J. Del Ser, E. Osaba, I Fister.
+        [Differential evolution for association rule mining using categorical and numerical attributes]
+        (http://www.iztok-jr-fister.eu/static/publications/231.pdf)
+        In: Intelligent data engineering and automated learning - IDEAL 2018, pp. 79-88, 2018.
 
-        I. Fister Jr., V. Podgorelec, I. Fister. Improved Nature-Inspired Algorithms for Numeric Association Rule Mining. In: Vasant P., Zelinka I., Weber GW. (eds) Intelligent Computing and Optimization. ICO 2020. Advances in Intelligent Systems and Computing, vol 1324. Springer, Cham.
+        I. Fister Jr., V. Podgorelec, I. Fister.
+        Improved Nature-Inspired Algorithms for Numeric Association Rule Mining.
+        In: Vasant P., Zelinka I., Weber GW. (eds) Intelligent Computing and Optimization. ICO 2020.
+        Advances in Intelligent Systems and Computing, vol 1324. Springer, Cham.
 
     Attributes:
         features (list[Feature]): List of features.
@@ -39,10 +45,10 @@ def __init__(self, dimension, features, transactions, alpha=0.0, beta=0.0, gamma
         self.rules = []
         super().__init__(dimension, 0.0, 1.0)
 
-    def rule_exists(self, antecedent, consequence):
+    def rule_exists(self, antecedent, consequent):
         r"""Check if association rule already exists."""
         for rule in self.rules:
-            if rule.antecedent == antecedent and rule.consequence == consequence:
+            if rule.antecedent == antecedent and rule.consequent == consequent:
                 return True
         return False
 
@@ -52,11 +58,11 @@ def export_rules(self, path):
             writer = csv.writer(f)
 
             # write header
-            writer.writerow(["Antecedent", "Consequence", "Fitness", "Support", "Confidence", "Coverage", "Shrinkage"])
+            writer.writerow(["Antecedent", "consequent", "Fitness", "Support", "Confidence", "Coverage", "Shrinkage"])
 
             for rule in self.rules:
                 writer.writerow(
-                    [rule.antecedent, rule.consequence, rule.fitness, rule.support, rule.confidence, rule.coverage,
+                    [rule.antecedent, rule.consequent, rule.fitness, rule.support, rule.confidence, rule.coverage,
                      rule.shrink])
         print(f"Rules exported to {path}")
 
@@ -74,41 +80,41 @@ def _evaluate(self, sol):
 
         rule = arm.build_rule(solution)
 
-        # get antecedent and consequence of rule
+        # get antecedent and consequent of rule
         antecedent = rule[:cut]
-        consequence = rule[cut:]
+        consequent = rule[cut:]
 
         # check if rule is feasible
-        if _rule_feasible(antecedent, consequence):
+        if _rule_feasible(antecedent, consequent):
             # get support and confidence of rule
-            support, confidence = arm.support_confidence(antecedent, consequence, self.transactions)
+            support, confidence = arm.support_confidence(antecedent, consequent, self.transactions)
 
             if self.gamma == 0.0:
                 shrinkage = 0
             else:
-                shrinkage = arm.shrinkage(antecedent, consequence)
+                shrinkage = arm.shrinkage(antecedent, consequent)
 
             if self.delta == 0.0:
                 coverage = 0
             else:
-                coverage = arm.coverage(antecedent, consequence)
+                coverage = arm.coverage(antecedent, consequent)
 
             fitness = ((self.alpha * support) + (self.beta * confidence) + (self.gamma * shrinkage) +
                        (self.delta * coverage)) / (self.alpha + self.beta + self.gamma + self.delta)
 
-            # in case no attributes were selected for antecedent or consequence
-            if antecedent.count("NO") == len(antecedent) or consequence.count("NO") == len(consequence):
+            # in case no attributes were selected for antecedent or consequent
+            if antecedent.count("NO") == len(antecedent) or consequent.count("NO") == len(consequent):
                 fitness = 0.0
 
             if support > 0.0 and confidence > 0.0:
-                antecedent, consequence = _fix_border(antecedent, consequence)
+                antecedent, consequent = _fix_border(antecedent, consequent)
                 # format rule; remove NO; add name of features
-                antecedent1, consequence1 = arm.format_rules(antecedent, consequence)
+                antecedent1, consequent1 = arm.format_rules(antecedent, consequent)
 
                 # save feasible rule
-                if not self.rule_exists(antecedent1, consequence1):
+                if not self.rule_exists(antecedent1, consequent1):
                     self.rules.append(
-                        Rule(antecedent1, consequence1, fitness, support, confidence, coverage, shrinkage))
+                        Rule(antecedent1, consequent1, fitness, support, confidence, coverage, shrinkage))
 
                 if fitness > self.best_fitness:
                     self.best_fitness = fitness
@@ -119,26 +125,26 @@ def _evaluate(self, sol):
             return -1.0
 
 
-def _fix_border(antecedent, consequence):
+def _fix_border(antecedent, consequent):
     r"""In case lower and upper bounds of interval are the same.
         We need this in order to provide clean output.
 
         Arguments:
             antecedent (np.ndarray): .
-            consequence (np.ndarray): .
+            consequent (np.ndarray): .
 
         Returns:
             antecedent (array):
-            consequence (array):
+            consequent (array):
     """
     for i in range(len(antecedent)):
         if len(antecedent[i]) > 1:
             if antecedent[i][0] == antecedent[i][1]:
                 antecedent[i] = antecedent[i][0]
 
-    for i in range(len(consequence)):
-        if len(consequence[i]) > 1:
-            if consequence[i][0] == consequence[i][1]:
-                consequence[i] = consequence[i][0]
+    for i in range(len(consequent)):
+        if len(consequent[i]) > 1:
+            if consequent[i][0] == consequent[i][1]:
+                consequent[i] = consequent[i][0]
 
-    return antecedent, consequence
+    return antecedent, consequent

niaarm/rule.py

@@ -8,7 +8,7 @@ class Rule:
 
     Attributes:
         antecedent (list[str]): A list of antecedents of association rule.
-        consequence (list[str]): A list of consequents of association rule.
+        consequent (list[str]): A list of consequents of association rule.
         fitness (float): Value of fitness function.
         support (float): Value of support.
         confidence (float): Value of confidence.
@@ -18,7 +18,7 @@ class Rule:
     """
 
     antecedent: list[str]
-    consequence: list[str]
+    consequent: list[str]
     fitness: float
     support: float
     confidence: float

niaarm/stats.py

@@ -41,4 +41,4 @@ def avg_ant_len(self):
 
     @property
     def avg_con_len(self):
-        return np.mean([len(rule.consequence) for rule in self.rules])
+        return np.mean([len(rule.consequent) for rule in self.rules])

niaarm/tests/test_coverage.py

@@ -15,22 +15,22 @@ def test_a(self):
         # Rule: A => 0
         antecedent = [['A']]
 
-        consequence = [[0, 0]]
+        consequent = [[0, 0]]
 
         oper = AssociationRule(self.features)
 
-        coverage = oper.coverage(antecedent, consequence)
+        coverage = oper.coverage(antecedent, consequent)
 
         self.assertEqual(coverage, 1)
 
     def test_b(self):
         # Rule: NO => 0
         antecedent = ["NO"]
 
-        consequence = [[0, 0]]
+        consequent = [[0, 0]]
 
         oper = AssociationRule(self.features)
 
-        coverage = oper.coverage(antecedent, consequence)
+        coverage = oper.coverage(antecedent, consequent)
 
         self.assertEqual(coverage, 0.5)