| package mining; |
| |
| import java.io.*; |
| import java.util.*; |
| |
| /** The class encapsulates an implementation of the Apriori algorithm |
| * to compute frequent itemsets. |
| * |
| * Datasets contains integers (>=0) separated by spaces, one transaction by line, e.g. |
| * 1 2 3 |
| * 0 9 |
| * 1 9 |
| * |
| * Usage with the command line : |
| * $ java mining.Apriori fileName support |
| * $ java mining.Apriori /tmp/data.dat 0.8 |
| * $ java mining.Apriori /tmp/data.dat 0.8 > frequent-itemsets.txt |
| * |
| * Usage as library: see {@link ExampleOfClientCodeOfApriori} |
| * |
| * @author Martin Monperrus, University of Darmstadt, 2010 |
| * @author Nathan Magnus and Su Yibin, under the supervision of Howard Hamilton, University of Regina, June 2009. |
| * GNU General Public License v3 |
| * No reproduction in whole or part without maintaining this copyright notice |
| * and imposing this condition on any subsequent users. |
| */ |
| public class Apriori extends Observable { |
| |
| |
| public static void main(String[] args) throws Exception { |
| Apriori ap = new Apriori(args); |
| } |
| |
| /** the list of current itemsets */ |
| private List<int[]> itemsets ; |
| /** the name of the transcation file */ |
| private String transaFile="transa.txt"; |
| /** number of different items in the dataset */ |
| private int numItems; |
| /** total number of transactions in transaFile */ |
| private int numTransactions; |
| /** minimum support for a frequent itemset in percentage, e.g. 0.8 */ |
| private double minSup; |
| |
| private boolean usedAsLibrary = false; |
| |
| /** This is the main interface to use this class as a library */ |
| public Apriori(String[] args, Observer ob) throws Exception |
| { |
| usedAsLibrary = true; |
| configure(args); |
| this.addObserver(ob); |
| go(); |
| } |
| |
| /** generates the apriori itemsets from a file |
| * |
| * @param args configuration parameters: args[0] is a filename, args[1] the min support (e.g. 0.8 for 80%) |
| */ |
| public Apriori(String[] args) throws Exception |
| { |
| configure(args); |
| go(); |
| } |
| |
| /** starts the algorithm after configuration */ |
| private void go() throws Exception { |
| //start timer |
| long start = System.currentTimeMillis(); |
| |
| // first we generate the candidates of size 1 |
| createItemetsOfSize1(); |
| int itemsetNumber=1; //the current itemset being looked at |
| int nbFrequentSets=0; |
| |
| while (itemsets.size()>0) |
| { |
| |
| calculateFrequentItemsets(); |
| |
| if(itemsets.size()!=0) |
| { |
| nbFrequentSets+=itemsets.size(); |
| log("Found "+itemsets.size()+" frequent itemsets of size " + itemsetNumber + " (with support "+(minSup*100)+"%)");; |
| createNewItemsetsFromPreviousOnes(); |
| } |
| |
| itemsetNumber++; |
| } |
| |
| //display the execution time |
| long end = System.currentTimeMillis(); |
| log("Execution time is: "+((double)(end-start)/1000) + " seconds."); |
| log("Found "+nbFrequentSets+ " frequents sets for support "+(minSup*100)+"% (absolute "+Math.round(numTransactions*minSup)+")"); |
| log("Done"); |
| } |
| |
| /** triggers actions if a frequent item set has been found */ |
| private void foundFrequentItemSet(int[] itemset, int support) { |
| if (usedAsLibrary) { |
| this.setChanged(); |
| notifyObservers(itemset); |
| } |
| else {System.out.println(Arrays.toString(itemset) + " ("+ ((support / (double) numTransactions))+" "+support+")");} |
| } |
| |
| /** outputs a message in Sys.err if not used as library */ |
| private void log(String message) { |
| if (!usedAsLibrary) { |
| System.err.println(message); |
| } |
| } |
| |
| /** computes numItems, numTransactions, and sets minSup */ |
| private void configure(String[] args) throws Exception |
| { |
| // setting transafile |
| if (args.length!=0) transaFile = args[0]; |
| else transaFile = "chess.dat"; // default |
| |
| // setting minsupport |
| if (args.length>=2) minSup=(Double.valueOf(args[1]).doubleValue()); |
| else minSup = .8;// by default |
| if (minSup>1 || minSup<0) throw new Exception("minSup: bad value"); |
| |
| |
| // going thourgh the file to compute numItems and numTransactions |
| numItems = 0; |
| numTransactions=0; |
| BufferedReader data_in = new BufferedReader(new FileReader(transaFile)); |
| while (data_in.ready()) { |
| String line=data_in.readLine(); |
| if (line.matches("//s*")) continue; // be friendly with empty lines |
| numTransactions++; |
| StringTokenizer t = new StringTokenizer(line," "); |
| while (t.hasMoreTokens()) { |
| int x = Integer.parseInt(t.nextToken()); |
| //log(x); |
| if (x+1>numItems) numItems=x+1; |
| } |
| } |
| |
| outputConfig(); |
| |
| } |
| |
| /** outputs the current configuration |
| */ |
| private void outputConfig() { |
| //output config info to the user |
| log("Input configuration: "+numItems+" items, "+numTransactions+" transactions, "); |
| log("minsup = "+minSup+"%"); |
| } |
| |
| /** puts in itemsets all sets of size 1, |
| * i.e. all possibles items of the datasets |
| */ |
| private void createItemetsOfSize1() { |
| itemsets = new ArrayList<int[]>(); |
| for(int i=0; i<numItems; i++) |
| { |
| int[] cand = {i}; |
| itemsets.add(cand); |
| } |
| } |
| |
| /** |
| * if m is the size of the current itemsets, |
| * generate all possible itemsets of size n+1 from pairs of current itemsets |
| * replaces the itemsets of itemsets by the new ones |
| */ |
| private void createNewItemsetsFromPreviousOnes() |
| { |
| // by construction, all existing itemsets have the same size |
| int currentSizeOfItemsets = itemsets.get(0).length; |
| log("Creating itemsets of size "+(currentSizeOfItemsets+1)+" based on "+itemsets.size()+" itemsets of size "+currentSizeOfItemsets); |
| |
| HashMap<String, int[]> tempCandidates = new HashMap<String, int[]>(); //temporary candidates |
| |
| // compare each pair of itemsets of size n-1 |
| for(int i=0; i<itemsets.size(); i++) |
| { |
| for(int j=i+1; j<itemsets.size(); j++) |
| { |
| int[] X = itemsets.get(i); |
| int[] Y = itemsets.get(j); |
| |
| assert (X.length==Y.length); |
| |
| //make a string of the first n-2 tokens of the strings |
| int [] newCand = new int[currentSizeOfItemsets+1]; |
| for(int s=0; s<newCand.length-1; s++) { |
| newCand[s] = X[s]; |
| } |
| |
| int ndifferent = 0; |
| // then we find the missing value |
| for(int s1=0; s1<Y.length; s1++) |
| { |
| boolean found = false; |
| // is Y[s1] in X? |
| for(int s2=0; s2<X.length; s2++) { |
| if (X[s2]==Y[s1]) { |
| found = true; |
| break; |
| } |
| } |
| if (!found){ // Y[s1] is not in X |
| ndifferent++; |
| // we put the missing value at the end of newCand |
| newCand[newCand.length -1] = Y[s1]; |
| } |
| |
| } |
| |
| // we have to find at least 1 different, otherwise it means that we have two times the same set in the existing candidates |
| assert(ndifferent>0); |
| |
| |
| if (ndifferent==1) { |
| // HashMap does not have the correct "equals" for int[] :-( |
| // I have to create the hash myself using a String :-( |
| // I use Arrays.toString to reuse equals and hashcode of String |
| Arrays.sort(newCand); |
| tempCandidates.put(Arrays.toString(newCand),newCand); |
| } |
| } |
| } |
| |
| //set the new itemsets |
| itemsets = new ArrayList<int[]>(tempCandidates.values()); |
| log("Created "+itemsets.size()+" unique itemsets of size "+(currentSizeOfItemsets+1)); |
| |
| } |
| |
| |
| |
| /** put "true" in trans[i] if the integer i is in line */ |
| private void line2booleanArray(String line, boolean[] trans) { |
| Arrays.fill(trans, false); |
| StringTokenizer stFile = new StringTokenizer(line, " "); //read a line from the file to the tokenizer |
| //put the contents of that line into the transaction array |
| while (stFile.hasMoreTokens()) |
| { |
| |
| int parsedVal = Integer.parseInt(stFile.nextToken()); |
| trans[parsedVal]=true; //if it is not a 0, assign the value to true |
| } |
| } |
| |
| |
| /** passes through the data to measure the frequency of sets in {@link itemsets}, |
| * then filters thoses who are under the minimum support (minSup) |
| */ |
| private void calculateFrequentItemsets() throws Exception |
| { |
| |
| log("Passing through the data to compute the frequency of " + itemsets.size()+ " itemsets of size "+itemsets.get(0).length); |
| |
| List<int[]> frequentCandidates = new ArrayList<int[]>(); //the frequent candidates for the current itemset |
| |
| boolean match; //whether the transaction has all the items in an itemset |
| int count[] = new int[itemsets.size()]; //the number of successful matches, initialized by zeros |
| |
| |
| // load the transaction file |
| BufferedReader data_in = new BufferedReader(new InputStreamReader(new FileInputStream(transaFile))); |
| |
| boolean[] trans = new boolean[numItems]; |
| |
| // for each transaction |
| for (int i = 0; i < numTransactions; i++) { |
| |
| // boolean[] trans = extractEncoding1(data_in.readLine()); |
| String line = data_in.readLine(); |
| line2booleanArray(line, trans); |
| |
| // check each candidate |
| for (int c = 0; c < itemsets.size(); c++) { |
| match = true; // reset match to false |
| // tokenize the candidate so that we know what items need to be |
| // present for a match |
| int[] cand = itemsets.get(c); |
| //int[] cand = candidatesOptimized[c]; |
| // check each item in the itemset to see if it is present in the |
| // transaction |
| for (int xx : cand) { |
| if (trans[xx] == false) { |
| match = false; |
| break; |
| } |
| } |
| if (match) { // if at this point it is a match, increase the count |
| count[c]++; |
| //log(Arrays.toString(cand)+" is contained in trans "+i+" ("+line+")"); |
| } |
| } |
| |
| } |
| |
| data_in.close(); |
| |
| for (int i = 0; i < itemsets.size(); i++) { |
| // if the count% is larger than the minSup%, add to the candidate to |
| // the frequent candidates |
| if ((count[i] / (double) (numTransactions)) >= minSup) { |
| foundFrequentItemSet(itemsets.get(i),count[i]); |
| frequentCandidates.add(itemsets.get(i)); |
| } |
| //else log("-- Remove candidate: "+ Arrays.toString(candidates.get(i)) + " is: "+ ((count[i] / (double) numTransactions))); |
| } |
| |
| //new candidates are only the frequent candidates |
| itemsets = frequentCandidates; |
| } |
| } |
