添加关联规则生成

Author: Boyce.Zhang

src/apriori/AssociationRule.java

@@ -0,0 +1,85 @@
+package apriori;
+
+import common.utils.AssertUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * User: Boyce
+ * Date: 11/12/15
+ * Time: 15:07
+ */
+// 关联规则对象
+public class AssociationRule {
+
+    // 关联规则前件
+    private List<SingleItem> frontItem;
+    // 关联规则后建
+    private List<SingleItem> afterItem;
+
+    public AssociationRule(List<SingleItem> frontItem, List<SingleItem> afterItem) {
+        AssertUtils.assertNotEmpty(frontItem);
+        AssertUtils.assertNotEmpty(afterItem);
+
+        this.frontItem = new ArrayList<SingleItem>(frontItem);
+        this.afterItem = new ArrayList<SingleItem>(afterItem);
+    }
+
+    public AssociationRule(SingleItem frontItem, List<SingleItem> afterItem) {
+        this(asList(frontItem), afterItem);
+    }
+
+    public AssociationRule(List<SingleItem> frontItem, SingleItem afterItem) {
+        this(frontItem, asList(afterItem));
+    }
+
+    public AssociationRule(SingleItem frontItem, SingleItem afterItem) {
+        this(asList(frontItem), asList(afterItem));
+    }
+
+    private static List<SingleItem> asList(SingleItem singleItem) {
+        List<SingleItem> list = new ArrayList<SingleItem>();
+        list.add(singleItem);
+        return list;
+    }
+
+    public List<SingleItem> getFrontItem() {
+        return frontItem;
+    }
+
+    public List<SingleItem> getAfterItem() {
+        return afterItem;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof AssociationRule)) return false;
+
+        AssociationRule that = (AssociationRule) o;
+
+        if (!afterItem.equals(that.afterItem)) return false;
+        if (!frontItem.equals(that.frontItem)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = frontItem.hashCode();
+        result = 31 * result + afterItem.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("AssociationRule{");
+        sb.append(frontItem);
+        sb.append(" > ");
+        sb.append(afterItem);
+        sb.append('}');
+        return sb.toString();
+    }
+}

src/apriori/Item.java

@@ -17,6 +17,7 @@ public class Item {
     // the item contains transactions, transactions size is the item count.
     // 每个item保存其所在的transaction 的名字集合
     protected Set<String> ownerTransactionNames;
+    protected int count;
 
     // item length, example: a :length=1, a,b: length=2
     protected int length;
@@ -42,6 +43,10 @@ public void addTransactions(Set<String> transactionNames) {
     //  count(X) = |{t(i)|X属于t(i), t(i)属于ts}|
     // item 的count 是 item所属于的t的数量
     public int count() {
+        if (this.ownerTransactionNames == null ||
+                this.ownerTransactionNames.isEmpty())
+            return count;
+
         return this.ownerTransactionNames.size();
     }
 
@@ -54,6 +59,8 @@ public int length() {
     }
 
     public void clear() {
+        // 保存下count
+        this.count = this.ownerTransactionNames.size();
         this.ownerTransactionNames.clear();
     }
 }

src/apriori/Itemset.java

@@ -2,10 +2,7 @@
 
 import common.utils.AssertUtils;
 
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /**
  * User: Boyce
@@ -14,6 +11,10 @@
  */
 public class Itemset implements Cloneable {
     protected List<Item> items;
+
+    // 生成该k项集的(k-1)项集
+    protected Itemset parentItemset;
+
     // TODO comment
     protected int cardinal_number;
     protected int length;
@@ -48,6 +49,7 @@ public int length() {
     public Itemset frequent_gen(Transactions transactions) {
         int c_cardinal_number = this.cardinal_number + 1;
         Itemset frequentItemset = new Itemset(c_cardinal_number, transactions);
+        frequentItemset.parentItemset = this;
 
         MultiItem multiItem;
         for(int i=0; i<length; i++) {
@@ -133,18 +135,106 @@ private void addItemIfFrequent(Item item) {
     }
 
     public static Itemset init(Transactions transactions) {
-        Itemset candidateItemset = new Itemset(1, transactions);
+        Itemset frequentItemset = new Itemset(1, transactions);
         List<SingleItem> singleItems = transactions.allSingleItems();
-        for (Item item: singleItems) {
-            candidateItemset.addItemIfFrequent(item);
+        for (SingleItem item: singleItems) {
+            frequentItemset.addItemIfFrequent(item);
         }
-        return candidateItemset;
+        return frequentItemset;
     }
 
     public boolean isEmpty() {
         return this.items.isEmpty();
     }
 
+    // 该频繁项集生成关联规则
+    public List<AssociationRule> rule_gen() {
+
+        if (1 == this.cardinal_number)
+            return Collections.EMPTY_LIST;
+
+        List<AssociationRule> f_rules = new ArrayList<AssociationRule>();
+        List<Item> items = this.items;
+
+        // 计算频繁项集中每个频繁项的关联规则
+        for (int i=0; i<items.size(); i++) {
+            MultiItem multiItem = (MultiItem)items.get(i);
+
+            // TODO 如果一条关联规则的后件为a，那么所有以a的非空子集作为后件的候选规则
+            // TODO 都是关联规则，换句话说，如果以a为后件的候选规则不是关联规则，则
+            // TODO 任何以a为子项的父集作为后件的候选规则都不是关联规则。
+
+            // 获取该频繁项的所有 1-候选规则
+            List<AssociationRule> c1_rules = multiItem.a_1AssociationRules();
+            this.recurse(f_rules, c1_rules, multiItem);
+        }
+        return f_rules;
+    }
+
+    private void recurse(List<AssociationRule> f_rules, List<AssociationRule> c_rules, MultiItem multiItem) {
+        for (AssociationRule rule: c_rules) {
+            if (isFrequentRule(rule, multiItem)) {
+                f_rules.add(rule);
+
+                List<AssociationRule> ck_rules = multiItem.a_kAssociationRules(rule.getAfterItem());
+                this.recurse(f_rules, ck_rules, multiItem);
+            }
+        }
+    }
+
+    private boolean isFrequentRule(AssociationRule rule, MultiItem item) {
+        List<SingleItem> frontItem = rule.getFrontItem();
+
+        int n = frontItem.size();
+        int n_parent = this.cardinal_number - n;
+
+        Itemset n_parent_itemset = this;
+        for (int i=0; i<n_parent; i++)
+            n_parent_itemset = n_parent_itemset.parentItemset;
+
+        int front_count = 0;
+        if (n == 1)
+            front_count = n_parent_itemset.count(frontItem.get(0));
+        else
+            front_count = n_parent_itemset.count(new MultiItem(frontItem));
+
+        double conf = (double)item.count/front_count;
+        boolean isFrequentRule = conf >= this.transactions.minconf();
+
+        if (isFrequentRule) {
+            System.out.println("> add    a rule: " + rule + ", conf=" + item.count + "/" + front_count + " = " + (double)item.count/front_count);
+        }
+        return isFrequentRule;
+    }
+
+    public int count(Item item) {
+        int count = 0;
+        for (int i=0; i<this.items.size(); i++) {
+            Item it = this.items.get(i);
+            if (it.equals(item)) {
+                count = it.count();
+                break;
+            }
+        }
+        return count;
+    }
+
+    public int count(SingleItem item) {
+        int count = 0;
+        for (int i=0; i<this.items.size(); i++) {
+            SingleItem it = (SingleItem)this.items.get(i);
+            if (it.value.equals(((SingleItem)(item.value)).value)) {
+                count = it.count();
+                break;
+            }
+        }
+        return count;
+    }
+
+    public Itemset getParentItemset() {
+        return parentItemset;
+    }
+
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("Itemset{");

src/apriori/Main.java

@@ -1,5 +1,7 @@
 package apriori;
 
+import java.util.*;
+
 /**
  * Created with IntelliJ IDEA.
  * User: Boyce
@@ -9,7 +11,7 @@
  */
 public class Main {
     public static void main(String[] args) {
-        Transactions transactions = new Transactions(0.25, 0.4);
+        Transactions transactions = new Transactions(0.25, 0.7);
 
         Transaction t1 = new Transaction("t1", transactions);
         t1.addItem("a");
@@ -57,5 +59,11 @@ public static void main(String[] args) {
             f = f.frequent_gen(transactions);
             System.out.println(f);
         }
+
+        f = f.parentItemset;
+        System.out.println(f);
+
+        List<AssociationRule> rules = f.rule_gen();
+        System.out.println("rules: " + rules);
     }
 }

src/apriori/MultiItem.java

@@ -28,17 +28,27 @@ public MultiItem(List<SingleItem> items) {
         this.values.addAll(items);
     }
 
-    public void addValue(Object obj) {
-        AssertUtils.assertNotNull(obj, "cannot add a null value into item.");
+    public void addItem(SingleItem singleItem) {
+        AssertUtils.assertNotNull(singleItem, "cannot add a null item into item.");
         AssertUtils.assertTrue(this.values.size() < this.length, "out of the item length.");
 
-        SingleItem singleItem = new SingleItem(obj);
-
         // TODO 保证list里面的元素不重复
         if (!this.values.contains(singleItem))
             this.values.add(singleItem);
     }
 
+    public void addItems(List<SingleItem> singleItems) {
+        for (SingleItem item: singleItems)
+            this.addItem(item);
+    }
+
+    public void addValue(Object obj) {
+        AssertUtils.assertNotNull(obj, "cannot add a null value into item.");
+        SingleItem singleItem = new SingleItem(obj);
+
+        this.addItem(singleItem);
+    }
+
     public void addValues(List<Object> objs) {
         AssertUtils.assertNotEmpty(objs, "cannot add a empty list into item.");
         for(Object obj: objs) {
@@ -97,6 +107,53 @@ public List<MultiItem> k_1Subset() {
         return subset;
     }
 
+    // 称以c个单值作为后件的候选规则为 c-候选规则，该方法生成该MultiItem的所有的 1-候选规则
+    public List<AssociationRule> a_1AssociationRules() {
+        List<AssociationRule> rules = new ArrayList<AssociationRule>(this.values.size());
+        for (int i=0; i<this.values.size(); i++) {
+            SingleItem afterItem = this.values.get(i);
+
+            List<SingleItem> frontItem = new ArrayList<SingleItem>(this.length-1);
+            for (int j=0; j<this.values.size(); j++) {
+                if (j != i) {
+                    frontItem.add(this.values.get(j));
+                }
+            }
+            AssociationRule rule = new AssociationRule(frontItem, afterItem);
+            rules.add(rule);
+        }
+        return rules;
+    }
+
+    // 该方法生成后件包含 items 的 (items.size()+1)-候选规则
+    public List<AssociationRule> a_kAssociationRules(List<SingleItem> items) {
+        if (null == items || items.isEmpty() || items.size() >= this.values.size()
+                || !this.values.containsAll(items))
+            return Collections.EMPTY_LIST;
+
+        List<SingleItem> otherItems = new ArrayList<SingleItem>(this.values);
+        otherItems.removeAll(items);
+
+        List<AssociationRule> rules = new ArrayList<AssociationRule>(this.values.size()-items.size());
+        for (int i=0; i<otherItems.size(); i++) {
+
+            List<SingleItem> afterItem = new ArrayList<SingleItem>(items.size()+1);
+            afterItem.addAll(items);
+            afterItem.add(otherItems.get(i));
+
+            List<SingleItem> frontItem = new ArrayList(otherItems.size()-1);
+            for (int j=0; j<otherItems.size(); j++) {
+                if (j != i) {
+                    frontItem.add(otherItems.get(j));
+                }
+            }
+            AssociationRule rule = new AssociationRule(frontItem, afterItem);
+            rules.add(rule);
+        }
+
+        return rules;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/apriori/example/Calculator.java

@@ -20,7 +20,7 @@ public class Calculator {
     private final static String BASE_PATH = "/Users/Boyce/GitProjects/Algorithm/src/apriori/example/";
 
     public static void main(String[] args) {
-        Transactions transactions = new Transactions(0.5, 0.4);
+        Transactions transactions = new Transactions(0.9, 0.4);
 
         File file = new File(BASE_PATH + "data/accidents.dat");
         List<String> lines = FileUtils.readLines(file);
@@ -56,5 +56,8 @@ public static void main(String[] args) {
         }
 
         System.out.println("calculate take: " + (System.currentTimeMillis()-start) + "ms");
+
+        System.out.println("rule: " + f.getParentItemset().rule_gen());
+
     }
 }