/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* PriorEstimation.java
* Copyright (C) 2004 University of Waikato, Hamilton, New Zealand
*
*/
package weka.associations;
import weka.core.Instances;
import weka.core.RevisionHandler;
import weka.core.RevisionUtils;
import weka.core.SpecialFunctions;
import weka.core.Utils;
import java.io.Serializable;
import java.util.Hashtable;
import java.util.Random;
/**
* Class implementing the prior estimattion of the predictive apriori algorithm
* for mining association rules.
*
* Reference: T. Scheffer (2001). <i>Finding Association Rules That Trade Support
* Optimally against Confidence</i>. Proc of the 5th European Conf.
* on Principles and Practice of Knowledge Discovery in Databases (PKDD'01),
* pp. 424-435. Freiburg, Germany: Springer-Verlag. <p>
*
* @author Stefan Mutter (mutter@cs.waikato.ac.nz)
* @version $Revision: 1.7 $ */
public class PriorEstimation
implements Serializable, RevisionHandler {
/** for serialization */
private static final long serialVersionUID = 5570863216522496271L;
/** The number of rnadom rules. */
protected int m_numRandRules;
/** The number of intervals. */
protected int m_numIntervals;
/** The random seed used for the random rule generation step. */
protected static final int SEED = 0;
/** The maximum number of attributes for which a prior can be estimated. */
protected static final int MAX_N = 1024;
/** The random number generator. */
protected Random m_randNum;
/** The instances for which association rules are mined. */
protected Instances m_instances;
/** Flag indicating whether standard association rules or class association rules are mined. */
protected boolean m_CARs;
/** Hashtable to store the confidence values of randomly generated rules. */
protected Hashtable m_distribution;
/** Hashtable containing the estimated prior probabilities. */
protected Hashtable m_priors;
/** Sums up the confidences of all rules with a certain length. */
protected double m_sum;
/** The mid points of the discrete intervals in which the interval [0,1] is divided. */
protected double[] m_midPoints;
/**
* Constructor
*
* @param instances the instances to be used for generating the associations
* @param numRules the number of random rules used for generating the prior
* @param numIntervals the number of intervals to discretise [0,1]
* @param car flag indicating whether standard or class association rules are mined
*/
public PriorEstimation(Instances instances,int numRules,int numIntervals,boolean car) {
m_instances = instances;
m_CARs = car;
m_numRandRules = numRules;
m_numIntervals = numIntervals;
m_randNum = m_instances.getRandomNumberGenerator(SEED);
}
/**
* Calculates the prior distribution.
*
* @exception Exception if prior can't be estimated successfully
*/
public final void generateDistribution() throws Exception{
boolean jump;
int i,maxLength = m_instances.numAttributes(), count =0,count1=0, ruleCounter;
int [] itemArray;
m_distribution = new Hashtable(maxLength*m_numIntervals);
RuleItem current;
ItemSet generate;
if(m_instances.numAttributes() == 0)
throw new Exception("Dataset has no attributes!");
if(m_instances.numAttributes() >= MAX_N)
throw new Exception("Dataset has to many attributes for prior estimation!");
if(m_instances.numInstances() == 0)
throw new Exception("Dataset has no instances!");
for (int h = 0; h < maxLength; h++) {
if (m_instances.attribute(h).isNumeric())
throw new Exception("Can't handle numeric attributes!");
}
if(m_numIntervals == 0 || m_numRandRules == 0)
throw new Exception("Prior initialisation impossible");
//calculate mid points for the intervals
midPoints();
//create random rules of length i and measure their support and if support >0 their confidence
for(i = 1;i <= maxLength; i++){
m_sum = 0;
int j = 0;
count = 0;
count1 = 0;
while(j < m_numRandRules){
count++;
jump =false;
if(!m_CARs){
itemArray = randomRule(maxLength,i,m_randNum);
current = splitItemSet(m_randNum.nextInt(i), itemArray);
}
else{
itemArray = randomCARule(maxLength,i,m_randNum);
current = addCons(itemArray);
}
int [] ruleItem = new int[maxLength];
for(int k =0; k < itemArray.length;k++){
if(current.m_premise.m_items[k] != -1)
ruleItem[k] = current.m_premise.m_items[k];
else
if(current.m_consequence.m_items[k] != -1)
ruleItem[k] = current.m_consequence.m_items[k];
else
ruleItem[k] = -1;
}
ItemSet rule = new ItemSet(ruleItem);
updateCounters(rule);
ruleCounter = rule.m_counter;
if(ruleCounter > 0)
jump =true;
updateCounters(current.m_premise);
j++;
if(jump){
buildDistribution((double)ruleCounter/(double)current.m_premise.m_counter, (double)i);
}
}
//normalize
if(m_sum > 0){
for(int w = 0; w < m_midPoints.length;w++){
String key = (String.valueOf(m_midPoints[w])).concat(String.valueOf((double)i));
Double oldValue = (Double)m_distribution.remove(key);
if(oldValue == null){
m_distribution.put(key,new Double(1.0/m_numIntervals));
m_sum += 1.0/m_numIntervals;
}
else
m_distribution.put(key,oldValue);
}
for(int w = 0; w < m_midPoints.length;w++){
double conf =0;
String key = (String.valueOf(m_midPoints[w])).concat(String.valueOf((double)i));
Double oldValue = (Double)m_distribution.remove(key);
if(oldValue != null){
conf = oldValue.doubleValue() / m_sum;
m_distribution.put(key,new Double(conf));
}
}
}
else{
for(int w = 0; w < m_midPoints.length;w++){
String key = (String.valueOf(m_midPoints[w])).concat(String.valueOf((double)i));
m_distribution.put(key,new Double(1.0/m_numIntervals));
}
}
}
}
/**
* Constructs an item set of certain length randomly.
* This method is used for standard association rule mining.
* @param maxLength the number of attributes of the instances
* @param actualLength the number of attributes that should be present in the item set
* @param randNum the random number generator
* @return a randomly constructed item set in form of an int array
*/
public final int[] randomRule(int maxLength, int actualLength, Random randNum){
int[] itemArray = new int[maxLength];
for(int k =0;k < itemArray.length;k++)
itemArray[k] = -1;
int help =actualLength;
if(help == maxLength){
help = 0;
for(int h = 0; h < itemArray.length; h++){
itemArray[h] = m_randNum.nextInt((m_instances.attribute(h)).numValues());
}
}
while(help > 0){
int mark = randNum.nextInt(maxLength);
if(itemArray[mark] == -1){
help--;
itemArray[mark] = m_randNum.nextInt((m_instances.attribute(mark)).numValues());
}
}
return itemArray;
}
/**
* Constructs an item set of certain length randomly.
* This method is used for class association rule mining.
* @param maxLength the number of attributes of the instances
* @param actualLength the number of attributes that should be present in the item set
* @param randNum the random number generator
* @return a randomly constructed item set in form of an int array
*/
public final int[] randomCARule(int maxLength, int actualLength, Random randNum){
int[] itemArray = new int[maxLength];
for(int k =0;k < itemArray.length;k++)
itemArray[k] = -1;
if(actualLength == 1)
return itemArray;
int help =actualLength-1;
if(help == maxLength-1){
help = 0;
for(int h = 0; h < itemArray.length; h++){
if(h != m_instances.classIndex()){
itemArray[h] = m_randNum.nextInt((m_instances.attribute(h)).numValues());
}
}
}
while(help > 0){
int mark = randNum.nextInt(maxLength);
if(itemArray[mark] == -1 && mark != m_instances.classIndex()){
help--;
itemArray[mark] = m_randNum.nextInt((m_instances.attribute(mark)).numValues());
}
}
return itemArray;
}
/**
* updates the distribution of the confidence values.
* For every confidence value the interval to which it belongs is searched
* and the confidence is added to the confidence already found in this
* interval.
* @param conf the confidence of the randomly created rule
* @param length the legnth of the randomly created rule
*/
public final void buildDistribution(double conf, double length){
double mPoint = findIntervall(conf);
String key = (String.valueOf(mPoint)).concat(String.valueOf(length));
m_sum += conf;
Double oldValue = (Double)m_distribution.remove(key);
if(oldValue != null)
conf = conf + oldValue.doubleValue();
m_distribution.put(key,new Double(conf));
}
/**
* searches the mid point of the interval a given confidence value falls into
* @param conf the confidence of a rule
* @return the mid point of the interval the confidence belongs to
*/
public final double findIntervall(double conf){
if(conf == 1.0)
return m_midPoints[m_midPoints.length-1];
int end = m_midPoints.length-1;
int start = 0;
while (Math.abs(end-start) > 1) {
int mid = (start + end) / 2;
if (conf > m_midPoints[mid])
start = mid+1;
if (conf < m_midPoints[mid])
end = mid-1;
if(conf == m_midPoints[mid])
return m_midPoints[mid];
}
if(Math.abs(conf-m_midPoints[start]) <= Math.abs(conf-m_midPoints[end]))
return m_midPoints[start];
else
return m_midPoints[end];
}
/**
* calculates the numerator and the denominator of the prior equation
* @param weighted indicates whether the numerator or the denominator is calculated
* @param mPoint the mid Point of an interval
* @return the numerator or denominator of the prior equation
*/
public final double calculatePriorSum(boolean weighted, double mPoint){
double distr, sum =0, max = logbinomialCoefficient(m_instances.numAttributes(),(int)m_instances.numAttributes()/2);
for(int i = 1; i <= m_instances.numAttributes(); i++){
if(weighted){
String key = (String.valueOf(mPoint)).concat(String.valueOf((double)i));
Double hashValue = (Double)m_distribution.get(key);
if(hashValue !=null)
distr = hashValue.doubleValue();
else
distr = 0;
//distr = 1.0/m_numIntervals;
if(distr != 0){
double addend = Utils.log2(distr) - max + Utils.log2((Math.pow(2,i)-1)) + logbinomialCoefficient(m_instances.numAttributes(),i);
sum = sum + Math.pow(2,addend);
}
}
else{
double addend = Utils.log2((Math.pow(2,i)-1)) - max + logbinomialCoefficient(m_instances.numAttributes(),i);
sum = sum + Math.pow(2,addend);
}
}
return sum;
}
/**
* Method that calculates the base 2 logarithm of a binomial coefficient
* @param upperIndex upper Inedx of the binomial coefficient
* @param lowerIndex lower index of the binomial coefficient
* @return the base 2 logarithm of the binomial coefficient
*/
public static final double logbinomialCoefficient(int upperIndex, int lowerIndex){
double result =1.0;
if(upperIndex == lowerIndex || lowerIndex == 0)
return result;
result = SpecialFunctions.log2Binomial((double)upperIndex, (double)lowerIndex);
return result;
}
/**
* Method to estimate the prior probabilities
* @throws Exception throws exception if the prior cannot be calculated
* @return a hashtable containing the prior probabilities
*/
public final Hashtable estimatePrior() throws Exception{
double distr, prior, denominator, mPoint;
Hashtable m_priors = new Hashtable(m_numIntervals);
denominator = calculatePriorSum(false,1.0);
generateDistribution();
for(int i = 0; i < m_numIntervals; i++){
mPoint = m_midPoints[i];
prior = calculatePriorSum(true,mPoint) / denominator;
m_priors.put(new Double(mPoint), new Double(prior));
}
return m_priors;
}
/**
* split the interval [0,1] into a predefined number of intervals and calculates their mid points
*/
public final void midPoints(){
m_midPoints = new double[m_numIntervals];
for(int i = 0; i < m_numIntervals; i++)
m_midPoints[i] = midPoint(1.0/m_numIntervals, i);
}
/**
* calculates the mid point of an interval
* @param size the size of each interval
* @param number the number of the interval.
* The intervals are numbered from 0 to m_numIntervals.
* @return the mid point of the interval
*/
public double midPoint(double size, int number){
return (size * (double)number) + (size / 2.0);
}
/**
* returns an ordered array of all mid points
* @return an ordered array of doubles conatining all midpoints
*/
public final double[] getMidPoints(){
return m_midPoints;
}
/**
* splits an item set into premise and consequence and constructs therefore
* an association rule. The length of the premise is given. The attributes
* for premise and consequence are chosen randomly. The result is a RuleItem.
* @param premiseLength the length of the premise
* @param itemArray a (randomly generated) item set
* @return a randomly generated association rule stored in a RuleItem
*/
public final RuleItem splitItemSet (int premiseLength, int[] itemArray){
int[] cons = new int[m_instances.numAttributes()];
System.arraycopy(itemArray, 0, cons, 0, itemArray.length);
int help = premiseLength;
while(help > 0){
int mark = m_randNum.nextInt(itemArray.length);
if(cons[mark] != -1){
help--;
cons[mark] =-1;
}
}
if(premiseLength == 0)
for(int i =0; i < itemArray.length;i++)
itemArray[i] = -1;
else
for(int i =0; i < itemArray.length;i++)
if(cons[i] != -1)
itemArray[i] = -1;
ItemSet premise = new ItemSet(itemArray);
ItemSet consequence = new ItemSet(cons);
RuleItem current = new RuleItem();
current.m_premise = premise;
current.m_consequence = consequence;
return current;
}
/**
* generates a class association rule out of a given premise.
* It randomly chooses a class label as consequence.
* @param itemArray the (randomly constructed) premise of the class association rule
* @return a class association rule stored in a RuleItem
*/
public final RuleItem addCons (int[] itemArray){
ItemSet premise = new ItemSet(itemArray);
int[] cons = new int[itemArray.length];
for(int i =0;i < itemArray.length;i++)
cons[i] = -1;
cons[m_instances.classIndex()] = m_randNum.nextInt((m_instances.attribute(m_instances.classIndex())).numValues());
ItemSet consequence = new ItemSet(cons);
RuleItem current = new RuleItem();
current.m_premise = premise;
current.m_consequence = consequence;
return current;
}
/**
* updates the support count of an item set
* @param itemSet the item set
*/
public final void updateCounters(ItemSet itemSet){
for (int i = 0; i < m_instances.numInstances(); i++)
itemSet.upDateCounter(m_instances.instance(i));
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 1.7 $");
}
}