关联分析-Apriori算法Java实现 支持度+置信度（2）

=========补充了关联规则的生成======== 比想象的要麻烦一点

关联规则可以是双向的，confidence(A-->B)=P(A|B)=support(A&B)/support(A)

所以在计算k项集的关联规则时，其分母都是k项集的支持度，分子为k-1项集的支持度，以及对应1项集的支持度

001 /**
002  *
003  */
004 package org.waitingfortime.datamining.association;
005
006 import java.io.BufferedReader;
007 import java.io.File;
008 import java.io.FileNotFoundException;
009 import java.io.FileOutputStream;
010 import java.io.FileReader;
011 import java.io.IOException;
012 import java.io.PrintStream;
013 import java.util.ArrayList;
014 import java.util.HashMap;
015 import java.util.Iterator;
016 import java.util.List;
017 import java.util.Map;
018 import java.util.Set;
019 import java.util.TreeSet;
020
021 /**
022  * @author mazhiyuan
023  *
024  */
025 public class Apriori {
026     private int minNum;// 最小支持数
027     private double minCon;// 最小置信度
028     private List> records;// 原始数据
029     private String output;// 输出路径
030     private List> result = new ArrayList>();// 频繁项集结果
031     private List fth;// 频繁1项集
032
033     public Apriori(double minDegree, double minCon, String input, String output) {
034         this.output = output;
035         this.minCon = minCon;
036         init(input);
037         if (records.size() == 0) {
038             System.err.println("不符合计算条件。退出！");
039             System.exit(1);
040         }
041         minNum = (int) (minDegree * records.size());
042     }
043
044     private void init(String path) {
045         // TODO Auto-generated method stub
046         records = new ArrayList>();
047         try {
048             BufferedReader br = new BufferedReader(new FileReader(
049                     new File(path)));
050
051             String line = null;
052             Set record;
053             while ((line = br.readLine()) != null) {
054                 if (!"".equals(line.trim())) {
055                     record = new TreeSet();
056                     String[] items = line.split(" ");
057                     for (String item : items) {
058                         record.add(Integer.valueOf(item));
059                     }
060                     records.add(record);
061                 }
062             }
063
064             br.close();
065         } catch (IOException e) {
066             System.err.println("读取事务文件失败。");
067         }
068     }
069
070     private void first() {
071         // TODO Auto-generated method stub
072         fth = new ArrayList();
073         Map first = new HashMap();
074         for (Set si : records)
075             for (Integer i : si) {
076                 if (first.get(i) == null)
077                     first.put(i, 1);
078                 else
079                     first.put(i, first.get(i) + 1);
080             }
081
082         for (Integer i : first.keySet())
083             if (first.get(i) >= minNum)
084                 fth.add(new ItemSet(i, first.get(i)));
085
086     }
087
088     private void loop(List items) {
089         // TODO Auto-generated method stub
090         List copy = new ArrayList(items);
091         List res = new ArrayList();
092         int size = items.size();
093
094         // 连接
095         for (int i = 0; i < size; i++)
096             for (int j = i + 1; j < size; j++)
097                 if (copy.get(i).isMerge(copy.get(j))) {
098                     ItemSet is = new ItemSet(copy.get(i));
099                     is.merge(copy.get(j).item.last());
100                     res.add(is);
101                 }
102         // 剪枝
103         pruning(copy, res);
104
105         if (res.size() != 0) {
106             result.add(res);
107             loop(res);
108         }
109     }
110
111     private void pruning(List pre, List res) {
112         // TODO Auto-generated method stub
113         // step 1 k项集的子集属于k-1项集
114         Iterator ir = res.iterator();
115         while (ir.hasNext()) {
116             // 获取所有k-1项子集
117             ItemSet now = ir.next();
118             Map> ss = subSet(now);
119             // 判断是否在pre集中
120             boolean flag = false;
121             for (List li : ss.values()) {
122                 if (flag)
123                     break;
124                 for (ItemSet pis : pre) {
125                     if (pis.item.containsAll(li)) {
126                         flag = false;
127                         break;
128                     }
129                     flag = true;
130                 }
131             }
132             if (flag) {
133                 ir.remove();
134                 continue;
135             }
136             // step 2 支持度
137             int i = 0;
138             for (Set sr : records) {
139                 if (sr.containsAll(now.item))
140                     i++;
141
142                 now.support = i;
143             }
144             if (now.support < minNum) {
145                 ir.remove();
146                 continue;
147             }
148             // 产生关联规则
149             double deno = now.support;
150             for (Map.Entry> me : ss.entrySet()) {
151                 ItemCon ic = new ItemCon(me.getKey(), me.getValue());
152                 int nume = 0;
153
154                 for (ItemSet f : fth)
155                     if (f.item.contains(me.getKey())) {
156                         nume = f.support;
157                         break;
158                     }
159                 if (deno / nume > minCon) {
160                     now.calcon(ic);
161                     ic.setC1(deno / nume);
162                 }
163                 for (ItemSet pis : pre)
164                     if (pis.item.size() == me.getValue().size()
165                             && pis.item.containsAll(me.getValue())) {
166                         nume = pis.support;
167                         break;
168                     }
169                 if (deno / nume > minCon)
170                     ic.setC2(deno / nume);
171             }
172         }
173     }
174
175     private Map> subSet(ItemSet is) {
176         // TODO Auto-generated method stub
177         List li = new ArrayList(is.item);
178         Map> res = new HashMap>();
179         for (int i = 0, j = li.size(); i < j; i++) {
180             List _li = new ArrayList(li);
181             _li.remove(i);
182             res.put(li.get(i), _li);
183         }
184