Example usage for weka.core ContingencyTables chiSquared

Introduction

In this page you can find the example usage for weka.core ContingencyTables chiSquared.

Prototype

public static double chiSquared(double[][] matrix, boolean yates) 

Source Link

Document

Returns chi-squared probability for a given matrix.

Usage

From source file:cba.AprioriItemSet.java

License:Open Source License

/**
 * Generates all significant rules for an item set.
 *
 * @param minMetric the minimum metric (confidence, lift, leverage, 
 * improvement) the rules have to have// ww  w  .j a  v  a2  s  . com
 * @param metricType (confidence=0, lift, leverage, improvement)
 * @param hashtables containing all(!) previously generated
 * item sets
 * @param numItemsInSet the size of the item set for which the rules
 * are to be generated
 * @param numTransactions
 * @param significanceLevel the significance level for testing the rules
 * @return all the rules with minimum metric for the given item set
 * @exception Exception if something goes wrong
 */
public final FastVector[] generateRulesBruteForce(double minMetric, int metricType, FastVector hashtables,
        int numItemsInSet, int numTransactions, double significanceLevel) throws Exception {

    FastVector premises = new FastVector(), consequences = new FastVector(), conf = new FastVector(),
            lift = new FastVector(), lev = new FastVector(), conv = new FastVector();
    FastVector[] rules = new FastVector[6];
    AprioriItemSet premise, consequence;
    Hashtable hashtableForPremise, hashtableForConsequence;
    int numItemsInPremise, help, max, consequenceUnconditionedCounter;
    double[][] contingencyTable = new double[2][2];
    double metric, chiSquared;

    // Generate all possible rules for this item set and test their
    // significance.
    max = (int) Math.pow(2, numItemsInSet);
    for (int j = 1; j < max; j++) {
        numItemsInPremise = 0;
        help = j;
        while (help > 0) {
            if (help % 2 == 1)
                numItemsInPremise++;
            help /= 2;
        }
        if (numItemsInPremise < numItemsInSet) {
            hashtableForPremise = (Hashtable) hashtables.elementAt(numItemsInPremise - 1);
            hashtableForConsequence = (Hashtable) hashtables.elementAt(numItemsInSet - numItemsInPremise - 1);
            premise = new AprioriItemSet(m_totalTransactions);
            consequence = new AprioriItemSet(m_totalTransactions);
            premise.m_items = new int[m_items.length];

            consequence.m_items = new int[m_items.length];
            consequence.m_counter = m_counter;
            help = j;
            for (int i = 0; i < m_items.length; i++)
                if (m_items[i] != -1) {
                    if (help % 2 == 1) {
                        premise.m_items[i] = m_items[i];
                        consequence.m_items[i] = -1;
                    } else {
                        premise.m_items[i] = -1;
                        consequence.m_items[i] = m_items[i];
                    }
                    help /= 2;
                } else {
                    premise.m_items[i] = -1;
                    consequence.m_items[i] = -1;
                }
            premise.m_counter = ((Integer) hashtableForPremise.get(premise)).intValue();
            consequenceUnconditionedCounter = ((Integer) hashtableForConsequence.get(consequence)).intValue();

            if (metricType == 0) {
                contingencyTable[0][0] = (double) (consequence.m_counter);
                contingencyTable[0][1] = (double) (premise.m_counter - consequence.m_counter);
                contingencyTable[1][0] = (double) (consequenceUnconditionedCounter - consequence.m_counter);
                contingencyTable[1][1] = (double) (numTransactions - premise.m_counter
                        - consequenceUnconditionedCounter + consequence.m_counter);
                chiSquared = ContingencyTables.chiSquared(contingencyTable, false);

                metric = confidenceForRule(premise, consequence);

                if ((!(metric < minMetric)) && (!(chiSquared > significanceLevel))) {
                    premises.addElement(premise);
                    consequences.addElement(consequence);
                    conf.addElement(new Double(metric));
                    lift.addElement(
                            new Double(liftForRule(premise, consequence, consequenceUnconditionedCounter)));
                    lev.addElement(new Double(leverageForRule(premise, consequence, premise.m_counter,
                            consequenceUnconditionedCounter)));
                    conv.addElement(new Double(convictionForRule(premise, consequence, premise.m_counter,
                            consequenceUnconditionedCounter)));
                }
            } else {
                double tempConf = confidenceForRule(premise, consequence);
                double tempLift = liftForRule(premise, consequence, consequenceUnconditionedCounter);
                double tempLev = leverageForRule(premise, consequence, premise.m_counter,
                        consequenceUnconditionedCounter);
                double tempConv = convictionForRule(premise, consequence, premise.m_counter,
                        consequenceUnconditionedCounter);
                switch (metricType) {
                case 1:
                    metric = tempLift;
                    break;
                case 2:
                    metric = tempLev;
                    break;
                case 3:
                    metric = tempConv;
                    break;
                default:
                    throw new Exception("ItemSet: Unknown metric type!");
                }
                if (!(metric < minMetric)) {
                    premises.addElement(premise);
                    consequences.addElement(consequence);
                    conf.addElement(new Double(tempConf));
                    lift.addElement(new Double(tempLift));
                    lev.addElement(new Double(tempLev));
                    conv.addElement(new Double(tempConv));
                }
            }
        }
    }
    rules[0] = premises;
    rules[1] = consequences;
    rules[2] = conf;
    rules[3] = lift;
    rules[4] = lev;
    rules[5] = conv;
    return rules;
}

---