"));
+ return newVector.elements();
+ }
+
+
+/**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -N <required number of rules output>
+ * The required number of rules. (default = 100)
+ *
+ * -A
+ * If set class association rules are mined. (default = no)
+ *
+ * -c <the class index>
+ * The class index. (default = last)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String[] options) throws Exception {
+
+ resetOptions();
+
+ String numRulesString = Utils.getOption('N', options);
+ if (numRulesString.length() != 0)
+ m_numRules = Integer.parseInt(numRulesString)+5;
+ else
+ m_numRules = Integer.MAX_VALUE;
+
+ String classIndexString = Utils.getOption('c',options);
+ if (classIndexString.length() != 0)
+ m_classIndex = Integer.parseInt(classIndexString);
+
+ m_car = Utils.getFlag('A', options);
+ }
+
+ /**
+ * Gets the current settings of the PredictiveApriori object.
+ *
+ * @return an array of strings suitable for passing to setOptions
+ */
+ public String [] getOptions() {
+ Vector result;
+
+ result = new Vector();
+
+ result.add("-N");
+ result.add("" + (m_numRules-5));
+
+ if (m_car)
+ result.add("-A");
+
+ result.add("-c");
+ result.add("" + m_classIndex);
+
+ return (String[]) result.toArray(new String[result.size()]);
+ }
+
+
+ /**
+ * Outputs the association rules.
+ *
+ * @return a string representation of the model
+ */
+ public String toString() {
+
+ StringBuffer text = new StringBuffer();
+
+ if (m_allTheRules[0].size() == 0)
+ return "\nNo large itemsets and rules found!\n";
+ text.append("\nPredictiveApriori\n===================\n\n");
+ text.append("\nBest rules found:\n\n");
+
+ for (int i = 0; i < m_allTheRules[0].size(); i++) {
+ text.append(Utils.doubleToString((double)i+1,
+ (int)(Math.log(m_numRules)/Math.log(10)+1),0)+
+ ". " + ((ItemSet)m_allTheRules[0].elementAt(i)).
+ toString(m_instances)
+ + " ==> " + ((ItemSet)m_allTheRules[1].elementAt(i)).
+ toString(m_instances) +" acc:("+
+ Utils.doubleToString(((Double)m_allTheRules[2].
+ elementAt(i)).doubleValue(),5)+")");
+
+ text.append('\n');
+ }
+
+
+ return text.toString();
+ }
+
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String numRulesTipText() {
+ return "Number of rules to find.";
+ }
+
+ /**
+ * Get the value of the number of required rules.
+ *
+ * @return Value of the number of required rules.
+ */
+ public int getNumRules() {
+
+ return m_numRules-5;
+ }
+
+ /**
+ * Set the value of required rules.
+ *
+ * @param v Value to assign to number of required rules.
+ */
+ public void setNumRules(int v) {
+
+ m_numRules = v+5;
+ }
+
+ /**
+ * Sets the class index
+ * @param index the index of the class attribute
+ */
+ public void setClassIndex(int index){
+
+ m_classIndex = index;
+ }
+
+ /**
+ * Gets the index of the class attribute
+ * @return the index of the class attribute
+ */
+ public int getClassIndex(){
+
+ return m_classIndex;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String classIndexTipText() {
+ return "Index of the class attribute.\n If set to -1, the last attribute will be taken as the class attribute.";
+ }
+
+ /**
+ * Sets class association rule mining
+ * @param flag if class association rules are mined, false otherwise
+ */
+ public void setCar(boolean flag){
+
+ m_car = flag;
+ }
+
+ /**
+ * Gets whether class association ruels are mined
+ * @return true if class association rules are mined, false otherwise
+ */
+ public boolean getCar(){
+
+ return m_car;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String carTipText() {
+ return "If enabled class association rules are mined instead of (general) association rules.";
+ }
+
+ /**
+ * Returns the metric string for the chosen metric type.
+ * Predictive apriori uses the estimated predictive accuracy.
+ * Therefore the metric string is "acc".
+ * @return string "acc"
+ */
+ public String metricString() {
+
+ return "acc";
+ }
+
+
+ /**
+ * Method that finds all large itemsets for the given set of instances.
+ *
+ * @param index the instances to be used
+ * @throws Exception if an attribute is numeric
+ */
+ private void findLargeItemSets(int index) throws Exception {
+
+ FastVector kMinusOneSets, kSets = new FastVector();
+ Hashtable hashtable;
+ int i = 0;
+ // Find large itemsets
+ //of length 1
+ if(index == 1){
+ kSets = ItemSet.singletons(m_instances);
+ ItemSet.upDateCounters(kSets, m_instances);
+ kSets = ItemSet.deleteItemSets(kSets, m_premiseCount,Integer.MAX_VALUE);
+ if (kSets.size() == 0)
+ return;
+ m_Ls.addElement(kSets);
+ }
+ //of length > 1
+ if(index >1){
+ if(m_Ls.size() > 0)
+ kSets = (FastVector)m_Ls.lastElement();
+ m_Ls.removeAllElements();
+ i = index-2;
+ kMinusOneSets = kSets;
+ kSets = ItemSet.mergeAllItemSets(kMinusOneSets, i, m_instances.numInstances());
+ hashtable = ItemSet.getHashtable(kMinusOneSets, kMinusOneSets.size());
+ m_hashtables.addElement(hashtable);
+ kSets = ItemSet.pruneItemSets(kSets, hashtable);
+ ItemSet.upDateCounters(kSets, m_instances);
+ kSets = ItemSet.deleteItemSets(kSets, m_premiseCount,Integer.MAX_VALUE);
+ if(kSets.size() == 0)
+ return;
+ m_Ls.addElement(kSets);
+ }
+ }
+
+
+
+
+ /**
+ * Method that finds all association rules.
+ *
+ * @throws Exception if an attribute is numeric
+ */
+ private void findRulesQuickly() throws Exception {
+
+ RuleGeneration currentItemSet;
+
+ // Build rules
+ for (int j = 0; j < m_Ls.size(); j++) {
+ FastVector currentItemSets = (FastVector)m_Ls.elementAt(j);
+ Enumeration enumItemSets = currentItemSets.elements();
+ while (enumItemSets.hasMoreElements()) {
+ currentItemSet = new RuleGeneration((ItemSet)enumItemSets.nextElement());
+ m_best = currentItemSet.generateRules(m_numRules-5, m_midPoints,m_priors,m_expectation,
+ m_instances,m_best,m_count);
+
+ m_count = currentItemSet.m_count;
+ if(!m_bestChanged && currentItemSet.m_change)
+ m_bestChanged = true;
+ //update minimum expected predictive accuracy to get into the n best
+ if(m_best.size() >= m_numRules-5)
+ m_expectation = ((RuleItem)m_best.first()).accuracy();
+ else m_expectation =0;
+ }
+ }
+ }
+
+
+ /**
+ * Method that finds all large itemsets for class association rule mining for the given set of instances.
+ * @param index the size of the large item sets
+ * @throws Exception if an attribute is numeric
+ */
+ private void findLargeCarItemSets(int index) throws Exception {
+
+ FastVector kMinusOneSets, kSets = new FastVector();
+ Hashtable hashtable;
+ int i = 0;
+ // Find large itemsets
+ if(index == 1){
+ kSets = CaRuleGeneration.singletons(m_instances);
+ ItemSet.upDateCounters(kSets, m_instances);
+ kSets = ItemSet.deleteItemSets(kSets, m_premiseCount,Integer.MAX_VALUE);
+ if (kSets.size() == 0)
+ return;
+ m_Ls.addElement(kSets);
+ }
+
+ if(index >1){
+ if(m_Ls.size() > 0)
+ kSets = (FastVector)m_Ls.lastElement();
+ m_Ls.removeAllElements();
+ i = index-2;
+ kMinusOneSets = kSets;
+ kSets = ItemSet.mergeAllItemSets(kMinusOneSets, i, m_instances.numInstances());
+ hashtable = ItemSet.getHashtable(kMinusOneSets, kMinusOneSets.size());
+ m_hashtables.addElement(hashtable);
+ kSets = ItemSet.pruneItemSets(kSets, hashtable);
+ ItemSet.upDateCounters(kSets, m_instances);
+ kSets = ItemSet.deleteItemSets(kSets, m_premiseCount,Integer.MAX_VALUE);
+ if(kSets.size() == 0)
+ return;
+ m_Ls.addElement(kSets);
+ }
+ }
+
+ /**
+ * Method that finds all class association rules.
+ *
+ * @throws Exception if an attribute is numeric
+ */
+ private void findCaRulesQuickly() throws Exception {
+
+ CaRuleGeneration currentLItemSet;
+ // Build rules
+ for (int j = 0; j < m_Ls.size(); j++) {
+ FastVector currentItemSets = (FastVector)m_Ls.elementAt(j);
+ Enumeration enumItemSets = currentItemSets.elements();
+ while (enumItemSets.hasMoreElements()) {
+ currentLItemSet = new CaRuleGeneration((ItemSet)enumItemSets.nextElement());
+ m_best = currentLItemSet.generateRules(m_numRules-5, m_midPoints,m_priors,m_expectation,
+ m_instances,m_best,m_count);
+ m_count = currentLItemSet.count();
+ if(!m_bestChanged && currentLItemSet.change())
+ m_bestChanged = true;
+ if(m_best.size() == m_numRules-5)
+ m_expectation = ((RuleItem)m_best.first()).accuracy();
+ else
+ m_expectation = 0;
+ }
+ }
+ }
+
+ /**
+ * returns all the rules
+ *
+ * @return all the rules
+ * @see #m_allTheRules
+ */
+ public FastVector[] getAllTheRules() {
+ return m_allTheRules;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5444 $");
+ }
+
+ /**
+ * Main method.
+ *
+ * @param args the commandline parameters
+ */
+ public static void main(String[] args) {
+ runAssociator(new PredictiveApriori(), args);
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/associations/PriorEstimation.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/PriorEstimation.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/PriorEstimation.java (revision 29)
@@ -0,0 +1,491 @@
+/*
+ * 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). Finding Association Rules That Trade Support
+ * Optimally against Confidence. Proc of the 5th European Conf.
+ * on Principles and Practice of Knowledge Discovery in Databases (PKDD'01),
+ * pp. 424-435. Freiburg, Germany: Springer-Verlag.
+ *
+ * @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 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/RuleGeneration.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/RuleGeneration.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/RuleGeneration.java (revision 29)
@@ -0,0 +1,381 @@
+/*
+ * 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.
+ */
+
+/*
+ * RuleGeneration.java
+ * Copyright (C) 2004 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.associations;
+
+import weka.core.FastVector;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Statistics;
+import weka.core.Utils;
+
+import java.io.Serializable;
+import java.util.Hashtable;
+import java.util.TreeSet;
+
+/**
+ * Class implementing the rule generation procedure of the predictive apriori algorithm.
+ *
+ * Reference: T. Scheffer (2001). Finding Association Rules That Trade Support
+ * Optimally against Confidence. Proc of the 5th European Conf.
+ * on Principles and Practice of Knowledge Discovery in Databases (PKDD'01),
+ * pp. 424-435. Freiburg, Germany: Springer-Verlag.
+ *
+ * The implementation follows the paper expect for adding a rule to the output of the
+ * n best rules. A rule is added if:
+ * the expected predictive accuracy of this rule is among the n best and it is
+ * not subsumed by a rule with at least the same expected predictive accuracy
+ * (out of an unpublished manuscript from T. Scheffer).
+ *
+ * @author Stefan Mutter (mutter@cs.waikato.ac.nz)
+ * @version $Revision: 1.4 $ */
+public class RuleGeneration
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -8927041669872491432L;
+
+ /** The items stored as an array of of integer. */
+ protected int[] m_items;
+
+ /** Counter for how many transactions contain this item set. */
+ protected int m_counter;
+
+ /** The total number of transactions */
+ protected int m_totalTransactions;
+
+ /** Flag indicating whether the list fo the best rules has changed. */
+ protected boolean m_change = false;
+
+ /** The minimum expected predictive accuracy that is needed to be a candidate for the list of the best rules. */
+ protected double m_expectation;
+
+ /** Threshold. If the support of the premise is higher the binomial distrubution is approximated by a normal one. */
+ protected static final int MAX_N = 300;
+
+ /** The minimum support a rule needs to be a candidate for the list of the best rules. */
+ protected int m_minRuleCount;
+
+ /** Sorted array of the mied points of the intervals used for prior estimation. */
+ protected double[] m_midPoints;
+
+ /** Hashtable conatining the estimated prior probabilities. */
+ protected Hashtable m_priors;
+
+ /** The list of the actual n best rules. */
+ protected TreeSet m_best;
+
+ /** Integer indicating the generation time of a rule. */
+ protected int m_count;
+
+ /** The instances. */
+ protected Instances m_instances;
+
+
+ /**
+ * Constructor
+ * @param itemSet item set for that rules should be generated.
+ * The item set will form the premise of the rules.
+ */
+ public RuleGeneration(ItemSet itemSet){
+
+ m_totalTransactions = itemSet.m_totalTransactions;
+ m_counter = itemSet.m_counter;
+ m_items = itemSet.m_items;
+ }
+
+
+ /**
+ * calculates the probability using a binomial distribution.
+ * If the support of the premise is too large this distribution
+ * is approximated by a normal distribution.
+ * @param accuracy the accuracy value
+ * @param ruleCount the support of the whole rule
+ * @param premiseCount the support of the premise
+ * @return the probability value
+ */
+ public static final double binomialDistribution(double accuracy, double ruleCount, double premiseCount){
+
+ double mu, sigma;
+
+ if(premiseCount < MAX_N)
+ return Math.pow(2,(Utils.log2(Math.pow(accuracy,ruleCount))+Utils.log2(Math.pow((1.0-accuracy),(premiseCount-ruleCount)))+PriorEstimation.logbinomialCoefficient((int)premiseCount,(int)ruleCount)));
+ else{
+ mu = premiseCount * accuracy;
+ sigma = Math.sqrt((premiseCount * (1.0 - accuracy))*accuracy);
+ return Statistics.normalProbability(((ruleCount+0.5)-mu)/(sigma*Math.sqrt(2)));
+ }
+ }
+
+ /**
+ * calculates the expected predctive accuracy of a rule
+ * @param ruleCount the support of the rule
+ * @param premiseCount the premise support of the rule
+ * @param midPoints array with all mid points
+ * @param priors hashtable containing the prior probabilities
+ * @return the expected predictive accuracy
+ */
+ public static final double expectation(double ruleCount, int premiseCount,double[] midPoints, Hashtable priors){
+
+ double numerator = 0, denominator = 0;
+ for(int i = 0;i < midPoints.length; i++){
+ Double actualPrior = (Double)priors.get(new Double(midPoints[i]));
+ if(actualPrior != null){
+ if(actualPrior.doubleValue() != 0){
+ double addend = actualPrior.doubleValue() * binomialDistribution(midPoints[i], ruleCount, (double)premiseCount);
+ denominator += addend;
+ numerator += addend*midPoints[i];
+ }
+ }
+ }
+ if(denominator <= 0 || Double.isNaN(denominator))
+ System.out.println("RuleItem denominator: "+denominator);
+ if(numerator <= 0 || Double.isNaN(numerator))
+ System.out.println("RuleItem numerator: "+numerator);
+ return numerator/denominator;
+ }
+
+ /**
+ * Generates all rules for an item set. The item set is the premise.
+ * @param numRules the number of association rules the use wants to mine.
+ * This number equals the size n of the list of the
+ * best rules.
+ * @param midPoints the mid points of the intervals
+ * @param priors Hashtable that contains the prior probabilities
+ * @param expectation the minimum value of the expected predictive accuracy
+ * that is needed to get into the list of the best rules
+ * @param instances the instances for which association rules are generated
+ * @param best the list of the n best rules.
+ * The list is implemented as a TreeSet
+ * @param genTime the maximum time of generation
+ * @return all the rules with minimum confidence for the given item set
+ */
+ public TreeSet generateRules(int numRules, double[] midPoints, Hashtable priors, double expectation, Instances instances,TreeSet best,int genTime) {
+
+ boolean redundant = false;
+ FastVector consequences = new FastVector(), consequencesMinusOne = new FastVector();
+ ItemSet premise;
+ int s = 0;
+ RuleItem current = null, old;
+
+ Hashtable hashtable;
+
+ m_change = false;
+ m_midPoints = midPoints;
+ m_priors = priors;
+ m_best = best;
+ m_expectation = expectation;
+ m_count = genTime;
+ m_instances = instances;
+
+ //create rule body
+ premise =null;
+ premise = new ItemSet(m_totalTransactions);
+ premise.m_items = new int[m_items.length];
+ System.arraycopy(m_items, 0, premise.m_items, 0, m_items.length);
+ premise.m_counter = m_counter;
+
+
+ do{
+ m_minRuleCount = 1;
+ while(expectation((double)m_minRuleCount,premise.m_counter,m_midPoints,m_priors) <= m_expectation){
+ m_minRuleCount++;
+ if(m_minRuleCount > premise.m_counter)
+ return m_best;
+ }
+ redundant = false;
+ for(int i = 0; i < instances.numAttributes();i++){
+ if(i == 0){
+ for(int j = 0; j < m_items.length;j++)
+ if(m_items[j] == -1)
+ consequences = singleConsequence(instances, j,consequences);
+ if(premise == null || consequences.size() == 0)
+ return m_best;
+ }
+ FastVector allRuleItems = new FastVector();
+ int index = 0;
+ do {
+ int h = 0;
+ while(h < consequences.size()){
+ RuleItem dummie = new RuleItem();
+ current = dummie.generateRuleItem(premise,(ItemSet)consequences.elementAt(h),instances,m_count,m_minRuleCount,m_midPoints,m_priors);
+ if(current != null){
+ allRuleItems.addElement(current);
+ h++;
+ }
+ else
+ consequences.removeElementAt(h);
+ }
+ if(index == i)
+ break;
+ consequencesMinusOne = consequences;
+ consequences = ItemSet.mergeAllItemSets(consequencesMinusOne, index, instances.numInstances());
+ hashtable = ItemSet.getHashtable(consequencesMinusOne, consequencesMinusOne.size());
+ consequences = ItemSet.pruneItemSets(consequences, hashtable);
+ index++;
+ } while (consequences.size() > 0);
+ for(int h = 0;h < allRuleItems.size();h++){
+ current = (RuleItem)allRuleItems.elementAt(h);
+ m_count++;
+ if(m_best.size() < numRules){
+ m_change =true;
+ redundant = removeRedundant(current);
+ }
+ else{
+ if(current.accuracy() > m_expectation){
+ m_expectation = ((RuleItem)(m_best.first())).accuracy();
+ boolean remove = m_best.remove(m_best.first());
+ m_change = true;
+ redundant = removeRedundant(current);
+ m_expectation = ((RuleItem)(m_best.first())).accuracy();
+ while(expectation((double)m_minRuleCount, (current.premise()).m_counter,m_midPoints,m_priors) < m_expectation){
+ m_minRuleCount++;
+ if(m_minRuleCount > (current.premise()).m_counter)
+ break;
+ }
+ }
+ }
+ }
+
+ }
+ }while(redundant);
+ return m_best;
+ }
+
+ /**
+ * Methods that decides whether or not rule a subsumes rule b.
+ * The defintion of subsumption is:
+ * Rule a subsumes rule b, if a subsumes b
+ * AND
+ * a has got least the same expected predictive accuracy as b.
+ * @param a an association rule stored as a RuleItem
+ * @param b an association rule stored as a RuleItem
+ * @return true if rule a subsumes rule b or false otherwise.
+ */
+ public static boolean aSubsumesB(RuleItem a, RuleItem b){
+
+ if(a.m_accuracy < b.m_accuracy)
+ return false;
+ for(int k = 0; k < a.premise().m_items.length;k++){
+ if(a.premise().m_items[k] != b.premise().m_items[k]){
+ if((a.premise().m_items[k] != -1 && b.premise().m_items[k] != -1) || b.premise().m_items[k] == -1)
+ return false;
+ }
+ if(a.consequence().m_items[k] != b.consequence().m_items[k]){
+ if((a.consequence().m_items[k] != -1 && b.consequence().m_items[k] != -1) || a.consequence().m_items[k] == -1)
+ return false;
+ }
+ }
+ return true;
+
+ }
+
+ /**
+ * generates a consequence of length 1 for an association rule.
+ * @param instances the instances under consideration
+ * @param attNum an item that does not occur in the premise
+ * @param consequences FastVector that possibly already contains other consequences of length 1
+ * @return FastVector with consequences of length 1
+ */
+ public static FastVector singleConsequence(Instances instances, int attNum, FastVector consequences){
+
+ ItemSet consequence;
+
+ for (int i = 0; i < instances.numAttributes(); i++) {
+ if( i == attNum){
+ for (int j = 0; j < instances.attribute(i).numValues(); j++) {
+ consequence = new ItemSet(instances.numInstances());
+ consequence.m_items = new int[instances.numAttributes()];
+ for (int k = 0; k < instances.numAttributes(); k++)
+ consequence.m_items[k] = -1;
+ consequence.m_items[i] = j;
+ consequences.addElement(consequence);
+ }
+ }
+ }
+ return consequences;
+
+ }
+
+ /**
+ * Method that removes redundant rules out of the list of the best rules.
+ * A rule is in that list if:
+ * the expected predictive accuracy of this rule is among the best and it is
+ * not subsumed by a rule with at least the same expected predictive accuracy
+ * @param toInsert the rule that should be inserted into the list
+ * @return true if the method has changed the list, false otherwise
+ */
+ public boolean removeRedundant(RuleItem toInsert){
+
+ boolean redundant = false, fSubsumesT = false, tSubsumesF = false;
+ RuleItem first;
+ int subsumes = 0;
+ Object [] best = m_best.toArray();
+ for(int i=0; i < best.length; i++){
+ first = (RuleItem)best[i];
+ fSubsumesT = aSubsumesB(first,toInsert);
+ tSubsumesF = aSubsumesB(toInsert, first);
+ if(fSubsumesT){
+ subsumes = 1;
+ break;
+ }
+ else{
+ if(tSubsumesF){
+ boolean remove = m_best.remove(first);
+ subsumes = 2;
+ redundant =true;
+ }
+ }
+ }
+ if(subsumes == 0 || subsumes == 2)
+ m_best.add(toInsert);
+ return redundant;
+ }
+
+ /**
+ * Gets the actual maximum value of the generation time
+ * @return the actual maximum value of the generation time
+ */
+ public int count(){
+
+ return m_count;
+ }
+
+ /**
+ * Gets if the list fo the best rules has been changed
+ * @return whether or not the list fo the best rules has been changed
+ */
+ public boolean change(){
+
+ return m_change;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.4 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/RuleItem.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/RuleItem.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/RuleItem.java (revision 29)
@@ -0,0 +1,203 @@
+/*
+ * 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.
+ */
+
+/*
+ * RuleItem.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 java.io.Serializable;
+import java.util.Hashtable;
+
+/**
+ * Class for storing an (class) association rule.
+ * The premise and the consequence are stored each as separate item sets.
+ * For every rule their expected predictive accuracy and the time of generation is stored.
+ * These two measures allow to introduce a sort order for rules.
+ *
+ * @author Stefan Mutter
+ * @version $Revision: 1.5 $
+ */
+public class RuleItem
+ implements Comparable, Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -3761299128347476534L;
+
+ /** The premise of a rule. */
+ protected ItemSet m_premise;
+
+ /** The consequence of a rule. */
+ protected ItemSet m_consequence;
+
+ /** The expected predictive accuracy of a rule. */
+ protected double m_accuracy;
+
+ /** The generation time of a rule. */
+ protected int m_genTime;
+
+
+ /**
+ * Constructor for an empty RuleItem
+ */
+ public RuleItem(){
+
+ }
+
+ /**
+ * Constructor that generates a RuleItem out of a given one
+ * @param toCopy RuleItem to copy
+ */
+ public RuleItem(RuleItem toCopy){
+
+ m_premise = toCopy.m_premise;
+ m_consequence = toCopy.m_consequence;
+ m_accuracy = toCopy.m_accuracy;
+ m_genTime = toCopy.m_genTime;
+ }
+
+ /**
+ * Constructor
+ * @param premise the premise of the future RuleItem
+ * @param consequence the consequence of the future RuleItem
+ * @param genTime the time of generation of the future RuleItem
+ * @param ruleSupport support of the rule
+ * @param m_midPoints the mid poitns of the intervals
+ * @param m_priors Hashtable containing the estimated prior probablilities
+ */
+ public RuleItem(ItemSet premise, ItemSet consequence, int genTime,int ruleSupport,double [] m_midPoints, Hashtable m_priors){
+
+
+ m_premise = premise;
+ m_consequence = consequence;
+ m_accuracy = RuleGeneration.expectation((double)ruleSupport,m_premise.m_counter,m_midPoints,m_priors);
+ //overflow, underflow
+ if(Double.isNaN(m_accuracy) || m_accuracy < 0){
+ m_accuracy = Double.MIN_VALUE;
+ }
+ m_consequence.m_counter = ruleSupport;
+ m_genTime = genTime;
+ }
+
+ /**
+ * Constructs a new RuleItem if the support of the given rule is above the support threshold.
+ * @param premise the premise
+ * @param consequence the consequence
+ * @param instances the instances
+ * @param genTime the time of generation of the current premise and consequence
+ * @param minRuleCount the support threshold
+ * @param m_midPoints the mid points of the intervals
+ * @param m_priors the estimated priori probabilities (in a hashtable)
+ * @return a RuleItem if its support is above the threshold, null otherwise
+ */
+ public RuleItem generateRuleItem(ItemSet premise, ItemSet consequence, Instances instances,int genTime, int minRuleCount,double[] m_midPoints, Hashtable m_priors){
+ ItemSet rule = new ItemSet(instances.numInstances());
+ rule.m_items = new int[(consequence.m_items).length];
+ System.arraycopy(premise.m_items, 0, rule.m_items, 0, (premise.m_items).length);
+ for(int k = 0;k < consequence.m_items.length; k++){
+ if(consequence.m_items[k] != -1)
+ rule.m_items[k] = consequence.m_items[k];
+ }
+ for (int i = 0; i < instances.numInstances(); i++)
+ rule.upDateCounter(instances.instance(i));
+ int ruleSupport = rule.support();
+ if(ruleSupport > minRuleCount){
+ RuleItem newRule = new RuleItem(premise,consequence,genTime,ruleSupport,m_midPoints,m_priors);
+ return newRule;
+ }
+ return null;
+ }
+
+ //Note: this class has a natural ordering that is inconsistent with equals
+ /**
+ * compares two RuleItems and allows an ordering concerning
+ * expected predictive accuracy and time of generation
+ * Note: this class has a natural ordering that is inconsistent with equals
+ * @param o RuleItem to compare
+ * @return integer indicating the sort oder of the two RuleItems
+ */
+ public int compareTo(Object o) {
+
+ if(this.m_accuracy == ((RuleItem)o).m_accuracy){
+ if((this.m_genTime == ((RuleItem)o).m_genTime))
+ return 0;
+ if(this.m_genTime > ((RuleItem)o).m_genTime)
+ return -1;
+ if(this.m_genTime < ((RuleItem)o).m_genTime)
+ return 1;
+ }
+ if(this.m_accuracy < ((RuleItem)o).m_accuracy)
+ return -1;
+ return 1;
+ }
+
+ /**
+ * returns whether two RuleItems are equal
+ * @param o RuleItem to compare
+ * @return true if the rules are equal, false otherwise
+ */
+ public boolean equals(Object o){
+
+ if(o == null)
+ return false;
+ if(m_premise.equals(((RuleItem)o).m_premise) && m_consequence.equals(((RuleItem)o).m_consequence))
+ return true;
+ return false;
+ }
+
+ /**
+ * Gets the expected predictive accuracy of a rule
+ * @return the expected predictive accuracy of a rule stored as a RuleItem
+ */
+ public double accuracy(){
+
+ return m_accuracy;
+ }
+
+ /**
+ * Gets the premise of a rule
+ * @return the premise of a rule stored as a RuleItem
+ */
+ public ItemSet premise(){
+
+ return m_premise;
+ }
+
+ /**
+ * Gets the consequence of a rule
+ * @return the consequence of a rule stored as a RuleItem
+ */
+ public ItemSet consequence(){
+
+ return m_consequence;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.5 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/SingleAssociatorEnhancer.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/SingleAssociatorEnhancer.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/SingleAssociatorEnhancer.java (revision 29)
@@ -0,0 +1,203 @@
+/*
+ * 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.
+ */
+
+/*
+ * SingleAssociatorEnhancer.java
+ * Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.associations;
+
+import weka.core.Capabilities;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+ * Abstract utility class for handling settings common to meta
+ * associators that use a single base associator.
+ *
+ * @author Eibe Frank (eibe@cs.waikato.ac.nz)
+ * @author FracPete (fracpete at waikato dot ac dot nz)
+ * @version $Revision: 1.2 $
+ */
+public abstract class SingleAssociatorEnhancer
+ extends AbstractAssociator
+ implements OptionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -3665885256363525164L;
+
+ /** The base associator to use */
+ protected Associator m_Associator = new Apriori();
+
+ /**
+ * String describing default Associator.
+ *
+ * @return default classname
+ */
+ protected String defaultAssociatorString() {
+ return Apriori.class.getName();
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+ Vector result = new Vector();
+
+ result.addElement(new Option(
+ "\tFull name of base associator.\n"
+ + "\t(default: " + defaultAssociatorString() +")",
+ "W", 1, "-W"));
+
+ if (m_Associator instanceof OptionHandler) {
+ result.addElement(new Option(
+ "",
+ "", 0, "\nOptions specific to associator "
+ + m_Associator.getClass().getName() + ":"));
+
+ Enumeration enm = ((OptionHandler) m_Associator).listOptions();
+ while (enm.hasMoreElements())
+ result.addElement(enm.nextElement());
+ }
+
+ return result.elements();
+ }
+
+ /**
+ * Parses a given list of options. Valid options are:
+ *
+ * -W classname
+ * Specify the full class name of the base associator.
+ *
+ * Options after -- are passed to the designated associator.
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String[] options) throws Exception {
+ String tmpStr;
+
+ tmpStr = Utils.getOption('W', options);
+ if (tmpStr.length() > 0) {
+ // This is just to set the associator in case the option
+ // parsing fails.
+ setAssociator(AbstractAssociator.forName(tmpStr, null));
+ setAssociator(AbstractAssociator.forName(tmpStr, Utils.partitionOptions(options)));
+ }
+ else {
+ // This is just to set the associator in case the option
+ // parsing fails.
+ setAssociator(AbstractAssociator.forName(defaultAssociatorString(), null));
+ setAssociator(AbstractAssociator.forName(defaultAssociatorString(), Utils.partitionOptions(options)));
+ }
+ }
+
+ /**
+ * Gets the current settings of the associator.
+ *
+ * @return an array of strings suitable for passing to setOptions
+ */
+ public String[] getOptions() {
+ int i;
+ Vector result;
+ String[] options;
+
+ result = new Vector();
+
+ result.add("-W");
+ result.add(getAssociator().getClass().getName());
+
+ if (getAssociator() instanceof OptionHandler) {
+ options = ((OptionHandler) getAssociator()).getOptions();
+ result.add("--");
+ for (i = 0; i < options.length; i++)
+ result.add(options[i]);
+ }
+
+ return result.toArray(new String[result.size()]);
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String associatorTipText() {
+ return "The base associator to be used.";
+ }
+
+ /**
+ * Set the base associator.
+ *
+ * @param value the associator to use.
+ */
+ public void setAssociator(Associator value) {
+ m_Associator = value;
+ }
+
+ /**
+ * Get the associator used as the base associator.
+ *
+ * @return the currently used associator
+ */
+ public Associator getAssociator() {
+ return m_Associator;
+ }
+
+ /**
+ * Gets the associator specification string, which contains the class name of
+ * the associator and any options to the associator
+ *
+ * @return the associator string
+ */
+ protected String getAssociatorSpec() {
+ Associator c = getAssociator();
+ return c.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)c).getOptions());
+ }
+
+ /**
+ * Returns default capabilities of the base associator.
+ *
+ * @return the capabilities of the base associator
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ if (getAssociator() != null)
+ result = getAssociator().getCapabilities();
+ else
+ result = new Capabilities(this);
+
+ // set dependencies
+ for (Capability cap: Capability.values())
+ result.enableDependency(cap);
+
+ result.setOwner(this);
+
+ return result;
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/Tertius.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/Tertius.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/Tertius.java (revision 29)
@@ -0,0 +1,2025 @@
+/*
+ * 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.
+ */
+
+/*
+ * Tertius.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations;
+
+import weka.associations.tertius.AttributeValueLiteral;
+import weka.associations.tertius.IndividualInstances;
+import weka.associations.tertius.IndividualLiteral;
+import weka.associations.tertius.Literal;
+import weka.associations.tertius.Predicate;
+import weka.associations.tertius.Rule;
+import weka.associations.tertius.SimpleLinkedList;
+import weka.core.Attribute;
+import weka.core.Capabilities;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SelectedTag;
+import weka.core.Tag;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+
+import java.awt.BorderLayout;
+import java.awt.Button;
+import java.awt.Font;
+import java.awt.Frame;
+import java.awt.Label;
+import java.awt.TextField;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * Finds rules according to confirmation measure (Tertius-type algorithm).
+ *
+ * For more information see:
+ *
+ * P. A. Flach, N. Lachiche (1999). Confirmation-Guided Discovery of first-order rules with Tertius. Machine Learning. 42:61-95.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @article{Flach1999,
+ * author = {P. A. Flach and N. Lachiche},
+ * journal = {Machine Learning},
+ * pages = {61-95},
+ * title = {Confirmation-Guided Discovery of first-order rules with Tertius},
+ * volume = {42},
+ * year = {1999}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -K <number of values in result>
+ * Set maximum number of confirmation values in the result. (default: 10)
+ *
+ * -F <frequency threshold>
+ * Set frequency threshold for pruning. (default: 0)
+ *
+ * -C <confirmation threshold>
+ * Set confirmation threshold. (default: 0)
+ *
+ * -N <noise threshold>
+ * Set noise threshold : maximum frequency of counter-examples.
+ * 0 gives only satisfied rules. (default: 1)
+ *
+ * -R
+ * Allow attributes to be repeated in a same rule.
+ *
+ * -L <number of literals>
+ * Set maximum number of literals in a rule. (default: 4)
+ *
+ * -G <0=no negation | 1=body | 2=head | 3=body and head>
+ * Set the negations in the rule. (default: 0)
+ *
+ * -S
+ * Consider only classification rules.
+ *
+ * -c <class index>
+ * Set index of class attribute. (default: last).
+ *
+ * -H
+ * Consider only horn clauses.
+ *
+ * -E
+ * Keep equivalent rules.
+ *
+ * -M
+ * Keep same clauses.
+ *
+ * -T
+ * Keep subsumed rules.
+ *
+ * -I <0=always match | 1=never match | 2=significant>
+ * Set the way to handle missing values. (default: 0)
+ *
+ * -O
+ * Use ROC analysis.
+ *
+ * -p <name of file>
+ * Set the file containing the parts of the individual for individual-based learning.
+ *
+ * -P <0=no output | 1=on stdout | 2=in separate window>
+ * Set output of current values. (default: 0)
+ *
+
+ *
+ * @author Amelie Deltour
+ * @version $Revision: 5444 $
+ */
+
+public class Tertius
+ extends AbstractAssociator
+ implements OptionHandler, Runnable, TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 5556726848380738179L;
+
+ /** The results. */
+ private SimpleLinkedList m_results;
+
+ /** Number of hypotheses considered. */
+ private int m_hypotheses;
+
+ /** Number of hypotheses explored. */
+ private int m_explored;
+
+ /** Time needed for the search. */
+ private Date m_time;
+
+ /** Field to output the current values. */
+ private TextField m_valuesText;
+
+ /** Instances used for the search. */
+ private Instances m_instances;
+
+ /** Predicates used in the rules. */
+ private ArrayList m_predicates;
+
+ /** Status of the search. */
+ private int m_status;
+ /** Status of the search: normal */
+ private static final int NORMAL = 0;
+ /** Status of the search: memory problem */
+ private static final int MEMORY = 1;
+ /** Status of the search: user interruption */
+ private static final int STOP = 2;
+
+ /* Pruning options. */
+
+ /** Number of best confirmation values to search. */
+ private int m_best;
+
+ /** Frequency threshold for the body and the negation of the head. */
+ private double m_frequencyThreshold;
+
+ /** Confirmation threshold for the rules. */
+ private double m_confirmationThreshold;
+
+ /** Maximal number of counter-instances. */
+ private double m_noiseThreshold;
+
+ /* Search space & language bias options. */
+
+ /** Repeat attributes ? */
+ private boolean m_repeat;
+
+ /** Number of literals in a rule. */
+ private int m_numLiterals;
+
+ /** Type of negation: none */
+ private static final int NONE = 0;
+ /** Type of negation: body */
+ private static final int BODY = 1;
+ /** Type of negation: head */
+ private static final int HEAD = 2;
+ /** Type of negation: all */
+ private static final int ALL = 3;
+ /** Types of negation. */
+ private static final Tag [] TAGS_NEGATION = {
+ new Tag(NONE, "None"),
+ new Tag(BODY, "Body"),
+ new Tag(HEAD, "Head"),
+ new Tag(ALL, "Both")
+ };
+
+ /** Type of negation used in the rules. */
+ private int m_negation;
+
+ /** Classification bias. */
+ private boolean m_classification;
+
+ /** Index of class attribute. */
+ private int m_classIndex;
+
+ /** Horn clauses bias. */
+ private boolean m_horn;
+
+ /* Subsumption tests options. */
+
+ /** Perform test on equivalent rules ? */
+ private boolean m_equivalent;
+
+ /** Perform test on same clauses ? */
+ private boolean m_sameClause;
+
+ /** Perform subsumption test ? */
+ private boolean m_subsumption;
+
+ /** Way of handling missing values: min counterinstances */
+ public static final int EXPLICIT = 0;
+ /** Way of handling missing values: max counterinstances */
+ public static final int IMPLICIT = 1;
+ /** Way of handling missing values: missing as a particular value */
+ public static final int SIGNIFICANT = 2;
+ /** Ways of handling missing values. */
+ private static final Tag [] TAGS_MISSING = {
+ new Tag(EXPLICIT, "Matches all"),
+ new Tag(IMPLICIT, "Matches none"),
+ new Tag(SIGNIFICANT, "Significant")
+ };
+
+ /** Way of handling missing values in the search. */
+ private int m_missing;
+
+ /** Perform ROC analysis ? */
+ private boolean m_roc;
+
+ /** Name of the file containing the parts for individual-based learning. */
+ private String m_partsString;
+
+ /** Part instances for individual-based learning. */
+ private Instances m_parts;
+
+ /** Type of values output: No */
+ private static final int NO = 0;
+ /** Type of values output: stdout */
+ private static final int OUT = 1;
+ /** Type of values output: Window */
+ private static final int WINDOW = 2;
+ /** Types of values output. */
+ private static final Tag [] TAGS_VALUES = {
+ new Tag(NO, "No"),
+ new Tag(OUT, "stdout"),
+ new Tag(WINDOW, "Window")
+ };
+
+ /** Type of values output. */
+ private int m_printValues;
+
+ /**
+ * Constructor that sets the options to the default values.
+ */
+ public Tertius() {
+
+ resetOptions();
+ }
+
+ /**
+ * Returns a string describing this associator.
+ *
+ * @return A description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui.
+ */
+ public String globalInfo() {
+ return
+ "Finds rules according to confirmation measure (Tertius-type "
+ + "algorithm).\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.ARTICLE);
+ result.setValue(Field.AUTHOR, "P. A. Flach and N. Lachiche");
+ result.setValue(Field.YEAR, "1999");
+ result.setValue(Field.TITLE, "Confirmation-Guided Discovery of first-order rules with Tertius");
+ result.setValue(Field.JOURNAL, "Machine Learning");
+ result.setValue(Field.VOLUME, "42");
+ result.setValue(Field.PAGES, "61-95");
+
+ return result;
+ }
+
+ /**
+ * Resets the options to the default values.
+ */
+ public void resetOptions() {
+
+ /* Pruning options. */
+ m_best = 10;
+ m_frequencyThreshold = 0;
+ m_confirmationThreshold = 0;
+ m_noiseThreshold = 1;
+
+ /* Search space & language bias options. */
+ m_repeat = false;
+ m_numLiterals = 4;
+ m_negation = NONE;
+ m_classification = false;
+ m_classIndex = 0;
+ m_horn = false;
+
+ /* Subsumption tests options. */
+ m_equivalent = true;
+ m_sameClause = true;
+ m_subsumption = true;
+
+ /* Missing values. */
+ m_missing = EXPLICIT;
+
+ /* ROC analysis. */
+ m_roc = false;
+
+ /* Individual-based learning. */
+ m_partsString = "";
+ m_parts = null;
+
+ /* Values output. */
+ m_printValues = NO;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return An enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+
+ Vector newVector = new Vector(17);
+
+ /* Pruning options. */
+ newVector.addElement(new Option("\tSet maximum number of confirmation "
+ + "values in the result. (default: 10)",
+ "K", 1, "-K "));
+ newVector.addElement(new Option("\tSet frequency threshold for pruning. "
+ + "(default: 0)",
+ "F", 1, "-F "));
+ newVector.addElement(new Option("\tSet confirmation threshold. "
+ + "(default: 0)",
+ "C", 1, "-C "));
+ newVector.addElement(new Option("\tSet noise threshold : maximum frequency "
+ + "of counter-examples.\n\t0 gives only "
+ + "satisfied rules. (default: 1)",
+ "N", 1, "-N "));
+
+ /* Search space & language bias options. */
+ newVector.addElement(new Option("\tAllow attributes to be repeated in a "
+ + "same rule.",
+ "R", 0, "-R"));
+ newVector.addElement(new Option("\tSet maximum number of literals in a "
+ + "rule. (default: 4)",
+ "L", 1, "-L "));
+ newVector.addElement(new Option("\tSet the negations in the rule. "
+ + "(default: 0)",
+ "G", 1, "-G <0=no negation | "
+ + "1=body | "
+ + "2=head | "
+ + "3=body and head>"));
+ newVector.addElement(new Option("\tConsider only classification rules.",
+ "S", 0, "-S"));
+ newVector.addElement(new Option("\tSet index of class attribute. "
+ + "(default: last).",
+ "c", 1, "-c "));
+ newVector.addElement(new Option("\tConsider only horn clauses.",
+ "H", 0, "-H"));
+
+ /* Subsumption tests options. */
+ newVector.addElement(new Option("\tKeep equivalent rules.",
+ "E", 0, "-E"));
+ newVector.addElement(new Option("\tKeep same clauses.",
+ "M", 0, "-M"));
+ newVector.addElement(new Option("\tKeep subsumed rules.",
+ "T", 0, "-T"));
+
+ /* Missing values options. */
+ newVector.addElement(new Option("\tSet the way to handle missing values. "
+ + "(default: 0)",
+ "I", 1, "-I <0=always match | "
+ + "1=never match | "
+ + "2=significant>"));
+
+ /* ROC analysis. */
+ newVector.addElement(new Option("\tUse ROC analysis. ",
+ "O", 0, "-O"));
+
+ /* Individual-based learning. */
+ newVector.addElement(new Option("\tSet the file containing the parts of "
+ + "the individual for individual-based "
+ + "learning.",
+ "p", 1, "-p "));
+
+ /* Values output. */
+ newVector.addElement(new Option("\tSet output of current values. "
+ + "(default: 0)",
+ "P", 1, "-P <0=no output | "
+ + "1=on stdout | "
+ + "2=in separate window>"));
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -K <number of values in result>
+ * Set maximum number of confirmation values in the result. (default: 10)
+ *
+ * -F <frequency threshold>
+ * Set frequency threshold for pruning. (default: 0)
+ *
+ * -C <confirmation threshold>
+ * Set confirmation threshold. (default: 0)
+ *
+ * -N <noise threshold>
+ * Set noise threshold : maximum frequency of counter-examples.
+ * 0 gives only satisfied rules. (default: 1)
+ *
+ * -R
+ * Allow attributes to be repeated in a same rule.
+ *
+ * -L <number of literals>
+ * Set maximum number of literals in a rule. (default: 4)
+ *
+ * -G <0=no negation | 1=body | 2=head | 3=body and head>
+ * Set the negations in the rule. (default: 0)
+ *
+ * -S
+ * Consider only classification rules.
+ *
+ * -c <class index>
+ * Set index of class attribute. (default: last).
+ *
+ * -H
+ * Consider only horn clauses.
+ *
+ * -E
+ * Keep equivalent rules.
+ *
+ * -M
+ * Keep same clauses.
+ *
+ * -T
+ * Keep subsumed rules.
+ *
+ * -I <0=always match | 1=never match | 2=significant>
+ * Set the way to handle missing values. (default: 0)
+ *
+ * -O
+ * Use ROC analysis.
+ *
+ * -p <name of file>
+ * Set the file containing the parts of the individual for individual-based learning.
+ *
+ * -P <0=no output | 1=on stdout | 2=in separate window>
+ * Set output of current values. (default: 0)
+ *
+
+ *
+ * @param options The list of options as an array of strings.
+ * @throws Exception if an option is not supported.
+ */
+ public void setOptions(String [] options) throws Exception {
+
+ resetOptions();
+
+ /* Pruning options. */
+ String bestString = Utils.getOption('K', options);
+ if (bestString.length() != 0) {
+ try {
+ m_best = Integer.parseInt(bestString);
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -K option: "
+ + e.getMessage() + ".");
+ }
+ if (m_best < 1) {
+ throw new Exception("Number of confirmation values has to be "
+ + "greater than one!");
+ }
+ }
+ String frequencyThresholdString = Utils.getOption('F', options);
+ if (frequencyThresholdString.length() != 0) {
+ try {
+ m_frequencyThreshold
+ = (new Double(frequencyThresholdString)).doubleValue();
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -F option: "
+ + e.getMessage() + ".");
+ }
+ if (m_frequencyThreshold < 0 || m_frequencyThreshold > 1) {
+ throw new Exception("Frequency threshold has to be between "
+ + "zero and one!");
+ }
+ }
+ String confirmationThresholdString = Utils.getOption('C', options);
+ if (confirmationThresholdString.length() != 0) {
+ try {
+ m_confirmationThreshold
+ = (new Double(confirmationThresholdString)).doubleValue();
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -C option: "
+ + e.getMessage() + ".");
+ }
+ if (m_confirmationThreshold < 0 || m_confirmationThreshold > 1) {
+ throw new Exception("Confirmation threshold has to be between "
+ + "zero and one!");
+ }
+ if (bestString.length() != 0) {
+ throw new Exception("Specifying both a number of confirmation "
+ + "values and a confirmation threshold "
+ + "doesn't make sense!");
+ }
+ if (m_confirmationThreshold != 0) {
+ m_best = 0;
+ }
+ }
+ String noiseThresholdString = Utils.getOption('N', options);
+ if (noiseThresholdString.length() != 0) {
+ try {
+ m_noiseThreshold = (new Double(noiseThresholdString)).doubleValue();
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -N option: "
+ + e.getMessage() + ".");
+ }
+ if (m_noiseThreshold < 0 || m_noiseThreshold > 1) {
+ throw new Exception("Noise threshold has to be between "
+ + "zero and one!");
+ }
+ }
+
+ /* Search space and language bias options. */
+ m_repeat = Utils.getFlag('R', options);
+ String numLiteralsString = Utils.getOption('L', options);
+ if (numLiteralsString.length() != 0) {
+ try {
+ m_numLiterals = Integer.parseInt(numLiteralsString);
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -L option: "
+ + e.getMessage() + ".");
+ }
+ if (m_numLiterals < 1) {
+ throw new Exception("Number of literals has to be "
+ + "greater than one!");
+ }
+ }
+ String negationString = Utils.getOption('G', options);
+ if (negationString.length() != 0) {
+ SelectedTag selected;
+ int tag;
+ try {
+ tag = Integer.parseInt(negationString);
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -G option: "
+ + e.getMessage() + ".");
+ }
+ try {
+ selected = new SelectedTag(tag, TAGS_NEGATION);
+ } catch (Exception e) {
+ throw new Exception("Value for -G option has to be "
+ + "between zero and three!");
+ }
+ setNegation(selected);
+ }
+ m_classification = Utils.getFlag('S', options);
+ String classIndexString = Utils.getOption('c', options);
+ if (classIndexString.length() != 0) {
+ try {
+ m_classIndex = Integer.parseInt(classIndexString);
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -c option: "
+ + e.getMessage() + ".");
+ }
+ }
+ m_horn = Utils.getFlag('H', options);
+ if (m_horn && (m_negation != NONE)) {
+ throw new Exception("Considering horn clauses doesn't make sense "
+ + "if negation allowed!");
+ }
+
+ /* Subsumption tests options. */
+ m_equivalent = !(Utils.getFlag('E', options));
+ m_sameClause = !(Utils.getFlag('M', options));
+ m_subsumption = !(Utils.getFlag('T', options));
+
+ /* Missing values options. */
+ String missingString = Utils.getOption('I', options);
+ if (missingString.length() != 0) {
+ SelectedTag selected;
+ int tag;
+ try {
+ tag = Integer.parseInt(missingString);
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -I option: "
+ + e.getMessage() + ".");
+ }
+ try {
+ selected = new SelectedTag(tag, TAGS_MISSING);
+ } catch (Exception e) {
+ throw new Exception("Value for -I option has to be "
+ + "between zero and two!");
+ }
+ setMissingValues(selected);
+ }
+
+ /* ROC analysis. */
+ m_roc = Utils.getFlag('O', options);
+
+
+ /* Individual-based learning. */
+ m_partsString = Utils.getOption('p', options);
+ if (m_partsString.length() != 0) {
+ Reader reader;
+ try {
+ reader = new BufferedReader(new FileReader(m_partsString));
+ } catch (Exception e) {
+ throw new Exception("Can't open file " + e.getMessage() + ".");
+ }
+ m_parts = new Instances(reader);
+ }
+
+ /* Values output. */
+ String printValuesString = Utils.getOption('P', options);
+ if (printValuesString.length() != 0) {
+ SelectedTag selected;
+ int tag;
+ try {
+ tag = Integer.parseInt(printValuesString);
+ } catch (Exception e) {
+ throw new Exception("Invalid value for -P option: "
+ + e.getMessage() + ".");
+ }
+ try {
+ selected = new SelectedTag(tag, TAGS_VALUES);
+ } catch (Exception e) {
+ throw new Exception("Value for -P option has to be "
+ + "between zero and two!");
+ }
+ setValuesOutput(selected);
+ }
+ }
+
+ /**
+ * Gets the current settings of the Tertius object.
+ *
+ * @return An array of strings suitable for passing to setOptions.
+ */
+ public String [] getOptions() {
+ Vector result;
+
+ result = new Vector();
+
+ /* Pruning options. */
+ if (m_best > 0) {
+ result.add("-K");
+ result.add("" + m_best);
+ }
+
+ result.add("-F");
+ result.add("" + m_frequencyThreshold);
+
+ if (m_confirmationThreshold > 0) {
+ result.add("-C");
+ result.add("" + m_confirmationThreshold);
+ }
+
+ result.add("-N");
+ result.add("" + m_noiseThreshold);
+
+ /* Search space and language bias options. */
+ if (m_repeat)
+ result.add("-R");
+
+ result.add("-L");
+ result.add("" + m_numLiterals);
+
+ result.add("-G");
+ result.add("" + m_negation);
+
+ if (m_classification)
+ result.add("-S");
+
+ result.add("-c");
+ result.add("" + m_classIndex);
+
+ if (m_horn)
+ result.add("-H");
+
+ /* Subsumption tests options. */
+ if (!m_equivalent)
+ result.add("-E");
+
+ if (!m_sameClause)
+ result.add("-M");
+
+ if (!m_subsumption)
+ result.add("-T");
+
+ /* Missing values options. */
+ result.add("-I");
+ result.add("" + m_missing);
+
+ /* ROC analysis. */
+ if (m_roc)
+ result.add("-O");
+
+ /* Individual-based learning. */
+ if (m_partsString.length() > 0) {
+ result.add("-p");
+ result.add("" + m_partsString);
+ }
+
+ /* Values output. */
+ result.add("-P");
+ result.add("" + m_printValues);
+
+ return (String[]) result.toArray(new String[result.size()]);
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String confirmationValuesTipText() {
+
+ return "Number of best confirmation values to find.";
+ }
+
+ /**
+ * Get the value of confirmationValues.
+ *
+ * @return Value of confirmationValues.
+ */
+ public int getConfirmationValues() {
+
+ return m_best;
+ }
+
+ /**
+ * Set the value of confirmationValues.
+ *
+ * @param v Value to assign to confirmationValues.
+ */
+ public void setConfirmationValues(int v) {
+
+ m_best = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String frequencyThresholdTipText() {
+
+ return "Minimum proportion of instances satisfying head and body of rules";
+ }
+
+ /**
+ * Get the value of frequencyThreshold.
+ *
+ * @return Value of frequencyThreshold.
+ */
+ public double getFrequencyThreshold() {
+
+ return m_frequencyThreshold;
+ }
+
+ /**
+ * Set the value of frequencyThreshold.
+ *
+ * @param v Value to assign to frequencyThreshold.
+ */
+ public void setFrequencyThreshold(double v) {
+
+ m_frequencyThreshold = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String confirmationThresholdTipText() {
+
+ return "Minimum confirmation of the rules.";
+ }
+
+ /**
+ * Get the value of confirmationThreshold.
+ *
+ * @return Value of confirmationThreshold.
+ */
+ public double getConfirmationThreshold() {
+
+ return m_confirmationThreshold;
+ }
+
+ /**
+ * Set the value of confirmationThreshold.
+ *
+ * @param v Value to assign to confirmationThreshold.
+ */
+ public void setConfirmationThreshold(double v) {
+
+ m_confirmationThreshold = v;
+ if (v != 0) {
+ m_best = 0;
+ }
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String noiseThresholdTipText() {
+
+ return "Maximum proportion of counter-instances of rules. "
+ + "If set to 0, only satisfied rules will be given.";
+ }
+
+ /**
+ * Get the value of noiseThreshold.
+ *
+ * @return Value of noiseThreshold.
+ */
+ public double getNoiseThreshold() {
+
+ return m_noiseThreshold;
+ }
+
+ /**
+ * Set the value of noiseThreshold.
+ *
+ * @param v Value to assign to noiseThreshold.
+ */
+ public void setNoiseThreshold(double v) {
+
+ m_noiseThreshold = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String repeatLiteralsTipText() {
+
+ return "Repeated attributes allowed.";
+ }
+
+ /**
+ * Get the value of repeatLiterals.
+ *
+ * @return Value of repeatLiterals.
+ */
+ public boolean getRepeatLiterals() {
+
+ return m_repeat;
+ }
+
+ /**
+ * Set the value of repeatLiterals.
+ *
+ * @param v Value to assign to repeatLiterals.
+ */
+ public void setRepeatLiterals(boolean v) {
+
+ m_repeat = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String numberLiteralsTipText() {
+
+ return "Maximum number of literals in a rule.";
+ }
+
+ /**
+ * Get the value of numberLiterals.
+ *
+ * @return Value of numberLiterals.
+ */
+ public int getNumberLiterals() {
+
+ return m_numLiterals;
+ }
+
+ /**
+ * Set the value of numberLiterals.
+ *
+ * @param v Value to assign to numberLiterals.
+ */
+ public void setNumberLiterals(int v) {
+
+ m_numLiterals = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String negationTipText() {
+
+ return "Set the type of negation allowed in the rule. "
+ + "Negation can be allowed in the body, in the head, in both "
+ + "or in none.";
+ }
+
+ /**
+ * Get the value of negation.
+ *
+ * @return Value of negation.
+ */
+ public SelectedTag getNegation() {
+
+ return new SelectedTag(m_negation, TAGS_NEGATION);
+ }
+
+ /**
+ * Set the value of negation.
+ *
+ * @param v Value to assign to negation.
+ */
+ public void setNegation(SelectedTag v) {
+
+ if (v.getTags() == TAGS_NEGATION) {
+ m_negation = v.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String classificationTipText() {
+
+ return "Find only rules with the class in the head.";
+ }
+
+ /**
+ * Get the value of classification.
+ *
+ * @return Value of classification.
+ */
+ public boolean getClassification() {
+
+ return m_classification;
+ }
+
+ /**
+ * Set the value of classification.
+ *
+ * @param v Value to assign to classification.
+ */
+ public void setClassification(boolean v) {
+
+ m_classification = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String classIndexTipText() {
+
+ return "Index of the class attribute. If set to 0, the class will be the last attribute.";
+ }
+
+ /**
+ * Get the value of classIndex.
+ *
+ * @return Value of classIndex.
+ */
+ public int getClassIndex() {
+
+ return m_classIndex;
+ }
+
+ /**
+ * Set the value of classIndex.
+ *
+ * @param v Value to assign to classIndex.
+ */
+ public void setClassIndex(int v) {
+
+ m_classIndex = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String hornClausesTipText() {
+
+ return "Find rules with a single conclusion literal only.";
+ }
+
+ /**
+ * Get the value of hornClauses.
+ *
+ * @return Value of hornClauses.
+ */
+ public boolean getHornClauses() {
+
+ return m_horn;
+ }
+
+ /**
+ * Set the value of hornClauses.
+ *
+ * @param v Value to assign to hornClauses.
+ */
+ public void setHornClauses(boolean v) {
+
+ m_horn = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String equivalentTipText() {
+
+ return "Keep equivalent rules. "
+ + "A rule r2 is equivalent to a rule r1 if the body of r2 is the "
+ + "negation of the head of r1, and the head of r2 is the "
+ + "negation of the body of r1.";
+ }
+
+ /**
+ * Get the value of equivalent.
+ *
+ * @return Value of equivalent.
+ */
+ public boolean disabled_getEquivalent() {
+
+ return !m_equivalent;
+ }
+
+ /**
+ * Set the value of equivalent.
+ *
+ * @param v Value to assign to equivalent.
+ */
+ public void disabled_setEquivalent(boolean v) {
+
+ m_equivalent = !v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String sameClauseTipText() {
+
+ return "Keep rules corresponding to the same clauses. "
+ + "If set to false, only the rule with the best confirmation "
+ + "value and rules with a lower number of counter-instances "
+ + "will be kept.";
+ }
+
+ /**
+ * Get the value of sameClause.
+ *
+ * @return Value of sameClause.
+ */
+ public boolean disabled_getSameClause() {
+
+ return !m_sameClause;
+ }
+
+ /**
+ * Set the value of sameClause.
+ *
+ * @param v Value to assign to sameClause.
+ */
+ public void disabled_setSameClause(boolean v) {
+
+ m_sameClause = !v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String subsumptionTipText() {
+
+ return "Keep subsumed rules. "
+ + "If set to false, subsumed rules will only be kept if they "
+ + "have a better confirmation or a lower number of counter-instances.";
+ }
+
+ /**
+ * Get the value of subsumption.
+ *
+ * @return Value of subsumption.
+ */
+ public boolean disabled_getSubsumption() {
+
+ return !m_subsumption;
+ }
+
+ /**
+ * Set the value of subsumption.
+ *
+ * @param v Value to assign to subsumption.
+ */
+ public void disabled_setSubsumption(boolean v) {
+
+ m_subsumption = !v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String missingValuesTipText() {
+
+ return "Set the way to handle missing values. "
+ + "Missing values can be set to match any value, or never match values "
+ + "or to be significant and possibly appear in rules.";
+ }
+
+ /**
+ * Get the value of missingValues.
+ *
+ * @return Value of missingValues.
+ */
+ public SelectedTag getMissingValues() {
+
+ return new SelectedTag(m_missing, TAGS_MISSING);
+ }
+
+ /**
+ * Set the value of missingValues.
+ *
+ * @param v Value to assign to missingValues.
+ */
+ public void setMissingValues(SelectedTag v) {
+
+ if (v.getTags() == TAGS_MISSING) {
+ m_missing = v.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String rocAnalysisTipText() {
+
+ return "Return TP-rate and FP-rate for each rule found.";
+ }
+
+ /**
+ * Get the value of rocAnalysis.
+ *
+ * @return Value of rocAnalysis.
+ */
+ public boolean getRocAnalysis() {
+
+ return m_roc;
+ }
+
+ /**
+ * Set the value of rocAnalysis.
+ *
+ * @param v Value to assign to rocAnalysis.
+ */
+ public void setRocAnalysis(boolean v) {
+
+ m_roc = v;
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String partFileTipText() {
+
+ return "Set file containing the parts of the individual "
+ + "for individual-based learning.";
+ }
+
+ /**
+ * Get the value of partFile.
+ *
+ * @return Value of partFile.
+ */
+ public File disabled_getPartFile() {
+
+ return new File(m_partsString);
+ }
+
+ /**
+ * Set the value of partFile.
+ *
+ * @param v Value to assign to partFile.
+ * @throws Exception if file cannot be opened
+ */
+ public void disabled_setPartFile(File v) throws Exception {
+
+ m_partsString = v.getAbsolutePath();
+ if (m_partsString.length() != 0) {
+ Reader reader;
+ try {
+ reader = new BufferedReader(new FileReader(m_partsString));
+ } catch (Exception e) {
+ throw new Exception("Can't open file " + e.getMessage() + ".");
+ }
+ m_parts = new Instances(reader);
+ }
+ }
+
+ /**
+ * Returns the tip text for this property.
+ *
+ * @return Tip text for this property suitable for
+ * displaying in the explorer/experimenter GUI.
+ */
+ public String valuesOutputTipText() {
+
+ return "Give visual feedback during the search. "
+ + "The current best and worst values can be output either to stdout or to a separate window.";
+ }
+
+ /**
+ * Get the value of valuesOutput.
+ *
+ * @return Value of valuesOutput.
+ */
+ public SelectedTag getValuesOutput() {
+
+ return new SelectedTag(m_printValues, TAGS_VALUES);
+ }
+
+ /**
+ * Set the value of valuesOutput.
+ *
+ * @param v Value to assign to valuesOutput.
+ */
+ public void setValuesOutput(SelectedTag v) {
+
+ if (v.getTags() == TAGS_VALUES) {
+ m_printValues = v.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Build the predicate corresponding to an attribute.
+ *
+ * @param instances The instances this predicates comes from.
+ * @param attr The attribute this predicate corresponds to.
+ * @param isClass Saying if the attribute is the class attribute.
+ * @return The corresponding Predicate.
+ * @throws Exception if the predicate could not be build
+ * (the attribute is numeric).
+ */
+ private Predicate buildPredicate(Instances instances,
+ Attribute attr, boolean isClass)
+ throws Exception {
+
+ Predicate predicate; /* The result. */
+ Literal lit;
+ Literal negation;
+ boolean missingValues; /* Missing values for this attribute ? */
+ boolean individual = (m_parts != null); /* Individual-based learning ? */
+ int type = (instances == m_parts)
+ ? IndividualLiteral.PART_PROPERTY
+ : IndividualLiteral.INDIVIDUAL_PROPERTY; /* Type of property. */
+
+ if (attr.isNumeric()) {
+ throw new Exception("Can't handle numeric attributes!");
+ }
+
+ missingValues = instances.attributeStats(attr.index()).missingCount > 0;
+
+ /* Build predicate. */
+ if (individual) {
+ predicate = new Predicate(instances.relationName() + "." + attr.name(),
+ attr.index(), isClass);
+ } else {
+ predicate = new Predicate(attr.name(), attr.index(), isClass);
+ }
+
+ if (attr.numValues() == 2
+ && (!missingValues || m_missing == EXPLICIT)) {
+ /* Case of two values.
+ * If there are missing values, this case is treated like other cases.
+ */
+ if (individual) {
+ lit = new IndividualLiteral(predicate, attr.value(0), 0,
+ Literal.POS, m_missing, type);
+ negation = new IndividualLiteral(predicate, attr.value(1), 1,
+ Literal.POS, m_missing, type);
+ } else {
+ lit = new AttributeValueLiteral(predicate, attr.value(0), 0,
+ Literal.POS, m_missing);
+ negation = new AttributeValueLiteral(predicate, attr.value(1), 1,
+ Literal.POS, m_missing);
+ }
+ lit.setNegation(negation);
+ negation.setNegation(lit);
+ predicate.addLiteral(lit);
+ } else {
+ /* Case of several values. */
+ for (int i = 0; i < attr.numValues(); i++) {
+ if (individual) {
+ lit = new IndividualLiteral(predicate, attr.value(i), i,
+ Literal.POS, m_missing, type);
+ } else {
+ lit = new AttributeValueLiteral(predicate, attr.value(i), i,
+ Literal.POS, m_missing);
+ }
+ if (m_negation != NONE) {
+ if (individual) {
+ negation = new IndividualLiteral(predicate, attr.value(i), i,
+ Literal.NEG, m_missing, type);
+ } else {
+ negation = new AttributeValueLiteral(predicate, attr.value(i), i,
+ Literal.NEG, m_missing);
+ }
+ lit.setNegation(negation);
+ negation.setNegation(lit);
+ }
+ predicate.addLiteral(lit);
+ }
+
+ /* One more value if missing is significant. */
+ if (missingValues && m_missing == SIGNIFICANT) {
+ if (individual) {
+ lit = new IndividualLiteral(predicate, "?", -1,
+ Literal.POS, m_missing, type);
+ } else {
+ lit = new AttributeValueLiteral(predicate, "?", -1,
+ Literal.POS, m_missing);
+ }
+ if (m_negation != NONE) {
+ if (individual) {
+ negation = new IndividualLiteral(predicate, "?", -1,
+ Literal.NEG, m_missing, type);
+ } else {
+ negation = new AttributeValueLiteral(predicate, "?", -1,
+ Literal.NEG, m_missing);
+ }
+ lit.setNegation(negation);
+ negation.setNegation(lit);
+ }
+ predicate.addLiteral(lit);
+ }
+ }
+ return predicate;
+ }
+
+ /**
+ * Build the predicates to use in the rules.
+ *
+ * @return the predicates
+ * @throws Exception If the predicates could not be built
+ * (numeric attribute).
+ */
+ private ArrayList buildPredicates() throws Exception {
+
+ ArrayList predicates = new ArrayList(); /* The result. */
+ Predicate predicate;
+ Attribute attr;
+ Enumeration attributes = m_instances.enumerateAttributes();
+ boolean individual = (m_parts != null); /* Individual-based learning ? */
+
+ /* Attributes. */
+ while (attributes.hasMoreElements()) {
+ attr = (Attribute) attributes.nextElement();
+ /* Identifiers do not appear in rules in individual-based learning. */
+ if (!(individual && attr.name().equals("id"))) {
+ predicate = buildPredicate(m_instances, attr, false);
+ predicates.add(predicate);
+ }
+ }
+ /* Class attribute. */
+ attr = m_instances.classAttribute();
+ /* Identifiers do not appear in rules. */
+ if (!(individual && attr.name().equals("id"))) {
+ predicate = buildPredicate(m_instances, attr, true);
+ predicates.add(predicate);
+ }
+
+ /* Attributes of the parts in individual-based learning. */
+ if (individual) {
+ attributes = m_parts.enumerateAttributes();
+ while (attributes.hasMoreElements()) {
+ attr = (Attribute) attributes.nextElement();
+ /* Identifiers do not appear in rules. */
+ if (!attr.name().equals("id")) {
+ predicate = buildPredicate(m_parts, attr, false);
+ predicates.add(predicate);
+ }
+ }
+ }
+
+ return predicates;
+ }
+
+ /**
+ * Count the number of distinct confirmation values in the results.
+ *
+ * @return Number of confirmation values in the results.
+ */
+ private int numValuesInResult() {
+
+ int result = 0;
+ SimpleLinkedList.LinkedListIterator iter = m_results.iterator();
+ Rule current;
+ Rule next;
+ if (!iter.hasNext()) {
+ return result;
+ } else {
+ current = (Rule) iter.next();
+ while (iter.hasNext()) {
+ next = (Rule) iter.next();
+ if (current.getConfirmation() > next.getConfirmation()) {
+ result++;
+ }
+ current = next;
+ }
+ return result + 1;
+ }
+ }
+
+ /**
+ * Test if it is worth refining a rule.
+ *
+ * @param rule The rule to consider.
+ * @return True if the rule can be refined, false otherwise.
+ */
+ private boolean canRefine(Rule rule) {
+ if (rule.isEmpty()) {
+ return true;
+ }
+ if (m_best != 0) {
+ if (numValuesInResult() < m_best) {
+ return true;
+ }
+ Rule worstResult = (Rule) m_results.getLast();
+ if (rule.getOptimistic() >= worstResult.getConfirmation()) {
+ return true;
+ }
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * Test if it is worth calculating the optimistic estimate of a rule.
+ *
+ * @param rule The rule to consider.
+ * @return True if the optimistic estimate can be calculated, false otherwise.
+ */
+ private boolean canCalculateOptimistic(Rule rule) {
+ if (rule.hasTrueBody() || rule.hasFalseHead()) {
+ return false;
+ }
+ if (!rule.overFrequencyThreshold(m_frequencyThreshold)) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Test if a rule can be explored (if it is interesting for the results
+ * or for refining).
+ *
+ * @param rule The rule to consider.
+ * @return True if the rule can be explored, false otherwise.
+ */
+ private boolean canExplore(Rule rule) {
+ if (rule.getOptimistic() < m_confirmationThreshold) {
+ return false;
+ }
+ if (m_best != 0) {
+ if (numValuesInResult() < m_best) {
+ return true;
+ }
+ Rule worstResult = (Rule) m_results.getLast();
+ if (rule.getOptimistic() >= worstResult.getConfirmation()) {
+ return true;
+ }
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * Test if a rule can be stored in the agenda.
+ *
+ * @param rule The rule to consider.
+ * @return True if the rule can be stored, false otherwise.
+ */
+ private boolean canStoreInNodes(Rule rule) {
+ if (rule.getObservedNumber() == 0) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Test if it is worth calculating the confirmation of a rule.
+ *
+ * @param rule The rule to consider.
+ * @return True if the confirmation can be calculated, false otherwise.
+ */
+ private boolean canCalculateConfirmation(Rule rule) {
+ if (rule.getObservedFrequency() > m_noiseThreshold) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Test if a rule can be added to the results.
+ *
+ * @param rule The rule to consider.
+ * @return True if the rule can be stored, false otherwise.
+ */
+ private boolean canStoreInResults(Rule rule) {
+ if (rule.getConfirmation() < m_confirmationThreshold) {
+ return false;
+ }
+ if (m_best != 0) {
+ if (numValuesInResult() < m_best) {
+ return true;
+ }
+ Rule worstResult = (Rule) m_results.getLast();
+ if (rule.getConfirmation() >= worstResult.getConfirmation()) {
+ return true;
+ }
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * Add a rule in the appropriate place in the list of the results,
+ * according to the confirmation and
+ * number of counter-instances of the rule.
+ * Subsumption tests are performed and the rule may not be added.
+ * Previous results may also be removed because of sumption.
+ */
+ private void addResult(Rule rule) {
+
+ Rule current;
+ boolean added = false;
+
+ /* Iterate the list until we find the right place. */
+ SimpleLinkedList.LinkedListIterator iter = m_results.iterator();
+ while (iter.hasNext()) {
+ current = (Rule) iter.next();
+ if (Rule.confirmationThenObservedComparator.compare(current, rule) > 0) {
+ iter.addBefore(rule);
+ added = true;
+ break;
+ }
+ /* Subsumption tests to see if the rule can be added. */
+ if ((m_subsumption || m_sameClause || m_equivalent)
+ && current.subsumes(rule)) {
+ if (current.numLiterals() == rule.numLiterals()) {
+ if (current.equivalentTo(rule)) {
+ /* Equivalent rules. */
+ if (m_equivalent) {
+ return;
+ }
+ } else {
+ /* Same clauses. */
+ if (m_sameClause
+ && Rule.confirmationComparator.compare(current, rule) < 0) {
+ return;
+ }
+ }
+ } else {
+ /* Subsumption. */
+ if (m_subsumption
+ && Rule.observedComparator.compare(current, rule) <= 0) {
+ return;
+ }
+ }
+ }
+ }
+
+ if (added == false) {
+ /* The rule must be added in the end of the results. */
+ m_results.add(rule);
+ }
+
+ /* Iterate the results with a lower confirmation
+ * to see if some of them must be removed. */
+ SimpleLinkedList.LinkedListInverseIterator inverse
+ = m_results.inverseIterator();
+ while (inverse.hasPrevious()) {
+ current = (Rule) inverse.previous();
+ if (Rule.confirmationThenObservedComparator.compare(current, rule) < 0) {
+ break;
+ }
+ if (current != rule && rule.subsumes(current)) {
+ if (current.numLiterals() == rule.numLiterals()) {
+ if (!current.equivalentTo(rule)) {
+ /* Same clauses. */
+ if (m_sameClause
+ && Rule.confirmationComparator.compare(current, rule) > 0) {
+ inverse.remove();
+ }
+ }
+ } else {
+ /* Subsumption. */
+ if (m_subsumption
+ && Rule.observedComparator.compare(rule, current) <= 0) {
+ inverse.remove();
+ }
+ }
+ }
+ }
+
+ /* Remove the rules with the worst confirmation value
+ * if there are too many results. */
+ if (m_best != 0 && numValuesInResult() > m_best) {
+ Rule worstRule = (Rule) m_results.getLast();
+ inverse = m_results.inverseIterator();
+ while (inverse.hasPrevious()) {
+ current = (Rule) inverse.previous();
+ if (Rule.confirmationComparator.compare(current, worstRule) < 0) {
+ break;
+ }
+ inverse.remove();
+ }
+ }
+
+ /* Print the new current values. */
+ printValues();
+ }
+
+ /**
+ * Returns default capabilities of the classifier.
+ *
+ * @return the capabilities of this classifier
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Method that launches the search to find the rules with the highest
+ * confirmation.
+ *
+ * @param instances The instances to be used for generating the rules.
+ * @throws Exception if rules can't be built successfully.
+ */
+ public void buildAssociations(Instances instances) throws Exception {
+
+ Frame valuesFrame = null; /* Frame to display the current values. */
+
+ /* Initialization of the search. */
+ if (m_parts == null) {
+ m_instances = new Instances(instances);
+ } else {
+ m_instances = new IndividualInstances(new Instances(instances), m_parts);
+ }
+ m_results = new SimpleLinkedList();
+ m_hypotheses = 0;
+ m_explored = 0;
+ m_status = NORMAL;
+
+ if (m_classIndex == -1)
+ m_instances.setClassIndex(m_instances.numAttributes()-1);
+ else if (m_classIndex < m_instances.numAttributes() && m_classIndex >= 0)
+ m_instances.setClassIndex(m_classIndex);
+ else
+ throw new Exception("Invalid class index.");
+
+ // can associator handle the data?
+ getCapabilities().testWithFail(m_instances);
+
+ /* Initialization of the window for current values. */
+ if (m_printValues == WINDOW) {
+ m_valuesText = new TextField(37);
+ m_valuesText.setEditable(false);
+ m_valuesText.setFont(new Font("Monospaced", Font.PLAIN, 12));
+ Label valuesLabel = new Label("Best and worst current values:");
+ Button stop = new Button("Stop search");
+ stop.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ /* Signal the interruption to the search. */
+ m_status = STOP;
+ }
+ });
+ valuesFrame = new Frame("Tertius status");
+ valuesFrame.setResizable(false);
+ valuesFrame.add(m_valuesText, BorderLayout.CENTER);
+ valuesFrame.add(stop, BorderLayout.SOUTH);
+ valuesFrame.add(valuesLabel, BorderLayout.NORTH);
+ valuesFrame.pack();
+ valuesFrame.setVisible(true);
+ } else if (m_printValues == OUT) {
+ System.out.println("Best and worst current values:");
+ }
+
+ Date start = new Date();
+
+ /* Build the predicates and launch the search. */
+ m_predicates = buildPredicates();
+ beginSearch();
+
+ Date end = new Date();
+
+ if (m_printValues == WINDOW) {
+ valuesFrame.dispose();
+ }
+
+ m_time = new Date(end.getTime() - start.getTime());
+ }
+
+ /**
+ * Run the search.
+ */
+ public void run() {
+ try {
+ search();
+ } catch (OutOfMemoryError e) {
+ /* Garbage collect what can be collected to be able to continue. */
+ System.gc();
+ m_status = MEMORY;
+ }
+ endSearch();
+ }
+
+ /**
+ * Begin the search by starting a new thread.
+ */
+ private synchronized void beginSearch() throws Exception {
+ /* This method must be synchronized to be able to
+ * call the wait() method. */
+ Thread search = new Thread(this);
+ search.start();
+ try {
+ /* Wait for the end of the thread. */
+ wait();
+ } catch (InterruptedException e) {
+ /* Signal the interruption to the search. */
+ m_status = STOP;
+ }
+ }
+
+ /**
+ * End the search by notifying to the waiting thread that it is finished.
+ */
+ private synchronized void endSearch() {
+ /* This method must be synchronized to be able to
+ * call the notify() method. */
+ notify();
+ }
+
+ /**
+ * Search in the space of hypotheses the rules that have the highest
+ * confirmation.
+ * The search starts with the empty rule, other rules are generated by
+ * refinement.
+ */
+ public void search() {
+
+ SimpleLinkedList nodes = new SimpleLinkedList(); /* The agenda. */
+ Rule currentNode;
+ SimpleLinkedList children;
+ SimpleLinkedList.LinkedListIterator iter;
+ Rule child;
+ boolean negBody = (m_negation == BODY || m_negation == ALL);
+ boolean negHead = (m_negation == HEAD || m_negation == ALL);
+
+ /* Start with the empty rule. */
+ nodes.add(new Rule(m_repeat, m_numLiterals, negBody, negHead,
+ m_classification, m_horn));
+
+ /* Print the current values. */
+ printValues();
+
+ /* Explore the rules in the agenda. */
+ while (m_status != STOP && !nodes.isEmpty()) {
+ currentNode = (Rule) nodes.removeFirst();
+ if (canRefine(currentNode)) {
+ children = currentNode.refine(m_predicates);
+ iter = children.iterator();
+ /* Calculate the optimistic estimate of the children and
+ * consider them for adding to the agenda and to the results. */
+ while (iter.hasNext()) {
+ m_hypotheses++;
+ child = (Rule) iter.next();
+ child.upDate(m_instances);
+ if (canCalculateOptimistic(child)) {
+ child.calculateOptimistic();
+ if (canExplore(child)) {
+ m_explored++;
+ if (canStoreInNodes(child)) {
+ } else {
+ iter.remove();
+ }
+ if (canCalculateConfirmation(child)) {
+ child.calculateConfirmation();
+ if (canStoreInResults(child)) {
+ addResult(child);
+ }
+ }
+ } else {
+ iter.remove();
+ }
+ } else {
+ iter.remove();
+ }
+ }
+ /* Since the agenda is already sorted it is more efficient
+ * to sort the children only and then merge. */
+ children.sort(Rule.optimisticThenObservedComparator);
+ nodes.merge(children, Rule.optimisticThenObservedComparator);
+ } else {
+ /* The agenda being sorted, it is not worth considering the following
+ * nodes. */
+ break;
+ }
+ }
+ }
+
+ /**
+ * returns the results
+ *
+ * @return the results
+ */
+ public SimpleLinkedList getResults() {
+ return m_results;
+ }
+
+ /**
+ * Print the current best and worst values.
+ */
+ private void printValues() {
+
+ if (m_printValues == NO) {
+ return;
+ } else {
+ if (m_results.isEmpty()) {
+ if (m_printValues == OUT) {
+ System.out.print("0.000000 0.000000 - 0.000000 0.000000");
+ } else { //m_printValues == WINDOW
+ m_valuesText.setText("0.000000 0.000000 - 0.000000 0.000000");
+ }
+ } else {
+ Rule best = (Rule) m_results.getFirst();
+ Rule worst = (Rule) m_results.getLast();
+ String values = best.valuesToString() + " - " + worst.valuesToString();
+ if (m_printValues == OUT) {
+ System.out.print("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
+ System.out.print(values);
+ } else { //m_printValues == WINDOW
+ m_valuesText.setText(values);
+ }
+ }
+ }
+ }
+
+ /**
+ * Outputs the best rules found with their confirmation value and number
+ * of counter-instances.
+ * Also gives the number of hypotheses considered and explored, and the
+ * time needed.
+ */
+ public String toString() {
+
+ StringBuffer text = new StringBuffer();
+ SimpleLinkedList.LinkedListIterator iter = m_results.iterator();
+ int size = m_results.size();
+ int i = 0;
+
+ text.append("\nTertius\n=======\n\n");
+
+ while (iter.hasNext()) {
+ Rule current = (Rule) iter.next();
+ text.append(Utils.doubleToString((double) i + 1,
+ (int) (Math.log(size)
+ / Math.log(10) + 1),
+ 0)
+ + ". ");
+ text.append("/* ");
+ if (m_roc) {
+ text.append(current.rocToString());
+ } else {
+ text.append(current.valuesToString());
+ }
+ text.append(" */ ");
+ text.append(current.toString());
+ text.append("\n");
+ i++;
+ }
+
+ text.append("\nNumber of hypotheses considered: " + m_hypotheses);
+ text.append("\nNumber of hypotheses explored: " + m_explored);
+
+ if (m_status == MEMORY) {
+ text.append("\n\nNot enough memory to continue the search");
+ } else if (m_status == STOP) {
+ text.append("\n\nSearch interrupted");
+ }
+
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5444 $");
+ }
+
+ /**
+ * Main method.
+ *
+ * @param args the commandline parameters
+ */
+ public static void main(String [] args) {
+ runAssociator(new Tertius(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/gsp/Element.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/gsp/Element.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/gsp/Element.java (revision 29)
@@ -0,0 +1,302 @@
+/*
+ * 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.
+ */
+
+/*
+ * Element.java
+ * Copyright (C) 2007 Sebastian Beer
+ *
+ */
+
+package weka.associations.gsp;
+
+import weka.core.FastVector;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+
+import java.io.Serializable;
+
+/**
+ * Class representing an Element, i.e., a set of events/items.
+ *
+ * @author Sebastian Beer
+ * @version $Revision: 1.2 $
+ */
+public class Element
+ implements Cloneable, Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -7900701276019516371L;
+
+ /** events/items stored as an array of ints */
+ protected int[] m_Events;
+
+ /**
+ * Constructor
+ */
+ public Element() {
+ }
+
+ /**
+ * Constructor accepting an initial size of the events Array as parameter.
+ *
+ * @param size the size
+ */
+ public Element(int size) {
+ m_Events = new int[size];
+ }
+
+ /**
+ * Returns all events of the given data set as Elements containing a single
+ * event. The order of events is determined by the header information of
+ * the corresponding ARFF file.
+ *
+ * @param instances the data set
+ * @return the set of 1-Elements
+ */
+ public static FastVector getOneElements (Instances instances) {
+ FastVector setOfOneElements = new FastVector();
+ Element curElement;
+
+ for (int i = 0; i < instances.numAttributes(); i++) {
+ for (int j = 0; j < instances.attribute(i).numValues(); j++) {
+ curElement = new Element();
+ curElement.setEvents(new int [instances.numAttributes()]);
+ for (int k = 0; k < instances.numAttributes(); k++) {
+ curElement.getEvents()[k] = -1;
+ }
+ curElement.getEvents()[i] = j;
+ setOfOneElements.addElement(curElement);
+ }
+ }
+ return setOfOneElements;
+ }
+
+ /**
+ * Merges two Elements into one.
+ *
+ * @param element1 first Element
+ * @param element2 second Element
+ * @return the merged Element
+ */
+ public static Element merge(Element element1, Element element2) {
+ int[] element1Events = element1.getEvents();
+ int[] element2Events = element2.getEvents();
+ Element resultElement = new Element(element1Events.length);
+ int[] resultEvents = resultElement.getEvents();
+
+ for (int i = 0; i < element1Events.length; i++) {
+ if (element2Events[i] > -1) {
+ resultEvents[i] = element2Events[i];
+ } else {
+ resultEvents[i] = element1Events[i];
+ }
+ }
+ resultElement.setEvents(resultEvents);
+
+ return resultElement;
+ }
+
+ /**
+ * Returns a deep clone of an Element.
+ *
+ * @return the cloned Element
+ */
+ public Element clone() {
+ try {
+ Element clone = (Element) super.clone();
+ int[] cloneEvents = new int[m_Events.length];
+
+ for (int i = 0; i < m_Events.length; i++) {
+ cloneEvents[i] = m_Events[i];
+ }
+ clone.setEvents(cloneEvents);
+
+ return clone;
+ } catch (CloneNotSupportedException exc) {
+ exc.printStackTrace();
+ }
+ return null;
+ }
+
+ /**
+ * Checks if an Element contains over one event.
+ *
+ * @return true, if the Element contains over one event, else false
+ */
+ public boolean containsOverOneEvent() {
+ int numEvents = 0;
+ for (int i = 0; i < m_Events.length; i++) {
+ if (m_Events[i] > -1) {
+ numEvents++;
+ }
+ if (numEvents == 2) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Deletes the first or last event of an Element.
+ *
+ * @param position the position of the event to be deleted (first or last)
+ */
+ public void deleteEvent(String position) {
+ if (position.equals("first")) {
+ //delete first event
+ for (int i = 0; i < m_Events.length; i++) {
+ if (m_Events[i] > -1) {
+ m_Events[i] = -1;
+ break;
+ }
+ }
+ }
+ if (position.equals("last")) {
+ //delete last event
+ for (int i = m_Events.length-1; i >= 0; i--) {
+ if (m_Events[i] > -1) {
+ m_Events[i] = -1;
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Checks if two Elements are equal.
+ *
+ * @return true, if the two Elements are equal, else false
+ */
+ public boolean equals(Object obj) {
+ Element element2 = (Element) obj;
+
+ for (int i=0; i < m_Events.length; i++) {
+ if (!(m_Events[i] == element2.getEvents()[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns the events Array of an Element.
+ *
+ * @return the events Array
+ */
+ public int[] getEvents() {
+ return m_Events;
+ }
+
+ /**
+ * Checks if an Element is contained by a given Instance.
+ *
+ * @param instance the given Instance
+ * @return true, if the Instance contains the Element, else false
+ */
+ public boolean isContainedBy(Instance instance) {
+ for (int i=0; i < instance.numAttributes(); i++) {
+ if (m_Events[i] > -1) {
+ if (instance.isMissing(i)) {
+ return false;
+ }
+ if (m_Events[i] != (int) instance.value(i)) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Checks if the Element contains any events.
+ *
+ * @return true, if the Element contains no event, else false
+ */
+ public boolean isEmpty() {
+ for (int i=0; i < m_Events.length; i++) {
+ if (m_Events[i] > -1) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Sets the events Array of an Element.
+ *
+ * @param events the events Array to set
+ */
+ protected void setEvents(int[] events) {
+ m_Events = events;
+ }
+
+ /**
+ * Returns a String representation of an Element where the numeric value
+ * of each event/item is represented by its respective nominal value.
+ *
+ * @param dataSet the corresponding data set containing the header information
+ * @return the String representation
+ */
+ public String toNominalString(Instances dataSet) {
+ StringBuffer result = new StringBuffer();
+ int addedValues = 0;
+
+ result.append("{");
+
+ for (int i=0; i < m_Events.length; i++) {
+ if (m_Events[i] > -1) {
+ result.append(dataSet.attribute(i).value(m_Events[i]) + ",");
+ addedValues++;
+ }
+ }
+ result.deleteCharAt(result.length()-1);
+ result.append("}");
+
+ return result.toString();
+ }
+
+ /**
+ * Returns a String representation of an Element.
+ *
+ * @return the String representation
+ */
+ public String toString() {
+ String result = "";
+
+ result += "{";
+
+ for (int i=0; i < m_Events.length; i++) {
+ result += m_Events[i];
+ if (i+1 < m_Events.length) {
+ result += ",";
+ }
+ }
+ result += "}";
+
+ return result;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.2 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/gsp/Sequence.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/gsp/Sequence.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/gsp/Sequence.java (revision 29)
@@ -0,0 +1,584 @@
+/*
+ * 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.
+ */
+
+/*
+ * Sequence.java
+ * Copyright (C) 2007 Sebastian Beer
+ *
+ */
+
+package weka.associations.gsp;
+
+import weka.core.FastVector;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+
+import java.io.Serializable;
+import java.util.Enumeration;
+
+/**
+ * Class representing a sequence of elements/itemsets.
+ *
+ * @author Sebastian Beer
+ * @version $Revision: 1.2 $
+ */
+public class Sequence
+ implements Cloneable, Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -5001018056339156390L;
+
+ /** the support count of the Sequence */
+ protected int m_SupportCount;
+
+ /** ordered list of the comprised elements/itemsets */
+ protected FastVector m_Elements;
+
+ /**
+ * Constructor.
+ */
+ public Sequence() {
+ m_SupportCount = 0;
+ m_Elements = new FastVector();
+ }
+
+ /**
+ * Constructor accepting a set of elements as parameter.
+ *
+ * @param elements the Elements of the Sequence
+ */
+ public Sequence(FastVector elements) {
+ m_SupportCount = 0;
+ m_Elements = elements;
+ }
+
+ /**
+ * Constructor accepting an int value as parameter to set the support count.
+ *
+ * @param supportCount the support count to set
+ */
+ public Sequence(int supportCount) {
+ m_SupportCount = supportCount;
+ m_Elements = new FastVector();
+ }
+
+ /**
+ * Generates all possible candidate k-Sequences and prunes the ones that
+ * contain an infrequent (k-1)-Sequence.
+ *
+ * @param kMinusOneSequences the set of (k-1)-Sequences, used for verification
+ * @return the generated set of k-candidates
+ * @throws CloneNotSupportedException
+ */
+ public static FastVector aprioriGen(FastVector kMinusOneSequences) throws CloneNotSupportedException {
+ FastVector allCandidates = generateKCandidates(kMinusOneSequences);
+ FastVector prunedCandidates = pruneCadidates(allCandidates, kMinusOneSequences);
+
+ return prunedCandidates;
+ }
+
+ /**
+ * Deletes Sequences of a given set which don't meet the minimum support
+ * count threshold.
+ *
+ * @param sequences the set Sequences to be checked
+ * @param minSupportCount the minimum support count
+ * @return the set of Sequences after deleting
+ */
+ public static FastVector deleteInfrequentSequences(FastVector sequences, long minSupportCount) {
+ FastVector deletedSequences = new FastVector();
+ Enumeration seqEnum = sequences.elements();
+
+ while (seqEnum.hasMoreElements()) {
+ Sequence currentSeq = (Sequence) seqEnum.nextElement();
+ long curSupportCount = currentSeq.getSupportCount();
+
+ if (curSupportCount >= minSupportCount) {
+ deletedSequences.addElement(currentSeq);
+ }
+ }
+ return deletedSequences;
+ }
+
+ /**
+ * Generates candidate k-Sequences on the basis of a given (k-1)-Sequence set.
+ *
+ * @param kMinusOneSequences the set of (k-1)-Sequences
+ * @return the set of candidate k-Sequences
+ * @throws CloneNotSupportedException
+ */
+ protected static FastVector generateKCandidates(FastVector kMinusOneSequences) throws CloneNotSupportedException {
+ FastVector candidates = new FastVector();
+ FastVector mergeResult = new FastVector();
+
+ for (int i = 0; i < kMinusOneSequences.size(); i++) {
+ for (int j = 0; j < kMinusOneSequences.size(); j++) {
+ Sequence originalSeq1 = (Sequence) kMinusOneSequences.elementAt(i);
+ Sequence seq1 = originalSeq1.clone();
+ Sequence originalSeq2 = (Sequence) kMinusOneSequences.elementAt(j);
+ Sequence seq2 = originalSeq2.clone();
+ Sequence subseq1 = seq1.deleteEvent("first");
+ Sequence subseq2 = seq2.deleteEvent("last");
+
+ if (subseq1.equals(subseq2)) {
+ //seq1 and seq2 are 1-sequences
+ if ((subseq1.getElements().size() == 0) && (subseq2.getElements().size() == 0)) {
+ if (i >= j) {
+ mergeResult = merge(seq1, seq2, true, true);
+ } else {
+ mergeResult = merge(seq1, seq2, true, false);
+ }
+ //seq1 and seq2 are k-sequences
+ } else {
+ mergeResult = merge(seq1, seq2, false, false);
+ }
+ candidates.appendElements(mergeResult);
+ }
+ }
+ }
+ return candidates;
+ }
+
+ /**
+ * Merges two Sequences in the course of candidate generation. Differentiates
+ * between merging 1-Sequences and k-Sequences, k > 1.
+ *
+ * @param seq1 Sequence at first position
+ * @param seq2 Sequence at second position
+ * @param oneElements true, if 1-Elements should be merged, else false
+ * @param mergeElements true, if two 1-Elements were not already merged
+ * (regardless of their position), else false
+ * @return set of resulting Sequences
+ */
+ protected static FastVector merge(Sequence seq1, Sequence seq2, boolean oneElements, boolean mergeElements) {
+ FastVector mergeResult = new FastVector();
+
+ //merge 1-sequences
+ if (oneElements) {
+ Element element1 = (Element) seq1.getElements().firstElement();
+ Element element2 = (Element) seq2.getElements().firstElement();
+ Element element3 = null;
+ if (mergeElements) {
+ for (int i = 0; i < element1.getEvents().length; i++) {
+ if (element1.getEvents()[i] > -1) {
+ if (element2.getEvents()[i] > -1) {
+ break;
+ } else {
+ element3 = Element.merge(element1, element2);
+ }
+ }
+ }
+ }
+ FastVector newElements1 = new FastVector();
+ //generate <{x}{y}>
+ newElements1.addElement(element1);
+ newElements1.addElement(element2);
+ mergeResult.addElement(new Sequence(newElements1));
+ //generate <{x,y}>
+ if (element3 != null) {
+ FastVector newElements2 = new FastVector();
+ newElements2.addElement(element3);
+ mergeResult.addElement(new Sequence(newElements2));
+ }
+
+ return mergeResult;
+ //merge k-sequences, k > 1
+ } else {
+ Element lastElementSeq1 = (Element) seq1.getElements().lastElement();
+ Element lastElementSeq2 = (Element) seq2.getElements().lastElement();
+ Sequence resultSeq = new Sequence();
+ FastVector resultSeqElements = resultSeq.getElements();
+
+ //if last two events/items belong to the same element/itemset
+ if (lastElementSeq2.containsOverOneEvent()) {
+ for (int i = 0; i < (seq1.getElements().size()-1); i++) {
+ resultSeqElements.addElement(seq1.getElements().elementAt(i));
+ }
+ resultSeqElements.addElement(Element.merge(lastElementSeq1, lastElementSeq2));
+ mergeResult.addElement(resultSeq);
+
+ return mergeResult;
+ //if last two events/items belong to different elements/itemsets
+ } else {
+ for (int i = 0; i < (seq1.getElements().size()); i++) {
+ resultSeqElements.addElement(seq1.getElements().elementAt(i));
+ }
+ resultSeqElements.addElement(lastElementSeq2);
+ mergeResult.addElement(resultSeq);
+
+ return mergeResult;
+ }
+ }
+ }
+
+ /**
+ * Converts a set of 1-Elements into a set of 1-Sequences.
+ *
+ * @param elements the set of 1-Elements
+ * @return the set of 1-Sequences
+ */
+ public static FastVector oneElementsToSequences(FastVector elements) {
+ FastVector sequences = new FastVector();
+ Enumeration elementEnum = elements.elements();
+
+ while (elementEnum.hasMoreElements()) {
+ Sequence seq = new Sequence();
+ FastVector seqElements = seq.getElements();
+ seqElements.addElement(elementEnum.nextElement());
+ sequences.addElement(seq);
+ }
+ return sequences;
+ }
+
+ /**
+ * Prints a set of Sequences as String output.
+ *
+ * @param setOfSequences the set of sequences
+ */
+ public static void printSetOfSequences(FastVector setOfSequences) {
+ Enumeration seqEnum = setOfSequences.elements();
+ int i = 1;
+
+ while(seqEnum.hasMoreElements()) {
+ Sequence seq = (Sequence) seqEnum.nextElement();
+ System.out.print("[" + i++ + "]" + " " + seq.toString());
+ }
+ }
+
+ /**
+ * Prunes a k-Sequence of a given candidate set if one of its (k-1)-Sequences
+ * is infrequent.
+ *
+ * @param allCandidates the set of all potential k-Sequences
+ * @param kMinusOneSequences the set of (k-1)-Sequences for verification
+ * @return the set of the pruned candidates
+ */
+ protected static FastVector pruneCadidates(FastVector allCandidates, FastVector kMinusOneSequences) {
+ FastVector prunedCandidates = new FastVector();
+ boolean isFrequent;
+ //for each candidate
+ for (int i = 0; i < allCandidates.size(); i++) {
+ Sequence candidate = (Sequence) allCandidates.elementAt(i);
+ isFrequent = true;
+ FastVector canElements = candidate.getElements();
+ //generate each possible (k-1)-sequence and verify if it's frequent
+ for (int j = 0; j < canElements.size(); j++) {
+ if(isFrequent) {
+ Element origElement = (Element) canElements.elementAt(j);
+ int[] origEvents = origElement.getEvents();
+
+ for (int k = 0; k < origEvents.length; k++) {
+ if (origEvents[k] > -1) {
+ int helpEvent = origEvents[k];
+ origEvents[k] = -1;
+
+ if (origElement.isEmpty()) {
+ canElements.removeElementAt(j);
+ //check if the (k-1)-sequence is contained in the set of kMinusOneSequences
+ int containedAt = kMinusOneSequences.indexOf(candidate);
+ if (containedAt != -1) {
+ origEvents[k] = helpEvent;
+ canElements.insertElementAt(origElement, j);
+ break;
+ } else {
+ isFrequent = false;
+ break;
+ }
+ } else {
+ //check if the (k-1)-sequence is contained in the set of kMinusOneSequences
+ int containedAt = kMinusOneSequences.indexOf(candidate);
+ if (containedAt != -1) {
+ origEvents[k] = helpEvent;
+ continue;
+ } else {
+ isFrequent = false;
+ break;
+ }
+ }
+ }
+ }
+ } else {
+ break;
+ }
+ }
+ if (isFrequent) {
+ prunedCandidates.addElement(candidate);
+ }
+ }
+ return prunedCandidates;
+ }
+
+ /**
+ * Returns a String representation of a set of Sequences where the numeric
+ * value of each event/item is represented by its respective nominal value.
+ *
+ * @param setOfSequences the set of Sequences
+ * @param dataSet the corresponding data set containing the header
+ * information
+ * @param filterAttributes the attributes to filter out
+ * @return the String representation
+ */
+ public static String setOfSequencesToString(FastVector setOfSequences, Instances dataSet, FastVector filterAttributes) {
+ StringBuffer resString = new StringBuffer();
+ Enumeration SequencesEnum = setOfSequences.elements();
+ int i = 1;
+ boolean printSeq;
+
+ while(SequencesEnum.hasMoreElements()) {
+ Sequence seq = (Sequence) SequencesEnum.nextElement();
+ Integer filterAttr = (Integer) filterAttributes.elementAt(0);
+ printSeq = true;
+
+ if (filterAttr.intValue() != -1) {
+ for (int j=0; j < filterAttributes.size(); j++) {
+ filterAttr = (Integer) filterAttributes.elementAt(j);
+ FastVector seqElements = seq.getElements();
+
+ if (printSeq) {
+ for (int k=0; k < seqElements.size(); k++) {
+ Element currentElement = (Element) seqElements.elementAt(k);
+ int[] currentEvents = currentElement.getEvents();
+
+ if (currentEvents[filterAttr.intValue()] != -1) {
+ continue;
+ } else {
+ printSeq = false;
+ break;
+ }
+ }
+ }
+ }
+ }
+ if (printSeq) {
+ resString.append("[" + i++ + "]" + " " + seq.toNominalString(dataSet));
+ }
+ }
+ return resString.toString();
+ }
+
+ /**
+ * Updates the support count of a set of Sequence candidates according to a
+ * given set of data sequences.
+ *
+ * @param candidates the set of candidates
+ * @param dataSequences the set of data sequences
+ */
+ public static void updateSupportCount(FastVector candidates, FastVector dataSequences) {
+ Enumeration canEnumeration = candidates.elements();
+
+ while(canEnumeration.hasMoreElements()){
+ Enumeration dataSeqEnumeration = dataSequences.elements();
+ Sequence candidate = (Sequence) canEnumeration.nextElement();
+
+ while(dataSeqEnumeration.hasMoreElements()) {
+ Instances dataSequence = (Instances) dataSeqEnumeration.nextElement();
+
+ if (candidate.isSubsequenceOf(dataSequence)) {
+ candidate.setSupportCount(candidate.getSupportCount() + 1);
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns a deep clone of a Sequence.
+ *
+ * @return the cloned Sequence
+ */
+ public Sequence clone() {
+ try {
+ Sequence clone = (Sequence) super.clone();
+
+ clone.setSupportCount(m_SupportCount);
+ FastVector cloneElements = new FastVector(m_Elements.size());
+
+ for (int i = 0; i < m_Elements.size(); i++) {
+ Element helpElement = (Element) m_Elements.elementAt(i);
+ cloneElements.addElement(helpElement.clone());
+ }
+ clone.setElements(cloneElements);
+
+ return clone;
+ } catch (CloneNotSupportedException exc) {
+ exc.printStackTrace();
+ }
+ return null;
+ }
+
+ /**
+ * Deletes either the first or the last event/item of a Sequence. If the
+ * deleted event/item is the only value in the Element, it is removed, as well.
+ *
+ * @param position the position of the event/item (first or last)
+ * @return the Sequence with either the first or the last
+ * event/item deleted
+ */
+ protected Sequence deleteEvent(String position) {
+ Sequence cloneSeq = clone();
+
+ if (position.equals("first")) {
+ Element element = (Element) cloneSeq.getElements().firstElement();
+ element.deleteEvent("first");
+ if (element.isEmpty()) {
+ cloneSeq.getElements().removeElementAt(0);
+ }
+ return cloneSeq;
+ }
+ if (position.equals("last")) {
+ Element element = (Element) cloneSeq.getElements().lastElement();
+ element.deleteEvent("last");
+ if (element.isEmpty()) {
+ cloneSeq.getElements().removeElementAt(m_Elements.size()-1);
+ }
+ return cloneSeq;
+ }
+ return null;
+ }
+
+ /**
+ * Checks if two Sequences are equal.
+ *
+ * @return true, if the two Sequences are equal, else false
+ */
+ public boolean equals(Object obj) {
+ Sequence seq2 = (Sequence) obj;
+ FastVector seq2Elements = seq2.getElements();
+
+ for (int i = 0; i < m_Elements.size(); i++) {
+ Element thisElement = (Element) m_Elements.elementAt(i);
+ Element seq2Element = (Element) seq2Elements.elementAt(i);
+ if (!thisElement.equals(seq2Element)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns the Elements of the Sequence.
+ *
+ * @return the Elements
+ */
+ protected FastVector getElements() {
+ return m_Elements;
+ }
+
+ /**
+ * Returns the support count of the Sequence.
+ *
+ * @return the support count
+ */
+ protected int getSupportCount() {
+ return m_SupportCount;
+ }
+
+ /**
+ * Checks if the Sequence is subsequence of a given data sequence.
+ *
+ * @param dataSequence the data sequence to verify against
+ * @return true, if the Sequnce is subsequence of the data
+ * sequence, else false
+ */
+ protected boolean isSubsequenceOf(Instances dataSequence) {
+ FastVector elements = getElements();
+ Enumeration elementEnum = elements.elements();
+ Element curElement = (Element) elementEnum.nextElement();
+
+ for (int i = 0; i < dataSequence.numInstances(); i++) {
+ if (curElement.isContainedBy(dataSequence.instance(i))) {
+ if (!elementEnum.hasMoreElements()) {
+ return true;
+ } else {
+ curElement = (Element) elementEnum.nextElement();
+ continue;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Sets the Elements of the Sequence.
+ *
+ * @param elements the Elements to set
+ */
+ protected void setElements(FastVector elements) {
+ m_Elements = elements;
+ }
+
+ /**
+ * Sets the support count of the Sequence.
+ *
+ * @param supportCount the support count to set
+ */
+ protected void setSupportCount(int supportCount) {
+ m_SupportCount = supportCount;
+ }
+
+ /**
+ * Returns a String representation of a Sequences where the numeric value
+ * of each event/item is represented by its respective nominal value.
+ *
+ * @param dataSet the corresponding data set containing the header
+ * information
+ * @return the String representation
+ */
+ public String toNominalString(Instances dataSet) {
+ String result = "";
+
+ result += "<";
+
+ for (int i = 0; i < m_Elements.size(); i++) {
+ Element element = (Element) m_Elements.elementAt(i);
+ result += element.toNominalString(dataSet);
+ }
+ result += "> (" + getSupportCount() + ")\n";
+
+ return result;
+ }
+
+ /**
+ * Returns a String representation of a Sequence.
+ *
+ * @return the String representation
+ */
+ public String toString() {
+ String result = "";
+
+ result += "Sequence Output\n";
+ result += "------------------------------\n";
+ result += "Support Count: " + getSupportCount() + "\n";
+ result += "contained elements/itemsets:\n";
+
+ for (int i = 0; i < m_Elements.size(); i++) {
+ Element element = (Element) m_Elements.elementAt(i);
+ result += element.toString();
+ }
+ result += "\n\n";
+
+ return result;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.2 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/AttributeValueLiteral.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/AttributeValueLiteral.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/AttributeValueLiteral.java (revision 29)
@@ -0,0 +1,118 @@
+/*
+ * 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.
+ */
+
+/*
+ * AttributeValueLiteral.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.RevisionUtils;
+import weka.associations.Tertius;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 1.6 $
+ */
+public class AttributeValueLiteral
+ extends Literal {
+
+ /** for serialization */
+ private static final long serialVersionUID = 4077436297281456239L;
+
+ private String m_value;
+
+ private int m_index;
+
+ public AttributeValueLiteral(Predicate predicate, String value,
+ int index, int sign, int missing) {
+
+ super(predicate, sign, missing);
+ m_value = value;
+ m_index = index;
+ }
+
+ public boolean satisfies(Instance instance) {
+
+ if (m_index == -1) {
+ if (positive()) {
+ return instance.isMissing(getPredicate().getIndex());
+ } else {
+ return !instance.isMissing(getPredicate().getIndex());
+ }
+ } else if (instance.isMissing(getPredicate().getIndex())) {
+ if (positive()) {
+ return false;
+ } else {
+ return m_missing != Tertius.EXPLICIT;
+ }
+ } else {
+ if (positive()) {
+ return (instance.value(getPredicate().getIndex()) == m_index);
+ } else {
+ return (instance.value(getPredicate().getIndex()) != m_index);
+ }
+ }
+ }
+
+ public boolean negationSatisfies(Instance instance) {
+
+ if (m_index == -1) {
+ if (positive()) {
+ return !instance.isMissing(getPredicate().getIndex());
+ } else {
+ return instance.isMissing(getPredicate().getIndex());
+ }
+ } else if (instance.isMissing(getPredicate().getIndex())) {
+ if (positive()) {
+ return m_missing != Tertius.EXPLICIT;
+ } else {
+ return false;
+ }
+ } else {
+ if (positive()) {
+ return (instance.value(getPredicate().getIndex()) != m_index);
+ } else {
+ return (instance.value(getPredicate().getIndex()) == m_index);
+ }
+ }
+ }
+
+ public String toString() {
+
+ StringBuffer text = new StringBuffer();
+ if (negative()) {
+ text.append("not ");
+ }
+ text.append(getPredicate().toString() + " = " + m_value);
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/Body.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/Body.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/Body.java (revision 29)
@@ -0,0 +1,123 @@
+/*
+ * 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.
+ */
+
+/*
+ * Body.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionUtils;
+
+import java.util.Iterator;
+
+/**
+ * Class representing the body of a rule.
+ *
+ * @author Amelie Deltour
+ * @version $Revision: 1.6 $
+ */
+
+public class Body
+ extends LiteralSet {
+
+ /** for serialization */
+ private static final long serialVersionUID = 4870689270432218016L;
+
+ /**
+ * Constructor without storing the counter-instances.
+ */
+ public Body() {
+
+ super();
+ }
+
+ /**
+ * Constructor storing the counter-instances.
+ *
+ * @param instances The dataset.
+ */
+ public Body(Instances instances) {
+
+ super(instances);
+ }
+
+ /**
+ * Test if an instance can be kept as a counter-instance,
+ * if a new literal is added to this body.
+ *
+ * @param instance The instance to test.
+ * @param newLit The new literal.
+ * @return True if the instance is still a counter-instance
+ * (if the new literal satisfies the instance).
+ */
+ public boolean canKeep(Instance instance, Literal newLit) {
+
+ return newLit.satisfies(instance);
+ }
+
+ /**
+ * Test if this Body is included in a rule.
+ * It is the literals of this Body are contained in the body of the other rule,
+ * or if their negation is included in the head of the other rule.
+ */
+ public boolean isIncludedIn(Rule otherRule) {
+
+ Iterator iter = this.enumerateLiterals();
+ while (iter.hasNext()) {
+ Literal current = (Literal) iter.next();
+ if (!otherRule.bodyContains(current)
+ && !otherRule.headContains(current.getNegation())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Gives a String representation of this set of literals as a conjunction.
+ */
+ public String toString() {
+ Iterator iter = this.enumerateLiterals();
+
+ if (!iter.hasNext()) {
+ return "TRUE";
+ }
+ StringBuffer text = new StringBuffer();
+ while (iter.hasNext()) {
+ text.append(iter.next().toString());
+ if (iter.hasNext()) {
+ text.append(" and ");
+ }
+ }
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/Head.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/Head.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/Head.java (revision 29)
@@ -0,0 +1,121 @@
+/*
+ * 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.
+ */
+
+/*
+ * Head.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionUtils;
+
+import java.util.Iterator;
+
+/**
+ * Class representing the head of a rule.
+ *
+ * @author Amelie Deltour
+ * @version $Revision: 1.6 $
+ */
+
+public class Head
+ extends LiteralSet {
+
+ /** for serialization */
+ private static final long serialVersionUID = 5068076274253706199L;
+
+ /**
+ * Constructor without storing the counter-instances.
+ */
+ public Head() {
+
+ super();
+ }
+
+ /**
+ * Constructor storing the counter-instances.
+ *
+ * @param instances The dataset.
+ */
+ public Head(Instances instances) {
+
+ super(instances);
+ }
+
+ /**
+ * Test if an instance can be kept as a counter-instance,
+ * if a new literal is added to this head.
+ *
+ * @param instance The instance to test.
+ * @param newLit The new literal.
+ * @return True if the instance is still a counter-instance
+ * (if the negation of the new literal satisfies the instance).
+ */
+ public boolean canKeep(Instance instance, Literal newLit) {
+ return newLit.negationSatisfies(instance);
+ }
+
+ /**
+ * Test if this Head is included in a rule.
+ * It is the literals of this Head are contained in the head of the other rule,
+ * or if their negation is included in the body of the other rule.
+ */ public boolean isIncludedIn(Rule otherRule) {
+ Iterator iter = this.enumerateLiterals();
+ while (iter.hasNext()) {
+ Literal current = (Literal) iter.next();
+ if (!otherRule.headContains(current)
+ && !otherRule.bodyContains(current.getNegation())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Gives a String representation of this set of literals as a disjunction.
+ */
+ public String toString() {
+ Iterator iter = this.enumerateLiterals();
+
+ if (!iter.hasNext()) {
+ return "FALSE";
+ }
+
+ StringBuffer text = new StringBuffer();
+ while (iter.hasNext()) {
+ text.append(iter.next().toString());
+ if (iter.hasNext()) {
+ text.append(" or ");
+ }
+ }
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualInstance.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualInstance.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualInstance.java (revision 29)
@@ -0,0 +1,77 @@
+/*
+ * 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.
+ */
+
+/*
+ * IndividualInstance.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.DenseInstance;
+import weka.core.Instances;
+import weka.core.RevisionUtils;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 5987 $
+ */
+public class IndividualInstance
+ extends DenseInstance {
+
+ /** for serialization */
+ private static final long serialVersionUID = -7903938733476585114L;
+
+ private Instances m_parts;
+
+ public IndividualInstance(Instance individual, Instances parts) {
+
+ super(individual);
+ m_parts = parts;
+ }
+
+ public IndividualInstance(IndividualInstance instance) {
+
+ super(instance);
+ m_parts = instance.m_parts;
+ }
+
+ public Object copy() {
+
+ IndividualInstance result = new IndividualInstance(this);
+ result.m_Dataset = m_Dataset;
+ return result;
+ }
+
+ public Instances getParts() {
+
+ return m_parts;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5987 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualInstances.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualInstances.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualInstances.java (revision 29)
@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+
+/*
+ * IndividualInstances.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ *
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Attribute;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionUtils;
+
+import java.util.Enumeration;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 1.6 $
+ */
+public class IndividualInstances
+ extends Instances {
+
+ /** for serialization */
+ private static final long serialVersionUID = -7355054814895636733L;
+
+ public IndividualInstances(Instances individuals, Instances parts)
+ throws Exception {
+
+ super(individuals, individuals.numInstances());
+
+ Attribute individualIdentifier = attribute("id");
+ if (individualIdentifier == null) {
+ throw new Exception("No identifier found in individuals dataset.");
+ }
+ Attribute partIdentifier = parts.attribute("id");
+ if (partIdentifier == null) {
+ throw new Exception("No identifier found in parts dataset.");
+ }
+
+ Enumeration enumIndividuals = individuals.enumerateInstances();
+ while (enumIndividuals.hasMoreElements()) {
+ Instance individual = (Instance) enumIndividuals.nextElement();
+ Instances partsOfIndividual = new Instances(parts, 0);
+ Enumeration enumParts = parts.enumerateInstances();
+ while (enumParts.hasMoreElements()) {
+ Instance part = (Instance) enumParts.nextElement();
+ if (individual.value(individualIdentifier)
+ == part.value(partIdentifier)) {
+ partsOfIndividual.add(part);
+ }
+ }
+ add(new IndividualInstance(individual, partsOfIndividual));
+ }
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualLiteral.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualLiteral.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/IndividualLiteral.java (revision 29)
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+/*
+ * IndividualLiteral.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ *
+ */
+
+package weka.associations.tertius;
+
+import weka.core.RevisionUtils;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 1.5 $
+ */
+public class IndividualLiteral extends AttributeValueLiteral {
+
+ /** for serialization */
+ private static final long serialVersionUID = 4712404824517887435L;
+
+ private int m_type;
+ public static int INDIVIDUAL_PROPERTY = 0;
+ public static int PART_PROPERTY = 1;
+
+ public IndividualLiteral(Predicate predicate, String value, int index,
+ int sign, int missing, int type) {
+
+ super(predicate, value, index, sign, missing);
+ m_type = type;
+ }
+
+ public int getType() {
+
+ return m_type;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.5 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/Literal.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/Literal.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/Literal.java (revision 29)
@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+
+/*
+ * Literal.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ *
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.RevisionHandler;
+
+import java.io.Serializable;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 1.5 $
+ */
+public abstract class Literal
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = 2675363669503575771L;
+
+ private Predicate m_predicate;
+
+ public static final int NEG = 0;
+
+ public static final int POS = 1;
+
+ private int m_sign;
+
+ private Literal m_negation;
+
+ protected int m_missing;
+
+ public Literal(Predicate predicate, int sign, int missing) {
+
+ m_predicate = predicate;
+ m_sign = sign;
+ m_negation = null;
+ m_missing = missing;
+ }
+
+ public Predicate getPredicate() {
+
+ return m_predicate;
+ }
+
+ public Literal getNegation() {
+
+ return m_negation;
+ }
+
+ public void setNegation(Literal negation) {
+
+ m_negation = negation;
+ }
+
+ public boolean positive() {
+
+ return m_sign == POS;
+ }
+
+ public boolean negative() {
+
+ return m_sign == NEG;
+ }
+
+ public abstract boolean satisfies(Instance instance);
+
+ public abstract boolean negationSatisfies(Instance instance);
+
+ public abstract String toString();
+}
+
+
+
+
+
+
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/LiteralSet.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/LiteralSet.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/LiteralSet.java (revision 29)
@@ -0,0 +1,383 @@
+/*
+ * 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.
+ */
+
+/*
+ * LiteralSet.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Iterator;
+
+/**
+ * Class representing a set of literals, being either the body or the head
+ * of a rule.
+ *
+ * @author Amelie Deltour
+ * @version $Revision: 1.7 $
+ */
+
+public abstract class LiteralSet
+ implements Serializable, Cloneable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = 6094536488654503152L;
+
+ /** Literals contained in this set. */
+ private ArrayList m_literals;
+
+ /** Last literal added to this set. */
+ private Literal m_lastLiteral;
+
+ /** Number of instances in the data the set deals with. */
+ private int m_numInstances;
+
+ /** Set of counter-instances of this part of the rule. */
+ private ArrayList m_counterInstances;
+ /* For a body, counter-instances are the instances satisfying the body.
+ * For a head, conter-instances are the instances satisfying the negation. */
+
+ /** Counter for the number of counter-instances. */
+ private int m_counter;
+
+ /**
+ * Type of properties expressed in this set
+ * (individual or parts properties).
+ */
+ private int m_type;
+
+ /**
+ * Constructor for a set that does not store its counter-instances.
+ */
+ public LiteralSet() {
+
+ m_literals = new ArrayList();
+ m_lastLiteral = null;
+ m_counterInstances = null;
+ m_type = -1;
+ }
+
+ /**
+ * Constructor initializing the set of counter-instances to all the instances.
+ *
+ * @param instances The dataset.
+ */
+ public LiteralSet(Instances instances) {
+
+ this();
+ m_numInstances = instances.numInstances();
+ m_counterInstances = new ArrayList(m_numInstances);
+ Enumeration enu = instances.enumerateInstances();
+ while (enu.hasMoreElements()) {
+ m_counterInstances.add(enu.nextElement());
+ }
+ }
+
+ /**
+ * Returns a shallow copy of this set.
+ * The structured is copied but the literals themselves are not copied.
+ *
+ * @return A copy of this LiteralSet.
+ */
+ public Object clone() {
+
+ Object result = null;
+ try {
+ result = super.clone();
+ /* Clone the set of literals, but not the literals themselves. */
+ ((LiteralSet) result).m_literals = (ArrayList) m_literals.clone();
+ if (m_counterInstances != null) {
+ /* Clone the set of instances, but not the instances themselves. */
+ ((LiteralSet) result).m_counterInstances
+ = (ArrayList) m_counterInstances.clone();
+ }
+ } catch(Exception e) {
+ /* An exception is not supposed to happen here. */
+ e.printStackTrace();
+ System.exit(0);
+ }
+ return result;
+ }
+
+ /**
+ * Update the number of counter-instances of this set in the dataset.
+ * This method should be used is the set does not store its counter-instances.
+ *
+ * @param instances The dataset.
+ */
+ public void upDate(Instances instances) {
+
+ Enumeration enu = instances.enumerateInstances();
+ m_numInstances = instances.numInstances();
+ m_counter = 0;
+ while (enu.hasMoreElements()) {
+ if (this.counterInstance((Instance) enu.nextElement())) {
+ m_counter++;
+ }
+ }
+ }
+
+ /**
+ * Get the number of counter-instances of this LiteralSet.
+ *
+ * @return The number of counter-instances.
+ */
+ public int getCounterInstancesNumber() {
+
+ if (m_counterInstances != null) {
+ return m_counterInstances.size();
+ } else {
+ return m_counter;
+ }
+ }
+
+ /**
+ * Get the frequency of counter-instances of this LiteralSet in the data.
+ *
+ * @return The frequency of counter-instances.
+ */
+ public double getCounterInstancesFrequency() {
+
+ return (double) getCounterInstancesNumber() / (double) m_numInstances;
+ }
+
+ /**
+ * Test if this LiteralSet has more counter-instances than the threshold.
+ *
+ * @param minFrequency The frequency threshold.
+ * @return True if there are more counter-instances than the threshold.
+ */
+ public boolean overFrequencyThreshold(double minFrequency) {
+
+ return getCounterInstancesFrequency() >= minFrequency;
+ }
+
+ /**
+ * Test if all the intances are counter-instances.
+ *
+ * @return True if all the instances are counter-instances.
+ */
+ public boolean hasMaxCounterInstances() {
+
+ return getCounterInstancesNumber() == m_numInstances;
+ }
+
+ /**
+ * Add a Literal to this set.
+ *
+ * @param element The element to add.
+ */
+ public void addElement(Literal element) {
+
+ m_literals.add(element);
+ /* Update the last literal. */
+ m_lastLiteral = element;
+ /* Update the type in the case of individual-based learning. */
+ if (element instanceof IndividualLiteral) {
+ int type = ((IndividualLiteral) element).getType();
+ if (type > m_type) {
+ m_type = type;
+ }
+ }
+ /* Update the set of counter-instances. */
+ if (m_counterInstances != null) {
+ for (int i = m_counterInstances.size() - 1; i >= 0; i--) {
+ Instance current = (Instance) m_counterInstances.get(i);
+ if (!canKeep(current, element)) {
+ m_counterInstances.remove(i);
+ }
+ }
+ }
+ }
+
+ /**
+ * Test if this set is empty.
+ *
+ * @return True if the set is empty.
+ */
+ public final boolean isEmpty() {
+
+ return m_literals.size() == 0;
+ }
+
+ /**
+ * Give the number of literals in this set.
+ *
+ * @return The number of literals.
+ */
+ public final int numLiterals() {
+
+ return m_literals.size();
+ }
+
+ /**
+ * Enumerate the literals contained in this set.
+ *
+ * @return An Iterator for the literals.
+ */
+ public final Iterator enumerateLiterals() {
+
+ return m_literals.iterator();
+ }
+
+ /**
+ * Give the last literal added to this set.
+ *
+ * @return The last literal added.
+ */
+ public Literal getLastLiteral() {
+
+ return m_lastLiteral;
+ }
+
+ /**
+ * Test if the negation of this LiteralSet is included in another LiteralSet.
+ *
+ * @param otherSet The other LiteralSet.
+ * @return True if the negation of this LiteralSet is included in
+ * the other LiteralSet.
+ */
+ public boolean negationIncludedIn(LiteralSet otherSet) {
+
+ Iterator iter = this.enumerateLiterals();
+ while (iter.hasNext()) {
+ Literal current = (Literal) iter.next();
+ if (!otherSet.contains(current.getNegation())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Test if this LiteralSet contains a given Literal.
+ *
+ * @param lit The literal that is looked for.
+ * @return True if this literal is contained in this LiteralSet.
+ */
+ public boolean contains(Literal lit) {
+
+ return m_literals.contains(lit);
+ }
+
+ /**
+ * Give the type of properties in this set (individual or part properties).
+ */
+ public int getType() {
+
+ return m_type;
+ }
+
+ /**
+ * Test if an individual instance, given a part instance of this individual,
+ * is a counter-instance of this LiteralSet.
+ *
+ * @param individual The individual instance.
+ * @param part The part instance.
+ * @return True if the individual is a counter-instance.
+ */
+ public boolean counterInstance(Instance individual, Instance part) {
+ Iterator iter = this.enumerateLiterals();
+ while (iter.hasNext()) {
+ IndividualLiteral current = (IndividualLiteral) iter.next();
+ if (current.getType() == IndividualLiteral.INDIVIDUAL_PROPERTY
+ && !canKeep(individual, current)) {
+ return false;
+ } else if (current.getType() == IndividualLiteral.PART_PROPERTY
+ && !canKeep(part, current)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Test if an instance is a counter-instance of this LiteralSet.
+ *
+ * @param instance The instance to test.
+ * @return True if the instance is a counter-instance.
+ */
+ public boolean counterInstance(Instance instance) {
+ if ((instance instanceof IndividualInstance)
+ && (m_type == IndividualLiteral.PART_PROPERTY)) {
+ /* In the case of an individual instance, all the parts of the individual
+ * have to be considered.
+ * Part properties can be found in the body only, so here we test for
+ * an instance satisfying the set.
+ * It satisfies the set if there exists a part satisfying the set.
+ */
+ Enumeration enu
+ = ((IndividualInstance) instance).getParts().enumerateInstances();
+ while (enu.hasMoreElements()) {
+ if (counterInstance(instance, (Instance) enu.nextElement())) {
+ return true;
+ }
+ }
+ return false;
+ } else {
+ /* Usual case. */
+ Iterator iter = this.enumerateLiterals();
+ while (iter.hasNext()) {
+ Literal current = (Literal) iter.next();
+ if (!canKeep(instance, current)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ /**
+ * Test if an instance can be kept as a counter-instance,
+ * given a new literal.
+ *
+ * @param instance The instance to test.
+ * @param newLit The new literal.
+ * @return True if the instance is still a counter-instance.
+ */
+ public abstract boolean canKeep(Instance instance, Literal newLit);
+
+ /**
+ * Test if this LiteralSet is included in a rule.
+ *
+ * @param otherRule The rule to test.
+ * @return True if this set of literals is included in the rule.
+ */
+ public abstract boolean isIncludedIn(Rule otherRule);
+
+ /**
+ * Gives a String representation for this set of literals.
+ */
+ public abstract String toString();
+}
+
+
+
+
+
+
+
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/Predicate.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/Predicate.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/Predicate.java (revision 29)
@@ -0,0 +1,118 @@
+/*
+ * 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.
+ */
+
+/*
+ * Predicate.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 1.5 $
+ */
+public class Predicate
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -8374702481965026640L;
+
+ private ArrayList m_literals;
+
+ private String m_name;
+
+ private int m_index;
+
+ private boolean m_isClass;
+
+ public Predicate(String name, int index, boolean isClass) {
+
+ m_literals = new ArrayList();
+ m_name = name;
+ m_index = index;
+ m_isClass = isClass;
+ }
+
+ public void addLiteral(Literal lit) {
+
+ m_literals.add(lit);
+ }
+
+ public Literal getLiteral(int index) {
+
+ return (Literal) m_literals.get(index);
+ }
+
+ public int getIndex() {
+
+ return m_index;
+ }
+
+ public int indexOf(Literal lit) {
+
+ int index = m_literals.indexOf(lit);
+ return ((index != -1)
+ ? index
+ : m_literals.indexOf(lit.getNegation()));
+ }
+
+ public int numLiterals() {
+
+ return m_literals.size();
+ }
+
+ public boolean isClass() {
+
+ return m_isClass;
+ }
+
+ public String toString() {
+
+ return m_name;
+ }
+
+ public String description() {
+
+ StringBuffer text = new StringBuffer();
+ text.append(this.toString() + "\n");
+ for (int i = 0; i < numLiterals(); i++) {
+ Literal lit = getLiteral(i);
+ Literal neg = lit.getNegation();
+ text.append("\t" + lit + "\t" + neg + "\n");
+ }
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.5 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/Rule.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/Rule.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/Rule.java (revision 29)
@@ -0,0 +1,872 @@
+/*
+ * 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.
+ */
+
+/*
+ * Rule.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+
+import java.io.Serializable;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Enumeration;
+
+/**
+ * Class representing a rule with a body and a head.
+ *
+ * @author Amelie Deltour
+ * @version $Revision: 1.7 $
+ */
+
+public class Rule
+ implements Serializable, Cloneable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -7763378359090435505L;
+
+ /** The body of the rule. */
+ private Body m_body;
+
+ /** The head of the rule. */
+ private Head m_head;
+
+ /** Can repeat predicates in the rule ? */
+ private boolean m_repeatPredicate;
+
+ /** Maximal number of literals in the rule. */
+ private int m_maxLiterals;
+
+ /** Can there be negations in the body ? */
+ private boolean m_negBody;
+
+ /** Can there be negations in the head ? */
+ private boolean m_negHead;
+
+ /** Is this rule a classification rule ? */
+ private boolean m_classRule;
+
+ /** Can there be only one literal in the head ? */
+ private boolean m_singleHead;
+
+ /** Number of instances in the data this rule deals with. */
+ private int m_numInstances;
+
+ /** Set of counter-instances of this rule. */
+ private ArrayList m_counterInstances;
+
+ /** Counter for the counter-instances of this rule. */
+ private int m_counter;
+
+ /** Confirmation of this rule. */
+ private double m_confirmation;
+
+ /** Optimistic estimate of this rule. */
+ private double m_optimistic;
+
+ /**
+ * Constructor for a rule when the counter-instances are not stored,
+ * giving all the constraints applied to this rule.
+ *
+ * @param repeatPredicate True if predicates can be repeated.
+ * @param maxLiterals Maximum number of literals.
+ * @param negBody True if negation is allowed in the body.
+ * @param negHead True if negation is allowed in the head.
+ * @param classRule True if the rule is a classification rule.
+ * @param horn True if the rule is a horn clause.
+ */
+ public Rule(boolean repeatPredicate, int maxLiterals, boolean negBody,
+ boolean negHead, boolean classRule, boolean horn) {
+
+ m_body = new Body();
+ m_head = new Head();
+ m_repeatPredicate = repeatPredicate;
+ m_maxLiterals = maxLiterals;
+ m_negBody = negBody && !horn;
+ m_negHead = negHead && !horn;
+ m_classRule = classRule;
+ m_singleHead = classRule || horn;
+ }
+
+ /**
+ * Constructor for a rule when the counter-instances are stored,
+ * giving all the constraints applied to this rule.
+ * The counter-instances are initialized to all the instances in the dataset.
+ *
+ * @param instances The dataset.
+ * @param repeatPredicate True if predicates can be repeated.
+ * @param maxLiterals Maximum number of literals.
+ * @param negBody True if negation is allowed in the body.
+ * @param negHead True if negation is allowed in the head.
+ * @param classRule True if the rule is a classification rule.
+ * @param horn True if the rule is a horn clause.
+ */
+ public Rule(Instances instances,
+ boolean repeatPredicate, int maxLiterals, boolean negBody,
+ boolean negHead, boolean classRule, boolean horn) {
+
+ m_body = new Body(instances);
+ m_head = new Head(instances);
+ m_repeatPredicate = repeatPredicate;
+ m_maxLiterals = maxLiterals;
+ m_negBody = negBody && !horn;
+ m_negHead = negHead && !horn;
+ m_classRule = classRule;
+ m_singleHead = classRule || horn;
+ m_numInstances = instances.numInstances();
+ m_counterInstances = new ArrayList(m_numInstances);
+ Enumeration enu = instances.enumerateInstances();
+ while (enu.hasMoreElements()) {
+ m_counterInstances.add(enu.nextElement());
+ }
+ }
+
+ /**
+ * Returns a shallow copy of this rule.
+ * The structured is copied but the literals themselves are not copied.
+ *
+ * @return A copy of this Rule.
+ */
+ public Object clone() {
+
+ Object result = null;
+ try {
+ result = super.clone();
+ /* Clone the body and the head. */
+ ((Rule) result).m_body = (Body) m_body.clone();
+ ((Rule) result).m_head = (Head) m_head.clone();
+ /* Clone the set of counter-instances. */
+ if (m_counterInstances != null) {
+ ((Rule) result).m_counterInstances
+ = (ArrayList) m_counterInstances.clone();
+ }
+ } catch (Exception e) {
+ /* An exception is not supposed to happen here. */
+ e.printStackTrace();
+ System.exit(0);
+ }
+ return result;
+ }
+
+ /**
+ * Test if an instance is a counter-instance of this rule.
+ *
+ * @param instance The instance to test.
+ * @return True if the instance is a counter-instance.
+ */
+ public boolean counterInstance(Instance instance) {
+
+ return ((m_body.counterInstance(instance)
+ && m_head.counterInstance(instance)));
+ }
+
+ /**
+ * Update the number of counter-instances of this rule in the dataset.
+ * This method should be used is the rule does not store its counter-instances.
+ *
+ * @param instances The dataset.
+ */
+ public void upDate(Instances instances) {
+
+ Enumeration enu = instances.enumerateInstances();
+ m_numInstances = instances.numInstances();
+ m_counter = 0;
+ while (enu.hasMoreElements()) {
+ if (this.counterInstance((Instance) enu.nextElement())) {
+ m_counter++;
+ }
+ }
+ m_head.upDate(instances);
+ m_body.upDate(instances);
+ }
+
+ /**
+ * Get the confirmation value of this rule.
+ *
+ * @return The confirmation.
+ */
+ public double getConfirmation() {
+
+ return m_confirmation;
+ }
+
+ /**
+ * Get the optimistic estimate of the confirmation obtained by refining
+ * this rule.
+ *
+ * @return The optimistic estimate.
+ */
+ public double getOptimistic() {
+
+ return m_optimistic;
+ }
+
+ /*
+ * Get the expected number of counter-instances of this rule,
+ * calculated from the number of instances satisfying the body and
+ * the number of instances satisfying the negation of the head.
+ *
+ * @return The expected number of counter-instances.
+ */
+ public double getExpectedNumber() {
+
+ return (double) m_body.getCounterInstancesNumber()
+ * (double) m_head.getCounterInstancesNumber()
+ / (double) m_numInstances;
+ }
+
+ /**
+ * Get the expected frequency of counter-instances of this rule.
+ *
+ * @return The expected frequency of counter-instances.
+ */
+ public double getExpectedFrequency() {
+
+ return getExpectedNumber() / (double) m_numInstances;
+ }
+
+ /**
+ * Get the observed number of counter-instances of this rule in the dataset.
+ *
+ * @return The observed number of counter-instances.
+ */
+ public int getObservedNumber() {
+
+ if (m_counterInstances != null) {
+ return m_counterInstances.size();
+ } else {
+ return m_counter;
+ }
+ }
+
+ /**
+ * Get the observed frequency of counter-instances of this rule in the dataset.
+ *
+ * @return The expected frequency of counter-instances.
+ */
+ public double getObservedFrequency() {
+
+ return (double) getObservedNumber() / (double) m_numInstances;
+ }
+
+ /**
+ * Get the rate of True Positive instances of this rule.
+ *
+ * @return The TP-rate.
+ */
+ public double getTPRate() {
+
+ int tp = m_body.getCounterInstancesNumber() - getObservedNumber();
+ int fn = m_numInstances - m_head.getCounterInstancesNumber() - tp;
+ return ((double) tp / (double) (tp + fn));
+ }
+
+ /**
+ * Get the rate of False Positive instances of this rule.
+ *
+ * @return The FP-rate.
+ */
+ public double getFPRate() {
+
+ int fp = getObservedNumber();
+ int tn = m_head.getCounterInstancesNumber() - fp;
+ return ((double) fp / (double) (fp + tn));
+ }
+
+ /**
+ * Calculate the confirmation of this rule.
+ */
+ public void calculateConfirmation() {
+
+ double expected = getExpectedFrequency();
+ double observed = getObservedFrequency();
+ if ((expected == 0) || (expected == 1)) {
+ m_confirmation = 0;
+ } else {
+ m_confirmation = (expected - observed) / (Math.sqrt(expected) - expected);
+ }
+ }
+
+ /**
+ * Calculate the optimistic estimate of this rule.
+ */
+ public void calculateOptimistic() {
+
+ int counterInstances = this.getObservedNumber();
+ int body = m_body.getCounterInstancesNumber();
+ int notHead = m_head.getCounterInstancesNumber();
+ int n = m_numInstances;
+ double expectedOptimistic;
+ /* optimistic expected number of counter-instances */
+ if (counterInstances <= body - notHead) {
+ expectedOptimistic = (double) (notHead * (body - counterInstances))
+ / (double) (n * n);
+ } else if (counterInstances <= notHead - body) {
+ expectedOptimistic = (double) (body * (notHead - counterInstances))
+ / (double) (n * n);
+ } else {
+ expectedOptimistic = (double) ((notHead + body - counterInstances)
+ * (notHead + body - counterInstances))
+ / (double) (4 * n * n);
+ }
+ if ((expectedOptimistic == 0) || (expectedOptimistic == 1)) {
+ m_optimistic = 0;
+ } else {
+ m_optimistic = expectedOptimistic
+ / (Math.sqrt(expectedOptimistic) - expectedOptimistic);
+ }
+ }
+
+ /**
+ * Test if this rule is empty.
+ *
+ * @return True if it is the empty rule.
+ */
+ public boolean isEmpty() {
+
+ return (m_head.isEmpty() && m_body.isEmpty());
+ }
+
+ /**
+ * Give the number of literals in this rule.
+ *
+ * @return The number of literals.
+ */
+ public int numLiterals() {
+
+ return m_body.numLiterals() + m_head.numLiterals();
+ }
+
+ /**
+ * Add a literal to the body of the rule.
+ *
+ * @param newLit The literal to add.
+ * @return The rule obtained by adding the literal, null if the literal can
+ * not be added because of the constraints on the rule.
+ */
+ private Rule addTermToBody(Literal newLit) {
+
+ if (!m_negBody && newLit.negative()
+ || (m_classRule && newLit.getPredicate().isClass())
+ || (newLit instanceof IndividualLiteral
+ && (((IndividualLiteral) newLit).getType()
+ - m_body.getType()) > 1
+ && (((IndividualLiteral) newLit).getType()
+ - m_head.getType()) > 1)) {
+ return null;
+ } else {
+ Rule result = (Rule) this.clone();
+ result.m_body.addElement(newLit);
+ /* Update the counter-instances. */
+ if (m_counterInstances != null) {
+ for (int i = result.m_counterInstances.size() - 1; i >= 0; i--) {
+ Instance current = (Instance) result.m_counterInstances.get(i);
+ if (!result.m_body.canKeep(current, newLit)) {
+ result.m_counterInstances.remove(i);
+ }
+ }
+ }
+ return result;
+ }
+ }
+
+ /**
+ * Add a literal to the head of the rule.
+ *
+ * @param newLit The literal to add.
+ * @return The rule obtained by adding the literal, null if the literal can
+ * not be added because of the constraints on the rule.
+ */
+ private Rule addTermToHead(Literal newLit) {
+ if ((!m_negHead && newLit.negative())
+ || (m_classRule && !newLit.getPredicate().isClass())
+ || (m_singleHead && !m_head.isEmpty())
+ || (newLit instanceof IndividualLiteral
+ && ((IndividualLiteral) newLit).getType()
+ != IndividualLiteral.INDIVIDUAL_PROPERTY)) {
+ return null;
+ } else {
+ Rule result = (Rule) this.clone();
+ result.m_head.addElement(newLit);
+ /* Update counter-instances. */
+ if (m_counterInstances != null) {
+ for (int i = result.m_counterInstances.size() - 1; i >= 0; i--) {
+ Instance current = (Instance) result.m_counterInstances.get(i);
+ if (!result.m_head.canKeep(current, newLit)) {
+ result.m_counterInstances.remove(i);
+ }
+ }
+ }
+ return result;
+ }
+ }
+
+ /**
+ * Refine a rule by adding a range of literals of a predicate, either to
+ * the head or to the body of the rule.
+ *
+ * @param pred The predicate to consider.
+ * @param firstIndex The index of the first literal of the predicate to add.
+ * @param lastIndex The index of the last literal of the predicate to add.
+ * @param addTobody True if the literals should be added to the body.
+ * @param addToHead True if the literals should be added to the head.
+ * @return A list of rules obtained by refinement.
+ */
+ private SimpleLinkedList refine(Predicate pred, int firstIndex, int lastIndex,
+ boolean addToBody, boolean addToHead) {
+
+ SimpleLinkedList result = new SimpleLinkedList();
+ Literal currentLit;
+ Literal negation;
+ Rule refinement;
+ for (int i = firstIndex; i < lastIndex; i++) {
+ currentLit = pred.getLiteral(i);
+ if (addToBody) {
+ refinement = addTermToBody(currentLit);
+ if (refinement != null) {
+ result.add(refinement);
+ }
+ }
+ if (addToHead) {
+ refinement = addTermToHead(currentLit);
+ if (refinement != null) {
+ result.add(refinement);
+ }
+ }
+ negation = currentLit.getNegation();
+ if (negation != null) {
+ if (addToBody) {
+ refinement = addTermToBody(negation);
+ if (refinement != null) {
+ result.add(refinement);
+ }
+ }
+ if (addToHead) {
+ refinement = addTermToHead(negation);
+ if (refinement != null) {
+ result.add(refinement);
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Refine a rule by adding literal from a set of predictes.
+ *
+ * @param predicates The predicates available.
+ * @return The list of the children obtained by refining the rule.
+ */
+ public SimpleLinkedList refine(ArrayList predicates) {
+
+ SimpleLinkedList result = new SimpleLinkedList();
+ Predicate currentPred;
+ boolean addToBody;
+ boolean addToHead;
+
+ if (this.numLiterals() == m_maxLiterals) {
+ return result;
+ }
+
+ if (this.isEmpty()) {
+ /* Literals can be added on both sides of the rule. */
+ for (int i = 0; i < predicates.size(); i++) {
+ currentPred = (Predicate) predicates.get(i);
+ result.addAll(refine(currentPred,
+ 0, currentPred.numLiterals(),
+ true, true));
+ }
+ } else if (m_body.isEmpty() || m_head.isEmpty()) {
+ /* Literals can be added to the empty side only. */
+ LiteralSet side;
+ Literal last;
+ if (m_body.isEmpty()) {
+ side = m_head;
+ addToBody = true;
+ addToHead = false;
+ } else { // m_head.isEmpty()
+ side = m_body;
+ addToBody = false;
+ addToHead = true;
+ }
+ last = side.getLastLiteral();
+ currentPred = last.getPredicate();
+ if (m_repeatPredicate) {
+ result.addAll(refine(currentPred,
+ currentPred.indexOf(last) + 1,
+ currentPred.numLiterals(),
+ addToBody, addToHead));
+ }
+ for (int i = predicates.indexOf(currentPred) + 1; i < predicates.size();
+ i++) {
+ currentPred = (Predicate) predicates.get(i);
+ result.addAll(refine(currentPred,
+ 0, currentPred.numLiterals(),
+ addToBody, addToHead));
+ }
+ } else {
+ Literal lastLitBody = m_body.getLastLiteral();
+ Literal lastLitHead = m_head.getLastLiteral();
+ Predicate lastPredBody = lastLitBody.getPredicate();
+ Predicate lastPredHead = lastLitHead.getPredicate();
+ int lastLitBodyIndex = lastPredBody.indexOf(lastLitBody);
+ int lastLitHeadIndex = lastPredHead.indexOf(lastLitHead);
+ int lastPredBodyIndex = predicates.indexOf(lastPredBody);
+ int lastPredHeadIndex = predicates.indexOf(lastPredHead);
+ Predicate inferiorPred;
+ Predicate superiorPred;
+ int inferiorLit;
+ int superiorLit;
+ addToBody = (m_head.numLiterals() == 1
+ && (lastPredBodyIndex < lastPredHeadIndex
+ || (lastPredBodyIndex == lastPredHeadIndex
+ && lastLitBodyIndex < lastLitHeadIndex)));
+ addToHead = (m_body.numLiterals() == 1
+ && (lastPredHeadIndex < lastPredBodyIndex
+ || (lastPredHeadIndex == lastPredBodyIndex
+ && lastLitHeadIndex < lastLitBodyIndex)));
+ if (addToBody || addToHead) {
+ /* Add literals in the gap between the body and the head. */
+ if (addToBody) {
+ inferiorPred = lastPredBody;
+ inferiorLit = lastLitBodyIndex;
+ superiorPred = lastPredHead;
+ superiorLit = lastLitHeadIndex;
+ } else { // addToHead
+ inferiorPred = lastPredHead;
+ inferiorLit = lastLitHeadIndex;
+ superiorPred = lastPredBody;
+ superiorLit = lastLitBodyIndex;
+ }
+ if (predicates.indexOf(inferiorPred)
+ < predicates.indexOf(superiorPred)) {
+ if (m_repeatPredicate) {
+ result.addAll(refine(inferiorPred,
+ inferiorLit + 1, inferiorPred.numLiterals(),
+ addToBody, addToHead));
+ }
+ for (int j = predicates.indexOf(inferiorPred) + 1;
+ j < predicates.indexOf(superiorPred); j++) {
+ currentPred = (Predicate) predicates.get(j);
+ result.addAll(refine(currentPred,
+ 0, currentPred.numLiterals(),
+ addToBody, addToHead));
+ }
+ if (m_repeatPredicate) {
+ result.addAll(refine(superiorPred,
+ 0, superiorLit,
+ addToBody, addToHead));
+ }
+ } else {
+ //((inferiorPred.getIndex() == superiorPred.getIndex())
+ //&& (inferiorLit < superiorLit))
+ if (m_repeatPredicate) {
+ result.addAll(refine(inferiorPred,
+ inferiorLit + 1, superiorLit,
+ addToBody, addToHead));
+ }
+ }
+ }
+ /* Add other literals. */
+ if (predicates.indexOf(lastPredBody) > predicates.indexOf(lastPredHead)) {
+ superiorPred = lastPredBody;
+ superiorLit = lastPredBody.indexOf(lastLitBody);
+ } else if (predicates.indexOf(lastPredBody)
+ < predicates.indexOf(lastPredHead)) {
+ superiorPred = lastPredHead;
+ superiorLit = lastPredHead.indexOf(lastLitHead);
+ } else {
+ superiorPred = lastPredBody;
+ if (lastLitBodyIndex > lastLitHeadIndex) {
+ superiorLit = lastPredBody.indexOf(lastLitBody);
+ } else {
+ superiorLit = lastPredHead.indexOf(lastLitHead);
+ }
+ }
+ if (m_repeatPredicate) {
+ result.addAll(refine(superiorPred,
+ superiorLit + 1, superiorPred.numLiterals(),
+ true, true));
+ }
+ for (int j = predicates.indexOf(superiorPred) + 1; j < predicates.size();
+ j++) {
+ currentPred = (Predicate) predicates.get(j);
+ result.addAll(refine(currentPred,
+ 0, currentPred.numLiterals(),
+ true, true));
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Test if this rule subsumes another rule.
+ *
+ * @param otherRule The other rule.
+ * @return True if the other rule is subsumed.
+ */
+ public boolean subsumes(Rule otherRule) {
+
+ if (this.numLiterals() > otherRule.numLiterals()) {
+ return false;
+ }
+ return (m_body.isIncludedIn(otherRule) && m_head.isIncludedIn(otherRule));
+ }
+
+ /**
+ * Test if this rule and another rule correspond to the same clause.
+ *
+ * @param otherRule The other rule.
+ * @return True if both rules correspond to the same clause.
+ */
+ public boolean sameClauseAs(Rule otherRule) {
+
+ return (this.numLiterals() == otherRule.numLiterals()
+ && this.subsumes(otherRule));
+ }
+
+ /**
+ * Test if this rule is equivalent to another rule.
+ *
+ * @param otherRule The other rule.
+ * @return True if both rules are equivalent.
+ */
+ public boolean equivalentTo(Rule otherRule) {
+
+ return (this.numLiterals() == otherRule.numLiterals()
+ && m_head.negationIncludedIn(otherRule.m_body)
+ && m_body.negationIncludedIn(otherRule.m_head));
+ }
+
+ /**
+ * Test if the body of the rule contains a literal.
+ *
+ * @param lit The literal to look for.
+ * @return True if the literal is contained in the body of the rule.
+ */
+ public boolean bodyContains(Literal lit) {
+
+ return m_body.contains(lit);
+ }
+
+ /**
+ * Test if the head of the rule contains a literal.
+ *
+ * @param lit The literal to look for.
+ * @return True if the literal is contained in the head of the rule.
+ */
+ public boolean headContains(Literal lit) {
+
+ return m_head.contains(lit);
+ }
+
+ /**
+ * Test if this rule is over the frequency threshold.
+ *
+ * @param minFrequency The frequency threshold.
+ * @return True if the rule is over the threshold.
+ */
+ public boolean overFrequencyThreshold(double minFrequency) {
+
+ return (m_body.overFrequencyThreshold(minFrequency)
+ && m_head.overFrequencyThreshold(minFrequency));
+ }
+
+ /**
+ * Test if the body of the rule is true.
+ *
+ * @return True if the body is always satisfied.
+ */
+ public boolean hasTrueBody() {
+
+ return (!m_body.isEmpty()
+ && m_body.hasMaxCounterInstances());
+ }
+
+ /**
+ * Test if the head of the rule is false.
+ *
+ * @return True if the body is never satisfied.
+ */
+ public boolean hasFalseHead() {
+
+ return (!m_head.isEmpty()
+ && m_head.hasMaxCounterInstances());
+ }
+
+ /**
+ * Return a String giving the confirmation and optimistic estimate of
+ * this rule.
+ *
+ * @return A String with the values of the rule.
+ */
+ public String valuesToString() {
+
+ StringBuffer text = new StringBuffer();
+ DecimalFormat decimalFormat = new DecimalFormat("0.000000");
+ text.append(decimalFormat.format(getConfirmation()));
+ text.append(" ");
+ text.append(decimalFormat.format(getObservedFrequency()));
+ return text.toString();
+ }
+
+ /**
+ * Return a String giving the TP-rate and FP-rate of
+ * this rule.
+ *
+ * @return A String with the values of the rule.
+ */
+ public String rocToString() {
+
+ StringBuffer text = new StringBuffer();
+ DecimalFormat decimalFormat = new DecimalFormat("0.000000");
+ text.append(decimalFormat.format(getConfirmation()));
+ text.append(" ");
+ text.append(decimalFormat.format(getTPRate()));
+ text.append(" ");
+ text.append(decimalFormat.format(getFPRate()));
+ return text.toString();
+ }
+
+ /**
+ * Retrun a String for this rule.
+ *
+ * @return The String describing this rule.
+ */
+ public String toString() {
+
+ StringBuffer text = new StringBuffer();
+ text.append(m_body.toString());
+ text.append(" ==> ");
+ text.append(m_head.toString());
+ return text.toString();
+ }
+
+ /**
+ * Comparator used to compare two rules according to their confirmation value.
+ */
+ public static Comparator confirmationComparator = new Comparator() {
+
+ public int compare(Object o1, Object o2) {
+
+ Rule r1 = (Rule) o1;
+ Rule r2 = (Rule) o2;
+ double conf1 = r1.getConfirmation();
+ double conf2 = r2.getConfirmation();
+ if (conf1 > conf2) {
+ return -1;
+ } else if (conf1 < conf2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ };
+
+ /**
+ * Comparator used to compare two rules according to their observed number
+ * of counter-instances.
+ */
+ public static Comparator observedComparator = new Comparator() {
+
+ public int compare(Object o1, Object o2) {
+
+ Rule r1 = (Rule) o1;
+ Rule r2 = (Rule) o2;
+ double obs1 = r1.getObservedFrequency();
+ double obs2 = r2.getObservedFrequency();
+ if (obs1 < obs2) {
+ return -1;
+ } else if (obs1 > obs2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ };
+
+ /**
+ * Comparator used to compare two rules according to their optimistic estimate.
+ */
+ public static Comparator optimisticComparator = new Comparator() {
+
+ public int compare(Object o1, Object o2) {
+
+ Rule r1 = (Rule) o1;
+ Rule r2 = (Rule) o2;
+ double opt1 = r1.getOptimistic();
+ double opt2 = r2.getOptimistic();
+ if (opt1 > opt2) {
+ return -1;
+ } else if (opt1 < opt2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ };
+
+ /**
+ * Comparator used to compare two rules according to their confirmation and
+ * then their observed number of counter-instances.
+ */
+ public static Comparator confirmationThenObservedComparator = new Comparator() {
+ public int compare(Object o1, Object o2) {
+
+ int confirmationComparison = confirmationComparator.compare(o1, o2);
+ if (confirmationComparison != 0) {
+ return confirmationComparison;
+ } else {
+ return observedComparator.compare(o1, o2);
+ }
+ }
+ };
+
+ /**
+ * Comparator used to compare two rules according to their optimistic estimate
+ * and then their observed number of counter-instances.
+ */
+ public static Comparator optimisticThenObservedComparator = new Comparator() {
+ public int compare(Object o1, Object o2) {
+ int optimisticComparison = optimisticComparator.compare(o1, o2);
+ if (optimisticComparison != 0) {
+ return optimisticComparison;
+ } else {
+ return observedComparator.compare(o1, o2);
+ }
+ }
+ };
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.7 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/associations/tertius/SimpleLinkedList.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/associations/tertius/SimpleLinkedList.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/associations/tertius/SimpleLinkedList.java (revision 29)
@@ -0,0 +1,351 @@
+/*
+ * 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.
+ */
+
+/*
+ * SimpleLinkedList.java
+ * Copyright (C) 2003 Peter A. Flach, Nicolas Lachiche
+ *
+ * Thanks to Amelie Deltour for porting the original C code to Java
+ * and integrating it into Weka.
+ */
+
+package weka.associations.tertius;
+
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.NoSuchElementException;
+
+/**
+ * @author Peter A. Flach
+ * @author Nicolas Lachiche
+ * @version $Revision: 1.6 $
+ */
+public class SimpleLinkedList
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -1491148276509976299L;
+
+ public class LinkedListIterator
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = -2448555236100426759L;
+
+ Entry current = first;
+ Entry lastReturned = null;
+
+ public boolean hasNext() {
+ return current.next != last;
+ }
+
+ public Object next() {
+ if (current == last) {
+ throw new NoSuchElementException();
+ }
+ current = current.next;
+ lastReturned = current;
+ return current.element;
+ }
+
+ public void remove() {
+ if (lastReturned == last
+ || lastReturned == null) {
+ throw new IllegalStateException();
+ }
+ lastReturned.previous.next = lastReturned.next;
+ lastReturned.next.previous = lastReturned.previous;
+ current = lastReturned.previous;
+ lastReturned = null;
+ }
+
+ public void addBefore(Object o) {
+ if (lastReturned == null) {
+ throw new IllegalStateException();
+ }
+ Entry newEntry = new Entry(o, lastReturned, lastReturned.previous);
+ lastReturned.previous.next = newEntry;
+ lastReturned.previous = newEntry;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+ }
+
+ public class LinkedListInverseIterator
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = 6290379064027832108L;
+
+ Entry current = last;
+ Entry lastReturned = null;
+
+ public boolean hasPrevious() {
+ return current.previous != first;
+ }
+
+ public Object previous() {
+ if (current == first) {
+ throw new NoSuchElementException();
+ }
+ current = current.previous;
+ lastReturned = current;
+ return current.element;
+ }
+
+ public void remove() {
+ if (lastReturned == first
+ || lastReturned == null) {
+ throw new IllegalStateException();
+ }
+ lastReturned.previous.next = lastReturned.next;
+ lastReturned.next.previous = lastReturned.previous;
+ current = lastReturned.next;
+ lastReturned = null;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+ }
+
+
+ private static class Entry
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ private static final long serialVersionUID = 7888492479685339831L;
+
+ Object element;
+ Entry next;
+ Entry previous;
+
+ Entry(Object element, Entry next, Entry previous) {
+ this.element = element;
+ this.next = next;
+ this.previous = previous;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.6 $");
+ }
+ }
+
+ private Entry first;
+ private Entry last;
+
+ public SimpleLinkedList() {
+ first = new Entry(null, null, null);
+ last = new Entry(null, null, null);
+ first.next = last;
+ last.previous = first;
+ }
+
+ public Object removeFirst() {
+ if (first.next == last) {
+ throw new NoSuchElementException();
+ }
+ Object result = first.next.element;
+ first.next.next.previous = first;
+ first.next = first.next.next;
+ return result;
+ }
+
+ public Object getFirst() {
+ if (first.next == last) {
+ throw new NoSuchElementException();
+ }
+ return first.next.element;
+ }
+
+ public Object getLast() {
+ if (last.previous == first) {
+ throw new NoSuchElementException();
+ }
+ return last.previous.element;
+ }
+
+ public void addFirst(Object o) {
+ Entry newEntry = new Entry(o, first.next, first);
+ first.next.previous = newEntry;
+ first.next = newEntry;
+ }
+
+ public void add(Object o) {
+ Entry newEntry = new Entry(o, last, last.previous);
+ last.previous.next = newEntry;
+ last.previous = newEntry;
+ }
+
+ public void addAll(SimpleLinkedList list) {
+ last.previous.next = list.first.next;
+ list.first.next.previous = last.previous;
+ last = list.last;
+ }
+
+ public void clear() {
+ first.next = last;
+ last.previous = first;
+ }
+
+ public boolean isEmpty() {
+ return first.next == last;
+ }
+
+ public LinkedListIterator iterator() {
+ return new LinkedListIterator();
+ }
+
+ public LinkedListInverseIterator inverseIterator() {
+ return new LinkedListInverseIterator();
+ }
+
+ public int size() {
+ int result = 0;
+ LinkedListIterator iter = new LinkedListIterator();
+ while (iter.hasNext()) {
+ result++;
+ iter.next();
+ }
+ return result;
+ }
+
+ public void merge(SimpleLinkedList list, Comparator comp) {
+ LinkedListIterator iter1 = this.iterator();
+ LinkedListIterator iter2 = list.iterator();
+ Object elem1 = iter1.next();
+ Object elem2 = iter2.next();
+ while (elem2 != null) {
+ if ((elem1 == null)
+ || (comp.compare(elem2, elem1) < 0)) {
+ iter1.addBefore(elem2);
+ elem2 = iter2.next();
+ } else {
+ elem1 = iter1.next();
+ }
+ }
+ }
+
+ public void sort(Comparator comp) {
+ LinkedListIterator iter = this.iterator();
+ if (iter.hasNext()) {
+ SimpleLinkedList lower = new SimpleLinkedList();
+ SimpleLinkedList upper = new SimpleLinkedList();
+ Object ref = iter.next();
+ Object elem;
+ while (iter.hasNext()) {
+ elem = iter.next();
+ if (comp.compare(elem, ref) < 0) {
+ lower.add(elem);
+ } else {
+ upper.add(elem);
+ }
+ }
+ lower.sort(comp);
+ upper.sort(comp);
+ clear();
+ addAll(lower);
+ add(ref);
+ addAll(upper);
+ }
+ }
+
+ public String toString() {
+ StringBuffer text = new StringBuffer();
+ LinkedListIterator iter = iterator();
+ text.append("[");
+ while (iter.hasNext()) {
+ text.append(String.valueOf(iter.next()));
+ if (iter.hasNext()) {
+ text.append(", ");
+ }
+ }
+ text.append("]");
+ return text.toString();
+ }
+
+ /**
+ * Save the state of this LinkedList instance to a stream (that
+ * is, serialize it).
+ *
+ * @serialData The size of the list (the number of elements it
+ * contains) is emitted (int), followed by all of its
+ * elements (each an Object) in the proper order. */
+ private synchronized void writeObject(java.io.ObjectOutputStream s)
+ throws java.io.IOException {
+ // Write out any hidden serialization magic
+ s.defaultWriteObject();
+
+ // Write out size
+ s.writeInt(size());
+
+ // Write out all elements in the proper order.
+ for (Entry e = first.next; e != last; e = e.next)
+ s.writeObject(e.element);
+ }
+
+ /**
+ * Reconstitute this LinkedList instance from a stream (that is
+ * deserialize it).
+ */
+ private synchronized void readObject(java.io.ObjectInputStream s)
+ throws java.io.IOException, ClassNotFoundException {
+ // Read in any hidden serialization magic
+ s.defaultReadObject();
+
+ // Read in size
+ int size = s.readInt();
+
+ // Initialize header
+ first = new Entry(null, null, null);
+ last = new Entry(null, null, null);
+ first.next = last;
+ last.previous = first;
+
+ // Read in all elements in the proper order.
+ for (int i=0; i
+ *
+ * Valid options are:
+ *
+ * -h
+ * Display help.
+ *
+ * -i <name of input file>
+ * Specify the training data file.
+ *
+ * -c <class index>
+ * The index of the attribute to use as the class.
+ *
+ * -s <search method>
+ * The full class name of the search method followed by search method options
+ * (if any).
+ * Eg. -s "weka.attributeSelection.BestFirst -N 10"
+ *
+ * -x <number of folds>
+ * Perform a cross validation.
+ *
+ * -n <random number seed>
+ * Specify a random number seed. Use in conjuction with -x. (Default = 1).
+ *
+ * ------------------------------------------------------------------------
+ *
+ * Example usage as the main of an attribute evaluator (called FunkyEvaluator):
+ *
+ * public static void main(String [] args) {
+ * runEvaluator(new FunkyEvaluator(), args);
+ * }
+ *
+ *
+ *
+ * ------------------------------------------------------------------------
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.47 $
+ */
+public class AttributeSelection
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 4170171824147584330L;
+
+ /** the instances to select attributes from */
+ private Instances m_trainInstances;
+
+ /** the attribute/subset evaluator */
+ private ASEvaluation m_ASEvaluator;
+
+ /** the search method */
+ private ASSearch m_searchMethod;
+
+ /** the number of folds to use for cross validation */
+ private int m_numFolds;
+
+ /** holds a string describing the results of the attribute selection */
+ private StringBuffer m_selectionResults;
+
+ /** rank features (if allowed by the search method) */
+ private boolean m_doRank;
+
+ /** do cross validation */
+ private boolean m_doXval;
+
+ /** seed used to randomly shuffle instances for cross validation */
+ private int m_seed;
+
+ /** number of attributes requested from ranked results */
+ private int m_numToSelect;
+
+ /** the selected attributes */
+ private int [] m_selectedAttributeSet;
+
+ /** the attribute indexes and associated merits if a ranking is produced */
+ private double [][] m_attributeRanking;
+
+ /** if a feature selection run involves an attribute transformer */
+ private AttributeTransformer m_transformer = null;
+
+ /** the attribute filter for processing instances with respect to
+ the most recent feature selection run */
+ private Remove m_attributeFilter = null;
+
+ /** hold statistics for repeated feature selection, such as
+ under cross validation */
+ private double [][] m_rankResults = null;
+ private double [] m_subsetResults = null;
+ private int m_trials = 0;
+
+ /**
+ * Return the number of attributes selected from the most recent
+ * run of attribute selection
+ * @return the number of attributes selected
+ */
+ public int numberAttributesSelected() throws Exception {
+ int [] att = selectedAttributes();
+ return att.length-1;
+ }
+
+ /**
+ * get the final selected set of attributes.
+ * @return an array of attribute indexes
+ * @exception Exception if attribute selection has not been performed yet
+ */
+ public int [] selectedAttributes () throws Exception {
+ if (m_selectedAttributeSet == null) {
+ throw new Exception("Attribute selection has not been performed yet!");
+ }
+ return m_selectedAttributeSet;
+ }
+
+ /**
+ * get the final ranking of the attributes.
+ * @return a two dimensional array of ranked attribute indexes and their
+ * associated merit scores as doubles.
+ * @exception Exception if a ranking has not been produced
+ */
+ public double [][] rankedAttributes () throws Exception {
+ if (m_attributeRanking == null) {
+ throw new Exception("Ranking has not been performed");
+ }
+ return m_attributeRanking;
+ }
+
+ /**
+ * set the attribute/subset evaluator
+ * @param evaluator the evaluator to use
+ */
+ public void setEvaluator (ASEvaluation evaluator) {
+ m_ASEvaluator = evaluator;
+ }
+
+ /**
+ * set the search method
+ * @param search the search method to use
+ */
+ public void setSearch (ASSearch search) {
+ m_searchMethod = search;
+
+ if (m_searchMethod instanceof RankedOutputSearch) {
+ setRanking(((RankedOutputSearch)m_searchMethod).getGenerateRanking());
+ }
+ }
+
+ /**
+ * set the number of folds for cross validation
+ * @param folds the number of folds
+ */
+ public void setFolds (int folds) {
+ m_numFolds = folds;
+ }
+
+ /**
+ * produce a ranking (if possible with the set search and evaluator)
+ * @param r true if a ranking is to be produced
+ */
+ public void setRanking (boolean r) {
+ m_doRank = r;
+ }
+
+ /**
+ * do a cross validation
+ * @param x true if a cross validation is to be performed
+ */
+ public void setXval (boolean x) {
+ m_doXval = x;
+ }
+
+ /**
+ * set the seed for use in cross validation
+ * @param s the seed
+ */
+ public void setSeed (int s) {
+ m_seed = s;
+ }
+
+ /**
+ * get a description of the attribute selection
+ * @return a String describing the results of attribute selection
+ */
+ public String toResultsString() {
+ return m_selectionResults.toString();
+ }
+
+ /**
+ * reduce the dimensionality of a set of instances to include only those
+ * attributes chosen by the last run of attribute selection.
+ * @param in the instances to be reduced
+ * @return a dimensionality reduced set of instances
+ * @exception Exception if the instances can't be reduced
+ */
+ public Instances reduceDimensionality(Instances in) throws Exception {
+ if (m_attributeFilter == null) {
+ throw new Exception("No feature selection has been performed yet!");
+ }
+
+ if (m_transformer != null) {
+ Instances transformed = new Instances(m_transformer.transformedHeader(),
+ in.numInstances());
+ for (int i=0;i 0) {
+ CvString.append(Utils.doubleToString(Math.
+ abs(m_rankResults[0][s[i]]),
+ 6, 3)
+ + " +-"
+ + Utils.doubleToString(m_rankResults[2][s[i]], 6, 3)
+ + " "
+ + Utils.doubleToString(m_rankResults[1][s[i]],
+ fieldWidth+2, 1)
+ + " +-"
+ + Utils.doubleToString(m_rankResults[3][s[i]], 5, 2)
+ +" "
+ + Utils.doubleToString(((double)(s[i] + 1)),
+ fieldWidth, 0)
+ + " "
+ + m_trainInstances.attribute(s[i]).name()
+ + "\n");
+ }
+ }
+ }
+ else {
+ CvString.append("number of folds (%) attribute\n");
+
+ for (int i = 0; i < m_subsetResults.length; i++) {
+ if ((m_ASEvaluator instanceof UnsupervisedSubsetEvaluator) ||
+ (i != m_trainInstances.classIndex())) {
+ CvString.append(Utils.doubleToString(m_subsetResults[i], 12, 0)
+ + "("
+ + Utils.doubleToString((m_subsetResults[i] /
+ m_numFolds * 100.0)
+ , 3, 0)
+ + " %) "
+ + Utils.doubleToString(((double)(i + 1)),
+ fieldWidth, 0)
+ + " "
+ + m_trainInstances.attribute(i).name()
+ + "\n");
+ }
+ }
+ }
+
+ return CvString.toString();
+ }
+
+ /**
+ * Select attributes for a split of the data. Calling this function
+ * updates the statistics on attribute selection. CVResultsString()
+ * returns a string summarizing the results of repeated calls to
+ * this function. Assumes that splits are from the same dataset---
+ * ie. have the same number and types of attributes as previous
+ * splits.
+ *
+ * @param split the instances to select attributes from
+ * @exception Exception if an error occurs
+ */
+ public void selectAttributesCVSplit(Instances split) throws Exception {
+ double[][] attributeRanking = null;
+
+ // if the train instances are null then set equal to this split.
+ // If this is the case then this function is more than likely being
+ // called from outside this class in order to obtain CV statistics
+ // and all we need m_trainIstances for is to get at attribute names
+ // and types etc.
+ if (m_trainInstances == null) {
+ m_trainInstances = split;
+ }
+
+ // create space to hold statistics
+ if (m_rankResults == null && m_subsetResults == null) {
+ m_subsetResults = new double[split.numAttributes()];
+ m_rankResults = new double[4][split.numAttributes()];
+ }
+
+ m_ASEvaluator.buildEvaluator(split);
+ // Do the search
+ int[] attributeSet = m_searchMethod.search(m_ASEvaluator,
+ split);
+ // Do any postprocessing that a attribute selection method might
+ // require
+ attributeSet = m_ASEvaluator.postProcess(attributeSet);
+
+ if ((m_searchMethod instanceof RankedOutputSearch) &&
+ (m_doRank == true)) {
+ attributeRanking = ((RankedOutputSearch)m_searchMethod).
+ rankedAttributes();
+
+ // System.out.println(attributeRanking[0][1]);
+ for (int j = 0; j < attributeRanking.length; j++) {
+ // merit
+ m_rankResults[0][(int)attributeRanking[j][0]] +=
+ attributeRanking[j][1];
+ // squared merit
+ m_rankResults[2][(int)attributeRanking[j][0]] +=
+ (attributeRanking[j][1]*attributeRanking[j][1]);
+ // rank
+ m_rankResults[1][(int)attributeRanking[j][0]] += (j + 1);
+ // squared rank
+ m_rankResults[3][(int)attributeRanking[j][0]] += (j + 1)*(j + 1);
+ // += (attributeRanking[j][0] * attributeRanking[j][0]);
+ }
+ } else {
+ for (int j = 0; j < attributeSet.length; j++) {
+ m_subsetResults[attributeSet[j]]++;
+ }
+ }
+
+ m_trials++;
+ }
+
+ /**
+ * Perform a cross validation for attribute selection. With subset
+ * evaluators the number of times each attribute is selected over
+ * the cross validation is reported. For attribute evaluators, the
+ * average merit and average ranking + std deviation is reported for
+ * each attribute.
+ *
+ * @return the results of cross validation as a String
+ * @exception Exception if an error occurs during cross validation
+ */
+ public String CrossValidateAttributes () throws Exception {
+ Instances cvData = new Instances(m_trainInstances);
+ Instances train;
+
+ Random random = new Random(m_seed);
+ cvData.randomize(random);
+
+ if (!(m_ASEvaluator instanceof UnsupervisedSubsetEvaluator) &&
+ !(m_ASEvaluator instanceof UnsupervisedAttributeEvaluator)) {
+ if (cvData.classAttribute().isNominal()) {
+ cvData.stratify(m_numFolds);
+ }
+
+ }
+
+ for (int i = 0; i < m_numFolds; i++) {
+ // Perform attribute selection
+ train = cvData.trainCV(m_numFolds, i, random);
+ selectAttributesCVSplit(train);
+ }
+
+ return CVResultsString();
+ }
+
+ /**
+ * Perform attribute selection on the supplied training instances.
+ *
+ * @param data the instances to select attributes from
+ * @exception Exception if there is a problem during selection
+ */
+ public void SelectAttributes (Instances data) throws Exception {
+ int [] attributeSet;
+
+ m_transformer = null;
+ m_attributeFilter = null;
+ m_trainInstances = data;
+
+ if (m_doXval == true && (m_ASEvaluator instanceof AttributeTransformer)) {
+ throw new Exception("Can't cross validate an attribute transformer.");
+ }
+
+ if (m_ASEvaluator instanceof SubsetEvaluator &&
+ m_searchMethod instanceof Ranker) {
+ throw new Exception(m_ASEvaluator.getClass().getName()
+ +" must use a search method other than Ranker");
+ }
+
+ if (m_ASEvaluator instanceof AttributeEvaluator &&
+ !(m_searchMethod instanceof Ranker)) {
+ // System.err.println("AttributeEvaluators must use a Ranker search "
+ // +"method. Switching to Ranker...");
+ // m_searchMethod = new Ranker();
+ throw new Exception("AttributeEvaluators must use the Ranker search "
+ + "method");
+ }
+
+ if (m_searchMethod instanceof RankedOutputSearch) {
+ m_doRank = ((RankedOutputSearch)m_searchMethod).getGenerateRanking();
+ }
+
+ if (m_ASEvaluator instanceof UnsupervisedAttributeEvaluator ||
+ m_ASEvaluator instanceof UnsupervisedSubsetEvaluator) {
+ // unset the class index
+ // m_trainInstances.setClassIndex(-1);
+ } else {
+ // check that a class index has been set
+ if (m_trainInstances.classIndex() < 0) {
+ m_trainInstances.setClassIndex(m_trainInstances.numAttributes()-1);
+ }
+ }
+
+ // Initialize the attribute evaluator
+ m_ASEvaluator.buildEvaluator(m_trainInstances);
+ if (m_ASEvaluator instanceof AttributeTransformer) {
+ m_trainInstances =
+ ((AttributeTransformer)m_ASEvaluator).transformedHeader();
+ m_transformer = (AttributeTransformer)m_ASEvaluator;
+ }
+ int fieldWidth = (int)(Math.log(m_trainInstances.numAttributes()) +1.0);
+
+ // Do the search
+ attributeSet = m_searchMethod.search(m_ASEvaluator,
+ m_trainInstances);
+
+ // try and determine if the search method uses an attribute transformer---
+ // this is a bit of a hack to make things work properly with RankSearch
+ // using PrincipalComponents as its attribute ranker
+ try {
+ BeanInfo bi = Introspector.getBeanInfo(m_searchMethod.getClass());
+ PropertyDescriptor properties[];
+ MethodDescriptor methods[];
+ // methods = bi.getMethodDescriptors();
+ properties = bi.getPropertyDescriptors();
+ for (int i=0;i 0) {
+ precision = Math.abs((Math.log(Math.abs(precision)) /
+ Math.log(10)))+3;
+ }
+ if (precision > f_p) {
+ f_p = (int)precision;
+ }
+
+ if (intPart == 0) {
+ if (w_p < 2) {
+ w_p = 2;
+ }
+ } else if ((Math.abs((Math.log(Math.abs(m_attributeRanking[i][1]))
+ / Math.log(10)))+1) > w_p) {
+ if (m_attributeRanking[i][1] > 0) {
+ w_p = (int)Math.abs((Math.log(Math.abs(m_attributeRanking[i][1]))
+ / Math.log(10)))+1;
+ }
+ }
+ }
+
+ for (int i = 0; i < m_numToSelect; i++) {
+ m_selectionResults.
+ append(Utils.doubleToString(m_attributeRanking[i][1],
+ f_p+w_p+1,f_p)
+ + Utils.doubleToString((m_attributeRanking[i][0] + 1),
+ fieldWidth+1,0)
+ + " "
+ + m_trainInstances.
+ attribute((int)m_attributeRanking[i][0]).name()
+ + "\n");
+ }
+
+ // set up the selected attributes array - usable by a filter or
+ // whatever
+ if (m_trainInstances.classIndex() >= 0) {
+ if ((!(m_ASEvaluator instanceof UnsupervisedSubsetEvaluator)
+ && !(m_ASEvaluator instanceof UnsupervisedAttributeEvaluator)) ||
+ m_ASEvaluator instanceof AttributeTransformer) {
+ // one more for the class
+ m_selectedAttributeSet = new int[m_numToSelect + 1];
+ m_selectedAttributeSet[m_numToSelect] =
+ m_trainInstances.classIndex();
+ } else {
+ m_selectedAttributeSet = new int[m_numToSelect];
+ }
+ } else {
+ m_selectedAttributeSet = new int[m_numToSelect];
+ }
+
+ m_selectionResults.append("\nSelected attributes: ");
+
+ for (int i = 0; i < m_numToSelect; i++) {
+ m_selectedAttributeSet[i] = (int)m_attributeRanking[i][0];
+
+ if (i == m_numToSelect - 1) {
+ m_selectionResults.append(((int)m_attributeRanking[i][0] + 1)
+ + " : "
+ + (i + 1)
+ + "\n");
+ }
+ else {
+ m_selectionResults.append(((int)m_attributeRanking[i][0] + 1));
+ m_selectionResults.append(",");
+ }
+ }
+ } else {
+ // set up the selected attributes array - usable by a filter or
+ // whatever
+ if ((!(m_ASEvaluator instanceof UnsupervisedSubsetEvaluator)
+ && !(m_ASEvaluator instanceof UnsupervisedAttributeEvaluator)) ||
+ m_trainInstances.classIndex() >= 0)
+ // one more for the class
+ {
+ m_selectedAttributeSet = new int[attributeSet.length + 1];
+ m_selectedAttributeSet[attributeSet.length] =
+ m_trainInstances.classIndex();
+ }
+ else {
+ m_selectedAttributeSet = new int[attributeSet.length];
+ }
+
+ for (int i = 0; i < attributeSet.length; i++) {
+ m_selectedAttributeSet[i] = attributeSet[i];
+ }
+
+ m_selectionResults.append("Selected attributes: ");
+
+ for (int i = 0; i < attributeSet.length; i++) {
+ if (i == (attributeSet.length - 1)) {
+ m_selectionResults.append((attributeSet[i] + 1)
+ + " : "
+ + attributeSet.length
+ + "\n");
+ }
+ else {
+ m_selectionResults.append((attributeSet[i] + 1) + ",");
+ }
+ }
+
+ for (int i=0;i train.numAttributes()))) {
+ throw new Exception("Class index out of range.");
+ }
+
+ if (classIndex != -1) {
+ train.setClassIndex(classIndex - 1);
+ }
+ else {
+ // classIndex = train.numAttributes();
+ // train.setClassIndex(classIndex - 1);
+ }
+
+ foldsString = Utils.getOption('x', options);
+
+ if (foldsString.length() != 0) {
+ folds = Integer.parseInt(foldsString);
+ doCrossVal = true;
+ }
+
+ trainSelector.setFolds(folds);
+ trainSelector.setXval(doCrossVal);
+
+ seedString = Utils.getOption('n', options);
+
+ if (seedString.length() != 0) {
+ seed = Integer.parseInt(seedString);
+ }
+
+ trainSelector.setSeed(seed);
+
+ searchName = Utils.getOption('s', options);
+
+ if ((searchName.length() == 0) &&
+ (!(ASEvaluator instanceof AttributeEvaluator))) {
+ throw new Exception("No search method given.");
+ }
+
+ if (searchName.length() != 0) {
+ searchName = searchName.trim();
+ // split off any search options
+ int breakLoc = searchName.indexOf(' ');
+ searchClassName = searchName;
+ String searchOptionsString = "";
+
+ if (breakLoc != -1) {
+ searchClassName = searchName.substring(0, breakLoc);
+ searchOptionsString = searchName.substring(breakLoc).trim();
+ searchOptions = Utils.splitOptions(searchOptionsString);
+ }
+ }
+ else {
+ try {
+ searchClassName = new String("weka.attributeSelection.Ranker");
+ searchMethod = (ASSearch)Class.
+ forName(searchClassName).newInstance();
+ }
+ catch (Exception e) {
+ throw new Exception("Can't create Ranker object");
+ }
+ }
+
+ // if evaluator is a subset evaluator
+ // create search method and set its options (if any)
+ if (searchMethod == null) {
+ searchMethod = ASSearch.forName(searchClassName, searchOptions);
+ }
+
+ // set the search method
+ trainSelector.setSearch(searchMethod);
+ }
+ catch (Exception e) {
+ throw new Exception('\n' + e.getMessage()
+ + makeOptionString(ASEvaluator, searchMethod));
+ }
+
+ try {
+ // Set options for ASEvaluator
+ if (ASEvaluator instanceof OptionHandler) {
+ ((OptionHandler)ASEvaluator).setOptions(options);
+ }
+
+ /* // Set options for Search method
+ if (searchMethod instanceof OptionHandler)
+ {
+ if (searchOptions != null)
+ {
+ ((OptionHandler)searchMethod).setOptions(searchOptions);
+ }
+ }
+ Utils.checkForRemainingOptions(searchOptions); */
+ }
+ catch (Exception e) {
+ throw new Exception("\n" + e.getMessage()
+ + makeOptionString(ASEvaluator, searchMethod));
+ }
+
+ try {
+ Utils.checkForRemainingOptions(options);
+ }
+ catch (Exception e) {
+ throw new Exception('\n' + e.getMessage()
+ + makeOptionString(ASEvaluator, searchMethod));
+ }
+
+ if (helpRequested) {
+ System.out.println(makeOptionString(ASEvaluator, searchMethod));
+ System.exit(0);
+ }
+
+ // set the attribute evaluator
+ trainSelector.setEvaluator(ASEvaluator);
+
+ // do the attribute selection
+ trainSelector.SelectAttributes(train);
+
+ // return the results string
+ return trainSelector.toResultsString();
+ }
+
+
+ /**
+ * Assembles a text description of the attribute selection results.
+ *
+ * @return a string describing the results of attribute selection.
+ */
+ private String printSelectionResults () {
+ StringBuffer text = new StringBuffer();
+ text.append("\n\n=== Attribute Selection on all input data ===\n\n"
+ + "Search Method:\n");
+ text.append(m_searchMethod.toString());
+ text.append("\nAttribute ");
+
+ if (m_ASEvaluator instanceof SubsetEvaluator) {
+ text.append("Subset Evaluator (");
+ }
+ else {
+ text.append("Evaluator (");
+ }
+
+ if (!(m_ASEvaluator instanceof UnsupervisedSubsetEvaluator)
+ && !(m_ASEvaluator instanceof UnsupervisedAttributeEvaluator)) {
+ text.append("supervised, ");
+ text.append("Class (");
+
+ if (m_trainInstances.attribute(m_trainInstances.classIndex())
+ .isNumeric()) {
+ text.append("numeric): ");
+ }
+ else {
+ text.append("nominal): ");
+ }
+
+ text.append((m_trainInstances.classIndex() + 1)
+ + " "
+ + m_trainInstances.attribute(m_trainInstances
+ .classIndex()).name()
+ + "):\n");
+ }
+ else {
+ text.append("unsupervised):\n");
+ }
+
+ text.append(m_ASEvaluator.toString() + "\n");
+ return text.toString();
+ }
+
+
+ /**
+ * Make up the help string giving all the command line options
+ *
+ * @param ASEvaluator the attribute evaluator to include options for
+ * @param searchMethod the search method to include options for
+ * @return a string detailing the valid command line options
+ * @throws Exception if something goes wrong
+ */
+ private static String makeOptionString (ASEvaluation ASEvaluator,
+ ASSearch searchMethod)
+ throws Exception {
+
+ StringBuffer optionsText = new StringBuffer("");
+ // General options
+ optionsText.append("\n\nGeneral options:\n\n");
+ optionsText.append("-h\n\tdisplay this help\n");
+ optionsText.append("-i \n");
+ optionsText.append("\tSets training file.\n");
+ optionsText.append("-c \n");
+ optionsText.append("\tSets the class index for supervised attribute\n");
+ optionsText.append("\tselection. Default=last column.\n");
+ optionsText.append("-s \n");
+ optionsText.append("\tSets search method for subset evaluators.\n");
+ optionsText.append("-x \n");
+ optionsText.append("\tPerform a cross validation.\n");
+ optionsText.append("-n \n");
+ optionsText.append("\tUse in conjunction with -x.\n");
+
+ // Get attribute evaluator-specific options
+ if (ASEvaluator instanceof OptionHandler) {
+ optionsText.append("\nOptions specific to "
+ + ASEvaluator.getClass().getName()
+ + ":\n\n");
+ Enumeration enu = ((OptionHandler)ASEvaluator).listOptions();
+
+ while (enu.hasMoreElements()) {
+ Option option = (Option)enu.nextElement();
+ optionsText.append(option.synopsis() + '\n');
+ optionsText.append(option.description() + "\n");
+ }
+ }
+
+ if (searchMethod != null) {
+ if (searchMethod instanceof OptionHandler) {
+ optionsText.append("\nOptions specific to "
+ + searchMethod.getClass().getName()
+ + ":\n\n");
+ Enumeration enu = ((OptionHandler)searchMethod).listOptions();
+
+ while (enu.hasMoreElements()) {
+ Option option = (Option)enu.nextElement();
+ optionsText.append(option.synopsis() + '\n');
+ optionsText.append(option.description() + "\n");
+ }
+ }
+ }
+ else {
+ if (ASEvaluator instanceof SubsetEvaluator) {
+ System.out.println("No search method given.");
+ }
+ }
+
+ return optionsText.toString();
+ }
+
+
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ try {
+ if (args.length == 0) {
+ throw new Exception("The first argument must be the name of an "
+ + "attribute/subset evaluator");
+ }
+
+ String EvaluatorName = args[0];
+ args[0] = "";
+ ASEvaluation newEval = ASEvaluation.forName(EvaluatorName, null);
+ System.out.println(SelectAttributes(newEval, args));
+ }
+ catch (Exception e) {
+ System.out.println(e.getMessage());
+ }
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.47 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/AttributeSetEvaluator.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/AttributeSetEvaluator.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/AttributeSetEvaluator.java (revision 29)
@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+ /*
+ * RELEASE INFORMATION (December 27, 2004)
+ *
+ * FCBF algorithm:
+ * Template obtained from Weka
+ * Developped for Weka by Zheng Alan Zhao
+ * December 27, 2004
+ *
+ * FCBF algorithm is a feature selection method based on Symmetrical Uncertainty
+ * Measurement for relevance redundancy analysis. The details of FCBF algorithm are
+ * in L. Yu and H. Liu. Feature selection for high-dimensional data: a fast
+ * correlation-based filter solution. In Proceedings of the twentieth International
+ * Conference on Machine Learning, pages 856--863, 2003.
+ *
+ *
+ * CONTACT INFORMATION
+ *
+ * For algorithm implementation:
+ * Zheng Zhao: zhaozheng at asu.edu
+ *
+ * For the algorithm:
+ * Lei Yu: leiyu at asu.edu
+ * Huan Liu: hliu at asu.edu
+ *
+ * Data Mining and Machine Learning Lab
+ * Computer Science and Engineering Department
+ * Fulton School of Engineering
+ * Arizona State University
+ * Tempe, AZ 85287
+ *
+ * AttributeSetEvaluator.java
+ *
+ * Copyright (C) 2004 Data Mining and Machine Learning Lab,
+ * Computer Science and Engineering Department,
+ * Fulton School of Engineering,
+ * Arizona State University
+ *
+ */
+
+package weka.attributeSelection;
+
+
+/**
+ * Abstract attribute set evaluator.
+ *
+ * @author Zheng Zhao: zhaozheng at asu.edu
+ * @version $Revision: 1.3 $
+ */
+public abstract class AttributeSetEvaluator extends ASEvaluation {
+
+ /** for serialization */
+ private static final long serialVersionUID = -5744881009422257389L;
+
+ // ===============
+ // Public methods.
+ // ===============
+
+ /**
+ * evaluates an individual attribute
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the "merit" of the attribute
+ * @exception Exception if the attribute could not be evaluated
+ */
+ public abstract double evaluateAttribute(int attribute) throws Exception;
+
+ /**
+ * Evaluates a set of attributes
+ *
+ * @param attributes an int[] value
+ * @param classAttributes an int[] value
+ * @return a double value
+ * @exception Exception if an error occurs
+ */
+ public abstract double evaluateAttribute(int[] attributes, int[] classAttributes)
+ throws Exception;
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/AttributeTransformer.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/AttributeTransformer.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/AttributeTransformer.java (revision 29)
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+/*
+ * AttributeTransformer.java
+ * Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instance;
+import weka.core.Instances;
+
+/**
+ * Abstract attribute transformer. Transforms the dataset.
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 4613 $
+ */
+public interface AttributeTransformer {
+ // ===============
+ // Public methods.
+ // ===============
+
+ /**
+ * Returns just the header for the transformed data (ie. an empty
+ * set of instances. This is so that AttributeSelection can
+ * determine the structure of the transformed data without actually
+ * having to get all the transformed data through getTransformedData().
+ * @return the header of the transformed data.
+ * @exception Exception if the header of the transformed data can't
+ * be determined.
+ */
+ Instances transformedHeader() throws Exception;
+
+ /**
+ * Transform the supplied data set (assumed to be the same format
+ * as the training data)
+ * @return A set of instances representing the transformed data
+ * @exception Exception if the attribute could not be evaluated
+ */
+ Instances transformedData(Instances data) throws Exception;
+
+ /**
+ * Transforms an instance in the format of the original data to the
+ * transformed space
+ * @return a transformed instance
+ * @exception Exception if the instance could not be transformed
+ */
+ Instance convertInstance(Instance instance) throws Exception;
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/BestFirst.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/BestFirst.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/BestFirst.java (revision 29)
@@ -0,0 +1,932 @@
+/*
+ * 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.
+ */
+
+/*
+ * BestFirst.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.FastVector;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Range;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SelectedTag;
+import weka.core.Tag;
+import weka.core.Utils;
+
+import java.io.Serializable;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+
+ * BestFirst:
+ *
+ * Searches the space of attribute subsets by greedy hillclimbing augmented with a backtracking facility. Setting the number of consecutive non-improving nodes allowed controls the level of backtracking done. Best first may start with the empty set of attributes and search forward, or start with the full set of attributes and search backward, or start at any point and search in both directions (by considering all possible single attribute additions and deletions at a given point).
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ *
+ * -D <0 = backward | 1 = forward | 2 = bi-directional>
+ * Direction of search. (default = 1).
+ *
+ * -N <num>
+ * Number of non-improving nodes to
+ * consider before terminating search.
+ *
+ * -S <num>
+ * Size of lookup cache for evaluated subsets.
+ * Expressed as a multiple of the number of
+ * attributes in the data set. (default = 1)
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * Martin Guetlein (cashing merit of expanded nodes)
+ * @version $Revision: 1.29 $
+ */
+public class BestFirst
+ extends ASSearch
+ implements OptionHandler, StartSetHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 7841338689536821867L;
+
+ // Inner classes
+ /**
+ * Class for a node in a linked list. Used in best first search.
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ **/
+ public class Link2
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -8236598311516351420L;
+
+ /* BitSet group; */
+ Object [] m_data;
+ double m_merit;
+
+
+ /**
+ * Constructor
+ */
+ public Link2 (Object [] data, double mer) {
+ // group = (BitSet)gr.clone();
+ m_data = data;
+ m_merit = mer;
+ }
+
+
+ /** Get a group */
+ public Object [] getData () {
+ return m_data;
+ }
+
+
+ public String toString () {
+ return ("Node: " + m_data.toString() + " " + m_merit);
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.29 $");
+ }
+ }
+
+
+ /**
+ * Class for handling a linked list. Used in best first search.
+ * Extends the Vector class.
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ **/
+ public class LinkedList2
+ extends FastVector {
+
+ /** for serialization */
+ static final long serialVersionUID = 3250538292330398929L;
+
+ /** Max number of elements in the list */
+ int m_MaxSize;
+
+ // ================
+ // Public methods
+ // ================
+ public LinkedList2 (int sz) {
+ super();
+ m_MaxSize = sz;
+ }
+
+
+ /**
+ * removes an element (Link) at a specific index from the list.
+ * @param index the index of the element to be removed.
+ **/
+ public void removeLinkAt (int index)
+ throws Exception {
+
+ if ((index >= 0) && (index < size())) {
+ removeElementAt(index);
+ }
+ else {
+ throw new Exception("index out of range (removeLinkAt)");
+ }
+ }
+
+
+ /**
+ * returns the element (Link) at a specific index from the list.
+ * @param index the index of the element to be returned.
+ **/
+ public Link2 getLinkAt (int index)
+ throws Exception {
+
+ if (size() == 0) {
+ throw new Exception("List is empty (getLinkAt)");
+ }
+ else {if ((index >= 0) && (index < size())) {
+ return ((Link2)(elementAt(index)));
+ }
+ else {
+ throw new Exception("index out of range (getLinkAt)");
+ }
+ }
+ }
+
+
+ /**
+ * adds an element (Link) to the list.
+ * @param data the attribute set specification
+ * @param mer the "merit" of this attribute set
+ **/
+ public void addToList (Object [] data, double mer)
+ throws Exception {
+ Link2 newL = new Link2(data, mer);
+
+ if (size() == 0) {
+ addElement(newL);
+ }
+ else {if (mer > ((Link2)(firstElement())).m_merit) {
+ if (size() == m_MaxSize) {
+ removeLinkAt(m_MaxSize - 1);
+ }
+
+ //----------
+ insertElementAt(newL, 0);
+ }
+ else {
+ int i = 0;
+ int size = size();
+ boolean done = false;
+
+ //------------
+ // don't insert if list contains max elements an this
+ // is worst than the last
+ if ((size == m_MaxSize) && (mer <= ((Link2)(lastElement())).m_merit)) {
+
+ }
+ //---------------
+ else {
+ while ((!done) && (i < size)) {
+ if (mer > ((Link2)(elementAt(i))).m_merit) {
+ if (size == m_MaxSize) {
+ removeLinkAt(m_MaxSize - 1);
+ }
+
+ // ---------------------
+ insertElementAt(newL, i);
+ done = true;
+ }
+ else {if (i == size - 1) {
+ addElement(newL);
+ done = true;
+ }
+ else {
+ i++;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.29 $");
+ }
+ }
+
+ // member variables
+ /** maximum number of stale nodes before terminating search */
+ protected int m_maxStale;
+
+ /** 0 == backward search, 1 == forward search, 2 == bidirectional */
+ protected int m_searchDirection;
+
+ /** search direction: backward */
+ protected static final int SELECTION_BACKWARD = 0;
+ /** search direction: forward */
+ protected static final int SELECTION_FORWARD = 1;
+ /** search direction: bidirectional */
+ protected static final int SELECTION_BIDIRECTIONAL = 2;
+ /** search directions */
+ public static final Tag [] TAGS_SELECTION = {
+ new Tag(SELECTION_BACKWARD, "Backward"),
+ new Tag(SELECTION_FORWARD, "Forward"),
+ new Tag(SELECTION_BIDIRECTIONAL, "Bi-directional"),
+ };
+
+ /** holds an array of starting attributes */
+ protected int[] m_starting;
+
+ /** holds the start set for the search as a Range */
+ protected Range m_startRange;
+
+ /** does the data have a class */
+ protected boolean m_hasClass;
+
+ /** holds the class index */
+ protected int m_classIndex;
+
+ /** number of attributes in the data */
+ protected int m_numAttribs;
+
+ /** total number of subsets evaluated during a search */
+ protected int m_totalEvals;
+
+ /** for debugging */
+ protected boolean m_debug;
+
+ /** holds the merit of the best subset found */
+ protected double m_bestMerit;
+
+ /** holds the maximum size of the lookup cache for evaluated subsets */
+ protected int m_cacheSize;
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search method suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "BestFirst:\n\n"
+ +"Searches the space of attribute subsets by greedy hillclimbing "
+ +"augmented with a backtracking facility. Setting the number of "
+ +"consecutive non-improving nodes allowed controls the level of "
+ +"backtracking done. Best first may start with the empty set of "
+ +"attributes and search forward, or start with the full set of "
+ +"attributes and search backward, or start at any point and search "
+ +"in both directions (by considering all possible single attribute "
+ +"additions and deletions at a given point).\n";
+ }
+
+ /**
+ *Constructor
+ */
+ public BestFirst () {
+ resetOptions();
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ *
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(4);
+
+ newVector.addElement(new Option("\tSpecify a starting set of attributes."
+ + "\n\tEg. 1,3,5-7."
+ ,"P",1
+ , "-P "));
+ newVector.addElement(new Option("\tDirection of search. (default = 1)."
+ , "D", 1
+ , "-D <0 = backward | 1 = forward "
+ + "| 2 = bi-directional>"));
+ newVector.addElement(new Option("\tNumber of non-improving nodes to"
+ + "\n\tconsider before terminating search."
+ , "N", 1, "-N "));
+ newVector.addElement(new Option("\tSize of lookup cache for evaluated subsets."
+ +"\n\tExpressed as a multiple of the number of"
+ +"\n\tattributes in the data set. (default = 1)",
+ "S", 1, "-S "));
+
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ *
+ * -D <0 = backward | 1 = forward | 2 = bi-directional>
+ * Direction of search. (default = 1).
+ *
+ * -N <num>
+ * Number of non-improving nodes to
+ * consider before terminating search.
+ *
+ * -S <num>
+ * Size of lookup cache for evaluated subsets.
+ * Expressed as a multiple of the number of
+ * attributes in the data set. (default = 1)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ *
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ optionString = Utils.getOption('D', options);
+
+ if (optionString.length() != 0) {
+ setDirection(new SelectedTag(Integer.parseInt(optionString),
+ TAGS_SELECTION));
+ } else {
+ setDirection(new SelectedTag(SELECTION_FORWARD, TAGS_SELECTION));
+ }
+
+ optionString = Utils.getOption('N', options);
+
+ if (optionString.length() != 0) {
+ setSearchTermination(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('S', options);
+ if (optionString.length() != 0) {
+ setLookupCacheSize(Integer.parseInt(optionString));
+ }
+
+ m_debug = Utils.getFlag('Z', options);
+ }
+
+ /**
+ * Set the maximum size of the evaluated subset cache (hashtable). This is
+ * expressed as a multiplier for the number of attributes in the data set.
+ * (default = 1).
+ *
+ * @param size the maximum size of the hashtable
+ */
+ public void setLookupCacheSize(int size) {
+ if (size >= 0) {
+ m_cacheSize = size;
+ }
+ }
+
+ /**
+ * Return the maximum size of the evaluated subset cache (expressed as a multiplier
+ * for the number of attributes in a data set.
+ *
+ * @return the maximum size of the hashtable.
+ */
+ public int getLookupCacheSize() {
+ return m_cacheSize;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String lookupCacheSizeTipText() {
+ return "Set the maximum size of the lookup cache of evaluated subsets. This is "
+ +"expressed as a multiplier of the number of attributes in the data set. "
+ +"(default = 1).";
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String startSetTipText() {
+ return "Set the start point for the search. This is specified as a comma "
+ +"seperated list off attribute indexes starting at 1. It can include "
+ +"ranges. Eg. 1,2,5-9,17.";
+ }
+
+ /**
+ * Sets a starting set of attributes for the search. It is the
+ * search method's responsibility to report this start set (if any)
+ * in its toString() method.
+ * @param startSet a string containing a list of attributes (and or ranges),
+ * eg. 1,2,6,10-15.
+ * @throws Exception if start set can't be set.
+ */
+ public void setStartSet (String startSet) throws Exception {
+ m_startRange.setRanges(startSet);
+ }
+
+ /**
+ * Returns a list of attributes (and or attribute ranges) as a String
+ * @return a list of attributes (and or attribute ranges)
+ */
+ public String getStartSet () {
+ return m_startRange.getRanges();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String searchTerminationTipText() {
+ return "Set the amount of backtracking. Specify the number of ";
+ }
+
+ /**
+ * Set the numnber of non-improving nodes to consider before terminating
+ * search.
+ *
+ * @param t the number of non-improving nodes
+ * @throws Exception if t is less than 1
+ */
+ public void setSearchTermination (int t)
+ throws Exception {
+ if (t < 1) {
+ throw new Exception("Value of -N must be > 0.");
+ }
+
+ m_maxStale = t;
+ }
+
+
+ /**
+ * Get the termination criterion (number of non-improving nodes).
+ *
+ * @return the number of non-improving nodes
+ */
+ public int getSearchTermination () {
+ return m_maxStale;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String directionTipText() {
+ return "Set the direction of the search.";
+ }
+
+ /**
+ * Set the search direction
+ *
+ * @param d the direction of the search
+ */
+ public void setDirection (SelectedTag d) {
+
+ if (d.getTags() == TAGS_SELECTION) {
+ m_searchDirection = d.getSelectedTag().getID();
+ }
+ }
+
+
+ /**
+ * Get the search direction
+ *
+ * @return the direction of the search
+ */
+ public SelectedTag getDirection () {
+
+ return new SelectedTag(m_searchDirection, TAGS_SELECTION);
+ }
+
+
+ /**
+ * Gets the current settings of BestFirst.
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[6];
+ int current = 0;
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = ""+startSetToString();
+ }
+ options[current++] = "-D";
+ options[current++] = "" + m_searchDirection;
+ options[current++] = "-N";
+ options[current++] = "" + m_maxStale;
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is
+ * used by getOptions to return the actual attributes specified
+ * as the starting set. This is better than using m_startRanges.getRanges()
+ * as the same start set can be specified in different ways from the
+ * command line---eg 1,2,3 == 1-3. This is to ensure that stuff that
+ * is stored in a database is comparable.
+ * @return a comma seperated list of individual attribute numbers as a String
+ */
+ private String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ (m_hasClass == true && i != m_classIndex)) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ }
+ else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * returns a description of the search as a String
+ * @return a description of the search
+ */
+ public String toString () {
+ StringBuffer BfString = new StringBuffer();
+ BfString.append("\tBest first.\n\tStart set: ");
+
+ if (m_starting == null) {
+ BfString.append("no attributes\n");
+ }
+ else {
+ BfString.append(startSetToString()+"\n");
+ }
+
+ BfString.append("\tSearch direction: ");
+
+ if (m_searchDirection == SELECTION_BACKWARD) {
+ BfString.append("backward\n");
+ }
+ else {if (m_searchDirection == SELECTION_FORWARD) {
+ BfString.append("forward\n");
+ }
+ else {
+ BfString.append("bi-directional\n");
+ }
+ }
+
+ BfString.append("\tStale search after "
+ + m_maxStale + " node expansions\n");
+ BfString.append("\tTotal number of subsets evaluated: "
+ + m_totalEvals + "\n");
+ BfString.append("\tMerit of best subset found: "
+ +Utils.doubleToString(Math.abs(m_bestMerit),8,3)+"\n");
+ return BfString.toString();
+ }
+
+
+ protected void printGroup (BitSet tt, int numAttribs) {
+ int i;
+
+ for (i = 0; i < numAttribs; i++) {
+ if (tt.get(i) == true) {
+ System.out.print((i + 1) + " ");
+ }
+ }
+
+ System.out.println();
+ }
+
+
+ /**
+ * Searches the attribute subset space by best first search
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+ m_totalEvals = 0;
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator!");
+ }
+
+ if (ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ } else {
+ m_hasClass = true;
+ m_classIndex = data.classIndex();
+ }
+
+ SubsetEvaluator ASEvaluator = (SubsetEvaluator)ASEval;
+ m_numAttribs = data.numAttributes();
+ int i, j;
+ int best_size = 0;
+ int size = 0;
+ int done;
+ int sd = m_searchDirection;
+ BitSet best_group, temp_group;
+ int stale;
+ double best_merit;
+ double merit;
+ boolean z;
+ boolean added;
+ Link2 tl;
+ Hashtable lookup = new Hashtable(m_cacheSize * m_numAttribs);
+ int insertCount = 0;
+ int cacheHits = 0;
+ LinkedList2 bfList = new LinkedList2(m_maxStale);
+ best_merit = -Double.MAX_VALUE;
+ stale = 0;
+ best_group = new BitSet(m_numAttribs);
+
+ m_startRange.setUpper(m_numAttribs-1);
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+ // If a starting subset has been supplied, then initialise the bitset
+ if (m_starting != null) {
+ for (i = 0; i < m_starting.length; i++) {
+ if ((m_starting[i]) != m_classIndex) {
+ best_group.set(m_starting[i]);
+ }
+ }
+
+ best_size = m_starting.length;
+ m_totalEvals++;
+ } else {
+ if (m_searchDirection == SELECTION_BACKWARD) {
+ setStartSet("1-last");
+ m_starting = new int[m_numAttribs];
+
+ // init initial subset to all attributes
+ for (i = 0, j = 0; i < m_numAttribs; i++) {
+ if (i != m_classIndex) {
+ best_group.set(i);
+ m_starting[j++] = i;
+ }
+ }
+
+ best_size = m_numAttribs - 1;
+ m_totalEvals++;
+ }
+ }
+
+ // evaluate the initial subset
+ best_merit = ASEvaluator.evaluateSubset(best_group);
+ // add the initial group to the list and the hash table
+ Object [] best = new Object[1];
+ best[0] = best_group.clone();
+ bfList.addToList(best, best_merit);
+ BitSet tt = (BitSet)best_group.clone();
+ String hashC = tt.toString();
+ lookup.put(hashC, new Double(best_merit));
+
+ while (stale < m_maxStale) {
+ added = false;
+
+ if (m_searchDirection == SELECTION_BIDIRECTIONAL) {
+ // bi-directional search
+ done = 2;
+ sd = SELECTION_FORWARD;
+ } else {
+ done = 1;
+ }
+
+ // finished search?
+ if (bfList.size() == 0) {
+ stale = m_maxStale;
+ break;
+ }
+
+ // copy the attribute set at the head of the list
+ tl = bfList.getLinkAt(0);
+ temp_group = (BitSet)(tl.getData()[0]);
+ temp_group = (BitSet)temp_group.clone();
+ // remove the head of the list
+ bfList.removeLinkAt(0);
+ // count the number of bits set (attributes)
+ int kk;
+
+ for (kk = 0, size = 0; kk < m_numAttribs; kk++) {
+ if (temp_group.get(kk)) {
+ size++;
+ }
+ }
+
+ do {
+ for (i = 0; i < m_numAttribs; i++) {
+ if (sd == SELECTION_FORWARD) {
+ z = ((i != m_classIndex) && (!temp_group.get(i)));
+ } else {
+ z = ((i != m_classIndex) && (temp_group.get(i)));
+ }
+
+ if (z) {
+ // set the bit (attribute to add/delete)
+ if (sd == SELECTION_FORWARD) {
+ temp_group.set(i);
+ size++;
+ } else {
+ temp_group.clear(i);
+ size--;
+ }
+
+ /* if this subset has been seen before, then it is already
+ in the list (or has been fully expanded) */
+ tt = (BitSet)temp_group.clone();
+ hashC = tt.toString();
+
+ if (lookup.containsKey(hashC) == false) {
+ merit = ASEvaluator.evaluateSubset(temp_group);
+ m_totalEvals++;
+
+ // insert this one in the hashtable
+ if (insertCount > m_cacheSize * m_numAttribs) {
+ lookup = new Hashtable(m_cacheSize * m_numAttribs);
+ insertCount = 0;
+ }
+ hashC = tt.toString();
+ lookup.put(hashC, new Double(merit));
+ insertCount++;
+ } else {
+ merit = ((Double)lookup.get(hashC)).doubleValue();
+ cacheHits++;
+ }
+
+ // insert this one in the list
+ Object[] add = new Object[1];
+ add[0] = tt.clone();
+ bfList.addToList(add, merit);
+
+ if (m_debug) {
+ System.out.print("Group: ");
+ printGroup(tt, m_numAttribs);
+ System.out.println("Merit: " + merit);
+ }
+
+ // is this better than the best?
+ if (sd == SELECTION_FORWARD) {
+ z = ((merit - best_merit) > 0.00001);
+ } else {
+ if (merit == best_merit) {
+ z = (size < best_size);
+ } else {
+ z = (merit > best_merit);
+ }
+ }
+
+ if (z) {
+ added = true;
+ stale = 0;
+ best_merit = merit;
+ // best_size = (size + best_size);
+ best_size = size;
+ best_group = (BitSet)(temp_group.clone());
+ }
+
+ // unset this addition(deletion)
+ if (sd == SELECTION_FORWARD) {
+ temp_group.clear(i);
+ size--;
+ } else {
+ temp_group.set(i);
+ size++;
+ }
+ }
+ }
+
+ if (done == 2) {
+ sd = SELECTION_BACKWARD;
+ }
+
+ done--;
+ } while (done > 0);
+
+ /* if we haven't added a new attribute subset then full expansion
+ of this node hasen't resulted in anything better */
+ if (!added) {
+ stale++;
+ }
+ }
+
+ m_bestMerit = best_merit;
+ return attributeList(best_group);
+ }
+
+
+ /**
+ * Reset options to default values
+ */
+ protected void resetOptions () {
+ m_maxStale = 5;
+ m_searchDirection = SELECTION_FORWARD;
+ m_starting = null;
+ m_startRange = new Range();
+ m_classIndex = -1;
+ m_totalEvals = 0;
+ m_cacheSize = 1;
+ m_debug = false;
+ }
+
+
+ /**
+ * converts a BitSet into a list of attribute indexes
+ * @param group the BitSet to convert
+ * @return an array of attribute indexes
+ **/
+ protected int[] attributeList (BitSet group) {
+ int count = 0;
+
+ // count how many were selected
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ count++;
+ }
+ }
+
+ int[] list = new int[count];
+ count = 0;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ list[count++] = i;
+ }
+ }
+
+ return list;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.29 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/CfsSubsetEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/CfsSubsetEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/CfsSubsetEval.java (revision 29)
@@ -0,0 +1,1140 @@
+/*
+ * 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.
+ */
+
+/*
+ * CfsSubsetEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Capabilities;
+import weka.core.ContingencyTables;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+import weka.filters.Filter;
+import weka.filters.supervised.attribute.Discretize;
+
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * CfsSubsetEval :
+ *
+ * Evaluates the worth of a subset of attributes by considering the individual predictive ability of each feature along with the degree of redundancy between them.
+ *
+ * Subsets of features that are highly correlated with the class while having low intercorrelation are preferred.
+ *
+ * For more information see:
+ *
+ * M. A. Hall (1998). Correlation-based Feature Subset Selection for Machine Learning. Hamilton, New Zealand.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @phdthesis{Hall1998,
+ * address = {Hamilton, New Zealand},
+ * author = {M. A. Hall},
+ * school = {University of Waikato},
+ * title = {Correlation-based Feature Subset Selection for Machine Learning},
+ * year = {1998}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * Treat missing values as a separate value.
+ *
+ * -L
+ * Don't include locally predictive attributes.
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 6132 $
+ * @see Discretize
+ */
+public class CfsSubsetEval
+ extends ASEvaluation
+ implements SubsetEvaluator,
+ OptionHandler,
+ TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 747878400813276317L;
+
+ /** The training instances */
+ private Instances m_trainInstances;
+ /** Discretise attributes when class in nominal */
+ private Discretize m_disTransform;
+ /** The class index */
+ private int m_classIndex;
+ /** Is the class numeric */
+ private boolean m_isNumeric;
+ /** Number of attributes in the training data */
+ private int m_numAttribs;
+ /** Number of instances in the training data */
+ private int m_numInstances;
+ /** Treat missing values as separate values */
+ private boolean m_missingSeparate;
+ /** Include locally predictive attributes */
+ private boolean m_locallyPredictive;
+ /** Holds the matrix of attribute correlations */
+ // private Matrix m_corr_matrix;
+ private float [][] m_corr_matrix;
+ /** Standard deviations of attributes (when using pearsons correlation) */
+ private double[] m_std_devs;
+ /** Threshold for admitting locally predictive features */
+ private double m_c_Threshold;
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "CfsSubsetEval :\n\nEvaluates the worth of a subset of attributes "
+ +"by considering the individual predictive ability of each feature "
+ +"along with the degree of redundancy between them.\n\n"
+ +"Subsets of features that are highly correlated with the class "
+ +"while having low intercorrelation are preferred.\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.PHDTHESIS);
+ result.setValue(Field.AUTHOR, "M. A. Hall");
+ result.setValue(Field.YEAR, "1998");
+ result.setValue(Field.TITLE, "Correlation-based Feature Subset Selection for Machine Learning");
+ result.setValue(Field.SCHOOL, "University of Waikato");
+ result.setValue(Field.ADDRESS, "Hamilton, New Zealand");
+
+ return result;
+ }
+
+ /**
+ * Constructor
+ */
+ public CfsSubsetEval () {
+ resetOptions();
+ }
+
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ *
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(3);
+ newVector.addElement(new Option("\tTreat missing values as a separate "
+ + "value.", "M", 0, "-M"));
+ newVector.addElement(new Option("\tDon't include locally predictive attributes"
+ + ".", "L", 0, "-L"));
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses and sets a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * Treat missing values as a separate value.
+ *
+ * -L
+ * Don't include locally predictive attributes.
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ *
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+
+ resetOptions();
+ setMissingSeparate(Utils.getFlag('M', options));
+ setLocallyPredictive(!Utils.getFlag('L', options));
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String locallyPredictiveTipText() {
+ return "Identify locally predictive attributes. Iteratively adds "
+ +"attributes with the highest correlation with the class as long "
+ +"as there is not already an attribute in the subset that has a "
+ +"higher correlation with the attribute in question";
+ }
+
+ /**
+ * Include locally predictive attributes
+ *
+ * @param b true or false
+ */
+ public void setLocallyPredictive (boolean b) {
+ m_locallyPredictive = b;
+ }
+
+
+ /**
+ * Return true if including locally predictive attributes
+ *
+ * @return true if locally predictive attributes are to be used
+ */
+ public boolean getLocallyPredictive () {
+ return m_locallyPredictive;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String missingSeparateTipText() {
+ return "Treat missing as a separate value. Otherwise, counts for missing "
+ +"values are distributed across other values in proportion to their "
+ +"frequency.";
+ }
+
+ /**
+ * Treat missing as a separate value
+ *
+ * @param b true or false
+ */
+ public void setMissingSeparate (boolean b) {
+ m_missingSeparate = b;
+ }
+
+
+ /**
+ * Return true is missing is treated as a separate value
+ *
+ * @return true if missing is to be treated as a separate value
+ */
+ public boolean getMissingSeparate () {
+ return m_missingSeparate;
+ }
+
+
+ /**
+ * Gets the current settings of CfsSubsetEval
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[2];
+ int current = 0;
+
+ if (getMissingSeparate()) {
+ options[current++] = "-M";
+ }
+
+ if (!getLocallyPredictive()) {
+ options[current++] = "-L";
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.NUMERIC_CLASS);
+ result.enable(Capability.DATE_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Generates a attribute evaluator. Has to initialize all fields of the
+ * evaluator that are not being set via options.
+ *
+ * CFS also discretises attributes (if necessary) and initializes
+ * the correlation matrix.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ m_trainInstances = new Instances(data);
+ m_trainInstances.deleteWithMissingClass();
+ m_classIndex = m_trainInstances.classIndex();
+ m_numAttribs = m_trainInstances.numAttributes();
+ m_numInstances = m_trainInstances.numInstances();
+ m_isNumeric = m_trainInstances.attribute(m_classIndex).isNumeric();
+
+ if (!m_isNumeric) {
+ m_disTransform = new Discretize();
+ m_disTransform.setUseBetterEncoding(true);
+ m_disTransform.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, m_disTransform);
+ }
+
+ m_std_devs = new double[m_numAttribs];
+ m_corr_matrix = new float [m_numAttribs][];
+ for (int i = 0; i < m_numAttribs; i++) {
+ m_corr_matrix[i] = new float [i+1];
+ }
+
+ for (int i = 0; i < m_corr_matrix.length; i++) {
+ m_corr_matrix[i][i] = 1.0f;
+ m_std_devs[i] = 1.0;
+ }
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ for (int j = 0; j < m_corr_matrix[i].length - 1; j++) {
+ m_corr_matrix[i][j] = -999;
+ }
+ }
+ }
+
+
+ /**
+ * evaluates a subset of attributes
+ *
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @return the merit
+ * @throws Exception if the subset could not be evaluated
+ */
+ public double evaluateSubset (BitSet subset)
+ throws Exception {
+ double num = 0.0;
+ double denom = 0.0;
+ float corr;
+ int larger, smaller;
+ // do numerator
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (i != m_classIndex) {
+ if (subset.get(i)) {
+ if (i > m_classIndex) {
+ larger = i; smaller = m_classIndex;
+ } else {
+ smaller = i; larger = m_classIndex;
+ }
+ /* int larger = (i > m_classIndex ? i : m_classIndex);
+ int smaller = (i > m_classIndex ? m_classIndex : i); */
+ if (m_corr_matrix[larger][smaller] == -999) {
+ corr = correlate(i, m_classIndex);
+ m_corr_matrix[larger][smaller] = corr;
+ num += (m_std_devs[i] * corr);
+ }
+ else {
+ num += (m_std_devs[i] * m_corr_matrix[larger][smaller]);
+ }
+ }
+ }
+ }
+
+ // do denominator
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (i != m_classIndex) {
+ if (subset.get(i)) {
+ denom += (1.0 * m_std_devs[i] * m_std_devs[i]);
+
+ for (int j = 0; j < m_corr_matrix[i].length - 1; j++) {
+ if (subset.get(j)) {
+ if (m_corr_matrix[i][j] == -999) {
+ corr = correlate(i, j);
+ m_corr_matrix[i][j] = corr;
+ denom += (2.0 * m_std_devs[i] * m_std_devs[j] * corr);
+ }
+ else {
+ denom += (2.0 * m_std_devs[i] * m_std_devs[j] * m_corr_matrix[i][j]);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (denom < 0.0) {
+ denom *= -1.0;
+ }
+
+ if (denom == 0.0) {
+ return (0.0);
+ }
+
+ double merit = (num/Math.sqrt(denom));
+
+ if (merit < 0.0) {
+ merit *= -1.0;
+ }
+
+ return merit;
+ }
+
+
+ private float correlate (int att1, int att2) {
+ if (!m_isNumeric) {
+ return (float) symmUncertCorr(att1, att2);
+ }
+
+ boolean att1_is_num = (m_trainInstances.attribute(att1).isNumeric());
+ boolean att2_is_num = (m_trainInstances.attribute(att2).isNumeric());
+
+ if (att1_is_num && att2_is_num) {
+ return (float) num_num(att1, att2);
+ }
+ else {if (att2_is_num) {
+ return (float) num_nom2(att1, att2);
+ }
+ else {if (att1_is_num) {
+ return (float) num_nom2(att2, att1);
+ }
+ }
+ }
+
+ return (float) nom_nom(att1, att2);
+ }
+
+
+ private double symmUncertCorr (int att1, int att2) {
+ int i, j, k, ii, jj;
+ int ni, nj;
+ double sum = 0.0;
+ double sumi[], sumj[];
+ double counts[][];
+ Instance inst;
+ double corr_measure;
+ boolean flag = false;
+ double temp = 0.0;
+
+ if (att1 == m_classIndex || att2 == m_classIndex) {
+ flag = true;
+ }
+
+ ni = m_trainInstances.attribute(att1).numValues() + 1;
+ nj = m_trainInstances.attribute(att2).numValues() + 1;
+ counts = new double[ni][nj];
+ sumi = new double[ni];
+ sumj = new double[nj];
+
+ for (i = 0; i < ni; i++) {
+ sumi[i] = 0.0;
+
+ for (j = 0; j < nj; j++) {
+ sumj[j] = 0.0;
+ counts[i][j] = 0.0;
+ }
+ }
+
+ // Fill the contingency table
+ for (i = 0; i < m_numInstances; i++) {
+ inst = m_trainInstances.instance(i);
+
+ if (inst.isMissing(att1)) {
+ ii = ni - 1;
+ }
+ else {
+ ii = (int)inst.value(att1);
+ }
+
+ if (inst.isMissing(att2)) {
+ jj = nj - 1;
+ }
+ else {
+ jj = (int)inst.value(att2);
+ }
+
+ counts[ii][jj]++;
+ }
+
+ // get the row totals
+ for (i = 0; i < ni; i++) {
+ sumi[i] = 0.0;
+
+ for (j = 0; j < nj; j++) {
+ sumi[i] += counts[i][j];
+ sum += counts[i][j];
+ }
+ }
+
+ // get the column totals
+ for (j = 0; j < nj; j++) {
+ sumj[j] = 0.0;
+
+ for (i = 0; i < ni; i++) {
+ sumj[j] += counts[i][j];
+ }
+ }
+
+ // distribute missing counts
+ if (!m_missingSeparate &&
+ (sumi[ni-1] < m_numInstances) &&
+ (sumj[nj-1] < m_numInstances)) {
+ double[] i_copy = new double[sumi.length];
+ double[] j_copy = new double[sumj.length];
+ double[][] counts_copy = new double[sumi.length][sumj.length];
+
+ for (i = 0; i < ni; i++) {
+ System.arraycopy(counts[i], 0, counts_copy[i], 0, sumj.length);
+ }
+
+ System.arraycopy(sumi, 0, i_copy, 0, sumi.length);
+ System.arraycopy(sumj, 0, j_copy, 0, sumj.length);
+ double total_missing =
+ (sumi[ni - 1] + sumj[nj - 1] - counts[ni - 1][nj - 1]);
+
+ // do the missing i's
+ if (sumi[ni - 1] > 0.0) {
+ for (j = 0; j < nj - 1; j++) {
+ if (counts[ni - 1][j] > 0.0) {
+ for (i = 0; i < ni - 1; i++) {
+ temp = ((i_copy[i]/(sum - i_copy[ni - 1]))*counts[ni - 1][j]);
+ counts[i][j] += temp;
+ sumi[i] += temp;
+ }
+
+ counts[ni - 1][j] = 0.0;
+ }
+ }
+ }
+
+ sumi[ni - 1] = 0.0;
+
+ // do the missing j's
+ if (sumj[nj - 1] > 0.0) {
+ for (i = 0; i < ni - 1; i++) {
+ if (counts[i][nj - 1] > 0.0) {
+ for (j = 0; j < nj - 1; j++) {
+ temp = ((j_copy[j]/(sum - j_copy[nj - 1]))*counts[i][nj - 1]);
+ counts[i][j] += temp;
+ sumj[j] += temp;
+ }
+
+ counts[i][nj - 1] = 0.0;
+ }
+ }
+ }
+
+ sumj[nj - 1] = 0.0;
+
+ // do the both missing
+ if (counts[ni - 1][nj - 1] > 0.0 && total_missing != sum) {
+ for (i = 0; i < ni - 1; i++) {
+ for (j = 0; j < nj - 1; j++) {
+ temp = (counts_copy[i][j]/(sum - total_missing)) *
+ counts_copy[ni - 1][nj - 1];
+
+ counts[i][j] += temp;
+ sumi[i] += temp;
+ sumj[j] += temp;
+ }
+ }
+
+ counts[ni - 1][nj - 1] = 0.0;
+ }
+ }
+
+ corr_measure = ContingencyTables.symmetricalUncertainty(counts);
+
+ if (Utils.eq(corr_measure, 0.0)) {
+ if (flag == true) {
+ return (0.0);
+ }
+ else {
+ return (1.0);
+ }
+ }
+ else {
+ return (corr_measure);
+ }
+ }
+
+
+ private double num_num (int att1, int att2) {
+ int i;
+ Instance inst;
+ double r, diff1, diff2, num = 0.0, sx = 0.0, sy = 0.0;
+ double mx = m_trainInstances.meanOrMode(m_trainInstances.attribute(att1));
+ double my = m_trainInstances.meanOrMode(m_trainInstances.attribute(att2));
+
+ for (i = 0; i < m_numInstances; i++) {
+ inst = m_trainInstances.instance(i);
+ diff1 = (inst.isMissing(att1))? 0.0 : (inst.value(att1) - mx);
+ diff2 = (inst.isMissing(att2))? 0.0 : (inst.value(att2) - my);
+ num += (diff1*diff2);
+ sx += (diff1*diff1);
+ sy += (diff2*diff2);
+ }
+
+ if (sx != 0.0) {
+ if (m_std_devs[att1] == 1.0) {
+ m_std_devs[att1] = Math.sqrt((sx/m_numInstances));
+ }
+ }
+
+ if (sy != 0.0) {
+ if (m_std_devs[att2] == 1.0) {
+ m_std_devs[att2] = Math.sqrt((sy/m_numInstances));
+ }
+ }
+
+ if ((sx*sy) > 0.0) {
+ r = (num/(Math.sqrt(sx*sy)));
+ return ((r < 0.0)? -r : r);
+ }
+ else {
+ if (att1 != m_classIndex && att2 != m_classIndex) {
+ return 1.0;
+ }
+ else {
+ return 0.0;
+ }
+ }
+ }
+
+
+ private double num_nom2 (int att1, int att2) {
+ int i, ii, k;
+ double temp;
+ Instance inst;
+ int mx = (int)m_trainInstances.
+ meanOrMode(m_trainInstances.attribute(att1));
+ double my = m_trainInstances.
+ meanOrMode(m_trainInstances.attribute(att2));
+ double stdv_num = 0.0;
+ double diff1, diff2;
+ double r = 0.0, rr;
+ int nx = (!m_missingSeparate)
+ ? m_trainInstances.attribute(att1).numValues()
+ : m_trainInstances.attribute(att1).numValues() + 1;
+
+ double[] prior_nom = new double[nx];
+ double[] stdvs_nom = new double[nx];
+ double[] covs = new double[nx];
+
+ for (i = 0; i < nx; i++) {
+ stdvs_nom[i] = covs[i] = prior_nom[i] = 0.0;
+ }
+
+ // calculate frequencies (and means) of the values of the nominal
+ // attribute
+ for (i = 0; i < m_numInstances; i++) {
+ inst = m_trainInstances.instance(i);
+
+ if (inst.isMissing(att1)) {
+ if (!m_missingSeparate) {
+ ii = mx;
+ }
+ else {
+ ii = nx - 1;
+ }
+ }
+ else {
+ ii = (int)inst.value(att1);
+ }
+
+ // increment freq for nominal
+ prior_nom[ii]++;
+ }
+
+ for (k = 0; k < m_numInstances; k++) {
+ inst = m_trainInstances.instance(k);
+ // std dev of numeric attribute
+ diff2 = (inst.isMissing(att2))? 0.0 : (inst.value(att2) - my);
+ stdv_num += (diff2*diff2);
+
+ //
+ for (i = 0; i < nx; i++) {
+ if (inst.isMissing(att1)) {
+ if (!m_missingSeparate) {
+ temp = (i == mx)? 1.0 : 0.0;
+ }
+ else {
+ temp = (i == (nx - 1))? 1.0 : 0.0;
+ }
+ }
+ else {
+ temp = (i == inst.value(att1))? 1.0 : 0.0;
+ }
+
+ diff1 = (temp - (prior_nom[i]/m_numInstances));
+ stdvs_nom[i] += (diff1*diff1);
+ covs[i] += (diff1*diff2);
+ }
+ }
+
+ // calculate weighted correlation
+ for (i = 0, temp = 0.0; i < nx; i++) {
+ // calculate the weighted variance of the nominal
+ temp += ((prior_nom[i]/m_numInstances)*(stdvs_nom[i]/m_numInstances));
+
+ if ((stdvs_nom[i]*stdv_num) > 0.0) {
+ //System.out.println("Stdv :"+stdvs_nom[i]);
+ rr = (covs[i]/(Math.sqrt(stdvs_nom[i]*stdv_num)));
+
+ if (rr < 0.0) {
+ rr = -rr;
+ }
+
+ r += ((prior_nom[i]/m_numInstances)*rr);
+ }
+ /* if there is zero variance for the numeric att at a specific
+ level of the catergorical att then if neither is the class then
+ make this correlation at this level maximally bad i.e. 1.0.
+ If either is the class then maximally bad correlation is 0.0 */
+ else {if (att1 != m_classIndex && att2 != m_classIndex) {
+ r += ((prior_nom[i]/m_numInstances)*1.0);
+ }
+ }
+ }
+
+ // set the standard deviations for these attributes if necessary
+ // if ((att1 != classIndex) && (att2 != classIndex)) // =============
+ if (temp != 0.0) {
+ if (m_std_devs[att1] == 1.0) {
+ m_std_devs[att1] = Math.sqrt(temp);
+ }
+ }
+
+ if (stdv_num != 0.0) {
+ if (m_std_devs[att2] == 1.0) {
+ m_std_devs[att2] = Math.sqrt((stdv_num/m_numInstances));
+ }
+ }
+
+ if (r == 0.0) {
+ if (att1 != m_classIndex && att2 != m_classIndex) {
+ r = 1.0;
+ }
+ }
+
+ return r;
+ }
+
+
+ private double nom_nom (int att1, int att2) {
+ int i, j, ii, jj, z;
+ double temp1, temp2;
+ Instance inst;
+ int mx = (int)m_trainInstances.
+ meanOrMode(m_trainInstances.attribute(att1));
+ int my = (int)m_trainInstances.
+ meanOrMode(m_trainInstances.attribute(att2));
+ double diff1, diff2;
+ double r = 0.0, rr;
+ int nx = (!m_missingSeparate)
+ ? m_trainInstances.attribute(att1).numValues()
+ : m_trainInstances.attribute(att1).numValues() + 1;
+
+ int ny = (!m_missingSeparate)
+ ? m_trainInstances.attribute(att2).numValues()
+ : m_trainInstances.attribute(att2).numValues() + 1;
+
+ double[][] prior_nom = new double[nx][ny];
+ double[] sumx = new double[nx];
+ double[] sumy = new double[ny];
+ double[] stdvsx = new double[nx];
+ double[] stdvsy = new double[ny];
+ double[][] covs = new double[nx][ny];
+
+ for (i = 0; i < nx; i++) {
+ sumx[i] = stdvsx[i] = 0.0;
+ }
+
+ for (j = 0; j < ny; j++) {
+ sumy[j] = stdvsy[j] = 0.0;
+ }
+
+ for (i = 0; i < nx; i++) {
+ for (j = 0; j < ny; j++) {
+ covs[i][j] = prior_nom[i][j] = 0.0;
+ }
+ }
+
+ // calculate frequencies (and means) of the values of the nominal
+ // attribute
+ for (i = 0; i < m_numInstances; i++) {
+ inst = m_trainInstances.instance(i);
+
+ if (inst.isMissing(att1)) {
+ if (!m_missingSeparate) {
+ ii = mx;
+ }
+ else {
+ ii = nx - 1;
+ }
+ }
+ else {
+ ii = (int)inst.value(att1);
+ }
+
+ if (inst.isMissing(att2)) {
+ if (!m_missingSeparate) {
+ jj = my;
+ }
+ else {
+ jj = ny - 1;
+ }
+ }
+ else {
+ jj = (int)inst.value(att2);
+ }
+
+ // increment freq for nominal
+ prior_nom[ii][jj]++;
+ sumx[ii]++;
+ sumy[jj]++;
+ }
+
+ for (z = 0; z < m_numInstances; z++) {
+ inst = m_trainInstances.instance(z);
+
+ for (j = 0; j < ny; j++) {
+ if (inst.isMissing(att2)) {
+ if (!m_missingSeparate) {
+ temp2 = (j == my)? 1.0 : 0.0;
+ }
+ else {
+ temp2 = (j == (ny - 1))? 1.0 : 0.0;
+ }
+ }
+ else {
+ temp2 = (j == inst.value(att2))? 1.0 : 0.0;
+ }
+
+ diff2 = (temp2 - (sumy[j]/m_numInstances));
+ stdvsy[j] += (diff2*diff2);
+ }
+
+ //
+ for (i = 0; i < nx; i++) {
+ if (inst.isMissing(att1)) {
+ if (!m_missingSeparate) {
+ temp1 = (i == mx)? 1.0 : 0.0;
+ }
+ else {
+ temp1 = (i == (nx - 1))? 1.0 : 0.0;
+ }
+ }
+ else {
+ temp1 = (i == inst.value(att1))? 1.0 : 0.0;
+ }
+
+ diff1 = (temp1 - (sumx[i]/m_numInstances));
+ stdvsx[i] += (diff1*diff1);
+
+ for (j = 0; j < ny; j++) {
+ if (inst.isMissing(att2)) {
+ if (!m_missingSeparate) {
+ temp2 = (j == my)? 1.0 : 0.0;
+ }
+ else {
+ temp2 = (j == (ny - 1))? 1.0 : 0.0;
+ }
+ }
+ else {
+ temp2 = (j == inst.value(att2))? 1.0 : 0.0;
+ }
+
+ diff2 = (temp2 - (sumy[j]/m_numInstances));
+ covs[i][j] += (diff1*diff2);
+ }
+ }
+ }
+
+ // calculate weighted correlation
+ for (i = 0; i < nx; i++) {
+ for (j = 0; j < ny; j++) {
+ if ((stdvsx[i]*stdvsy[j]) > 0.0) {
+ //System.out.println("Stdv :"+stdvs_nom[i]);
+ rr = (covs[i][j]/(Math.sqrt(stdvsx[i]*stdvsy[j])));
+
+ if (rr < 0.0) {
+ rr = -rr;
+ }
+
+ r += ((prior_nom[i][j]/m_numInstances)*rr);
+ }
+ // if there is zero variance for either of the categorical atts then if
+ // neither is the class then make this
+ // correlation at this level maximally bad i.e. 1.0. If either is
+ // the class then maximally bad correlation is 0.0
+ else {if (att1 != m_classIndex && att2 != m_classIndex) {
+ r += ((prior_nom[i][j]/m_numInstances)*1.0);
+ }
+ }
+ }
+ }
+
+ // calculate weighted standard deviations for these attributes
+ // (if necessary)
+ for (i = 0, temp1 = 0.0; i < nx; i++) {
+ temp1 += ((sumx[i]/m_numInstances)*(stdvsx[i]/m_numInstances));
+ }
+
+ if (temp1 != 0.0) {
+ if (m_std_devs[att1] == 1.0) {
+ m_std_devs[att1] = Math.sqrt(temp1);
+ }
+ }
+
+ for (j = 0, temp2 = 0.0; j < ny; j++) {
+ temp2 += ((sumy[j]/m_numInstances)*(stdvsy[j]/m_numInstances));
+ }
+
+ if (temp2 != 0.0) {
+ if (m_std_devs[att2] == 1.0) {
+ m_std_devs[att2] = Math.sqrt(temp2);
+ }
+ }
+
+ if (r == 0.0) {
+ if (att1 != m_classIndex && att2 != m_classIndex) {
+ r = 1.0;
+ }
+ }
+
+ return r;
+ }
+
+
+ /**
+ * returns a string describing CFS
+ *
+ * @return the description as a string
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_trainInstances == null) {
+ text.append("CFS subset evaluator has not been built yet\n");
+ }
+ else {
+ text.append("\tCFS Subset Evaluator\n");
+
+ if (m_missingSeparate) {
+ text.append("\tTreating missing values as a separate value\n");
+ }
+
+ if (m_locallyPredictive) {
+ text.append("\tIncluding locally predictive attributes\n");
+ }
+ }
+
+ return text.toString();
+ }
+
+
+ private void addLocallyPredictive (BitSet best_group) {
+ int i, j;
+ boolean done = false;
+ boolean ok = true;
+ double temp_best = -1.0;
+ float corr;
+ j = 0;
+ BitSet temp_group = (BitSet)best_group.clone();
+ int larger, smaller;
+
+ while (!done) {
+ temp_best = -1.0;
+
+ // find best not already in group
+ for (i = 0; i < m_numAttribs; i++) {
+ if (i > m_classIndex) {
+ larger = i; smaller = m_classIndex;
+ } else {
+ smaller = i; larger = m_classIndex;
+ }
+ /* int larger = (i > m_classIndex ? i : m_classIndex);
+ int smaller = (i > m_classIndex ? m_classIndex : i); */
+ if ((!temp_group.get(i)) && (i != m_classIndex)) {
+ if (m_corr_matrix[larger][smaller] == -999) {
+ corr = correlate(i, m_classIndex);
+ m_corr_matrix[larger][smaller] = corr;
+ }
+
+ if (m_corr_matrix[larger][smaller] > temp_best) {
+ temp_best = m_corr_matrix[larger][smaller];
+ j = i;
+ }
+ }
+ }
+
+ if (temp_best == -1.0) {
+ done = true;
+ }
+ else {
+ ok = true;
+ temp_group.set(j);
+
+ // check the best against correlations with others already
+ // in group
+ for (i = 0; i < m_numAttribs; i++) {
+ if (i > j) {
+ larger = i; smaller = j;
+ } else {
+ larger = j; smaller = i;
+ }
+ /* int larger = (i > j ? i : j);
+ int smaller = (i > j ? j : i); */
+ if (best_group.get(i)) {
+ if (m_corr_matrix[larger][smaller] == -999) {
+ corr = correlate(i, j);
+ m_corr_matrix[larger][smaller] = corr;
+ }
+
+ if (m_corr_matrix[larger][smaller] > temp_best - m_c_Threshold) {
+ ok = false;
+ break;
+ }
+ }
+ }
+
+ // if ok then add to best_group
+ if (ok) {
+ best_group.set(j);
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Calls locallyPredictive in order to include locally predictive
+ * attributes (if requested).
+ *
+ * @param attributeSet the set of attributes found by the search
+ * @return a possibly ranked list of postprocessed attributes
+ * @throws Exception if postprocessing fails for some reason
+ */
+ public int[] postProcess (int[] attributeSet)
+ throws Exception {
+ int j = 0;
+
+ if (!m_locallyPredictive) {
+ // m_trainInstances = new Instances(m_trainInstances,0);
+ return attributeSet;
+ }
+
+ BitSet bestGroup = new BitSet(m_numAttribs);
+
+ for (int i = 0; i < attributeSet.length; i++) {
+ bestGroup.set(attributeSet[i]);
+ }
+
+ addLocallyPredictive(bestGroup);
+
+ // count how many are set
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (bestGroup.get(i)) {
+ j++;
+ }
+ }
+
+ int[] newSet = new int[j];
+ j = 0;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (bestGroup.get(i)) {
+ newSet[j++] = i;
+ }
+ }
+
+ // m_trainInstances = new Instances(m_trainInstances,0);
+ return newSet;
+ }
+
+
+ protected void resetOptions () {
+ m_trainInstances = null;
+ m_missingSeparate = false;
+ m_locallyPredictive = true;
+ m_c_Threshold = 0.0;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 6132 $");
+ }
+
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new CfsSubsetEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/CheckAttributeSelection.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/CheckAttributeSelection.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/CheckAttributeSelection.java (revision 29)
@@ -0,0 +1,1641 @@
+/*
+ * 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.
+ */
+
+/*
+ * CheckAttributeSelection.java
+ * Copyright (C) 2006 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Attribute;
+import weka.core.CheckScheme;
+import weka.core.FastVector;
+import weka.core.Instances;
+import weka.core.MultiInstanceCapabilitiesHandler;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SerializationHelper;
+import weka.core.SerializedObject;
+import weka.core.TestInstances;
+import weka.core.Utils;
+import weka.core.WeightedInstancesHandler;
+
+import java.util.Enumeration;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+ * Class for examining the capabilities and finding problems with
+ * attribute selection schemes. If you implement an attribute selection using
+ * the WEKA.libraries, you should run the checks on it to ensure robustness
+ * and correct operation. Passing all the tests of this object does not mean
+ * bugs in the attribute selection don't exist, but this will help find some
+ * common ones.
+ *
+ * Typical usage:
+ * java weka.attributeSelection.CheckAttributeSelection -W ASscheme_name
+ * -- ASscheme_options
+ *
+ * CheckAttributeSelection reports on the following:
+ *
+ * - Scheme abilities
+ *
+ * - Possible command line options to the scheme
+ * - Whether the scheme can predict nominal, numeric, string,
+ * date or relational class attributes.
+ * - Whether the scheme can handle numeric predictor attributes
+ * - Whether the scheme can handle nominal predictor attributes
+ * - Whether the scheme can handle string predictor attributes
+ * - Whether the scheme can handle date predictor attributes
+ * - Whether the scheme can handle relational predictor attributes
+ * - Whether the scheme can handle multi-instance data
+ * - Whether the scheme can handle missing predictor values
+ * - Whether the scheme can handle missing class values
+ * - Whether a nominal scheme only handles 2 class problems
+ * - Whether the scheme can handle instance weights
+ *
+ *
+ * - Correct functioning
+ *
+ * - Correct initialisation during search (i.e. no result
+ * changes when search is performed repeatedly)
+ * - Whether the scheme alters the data pased to it
+ * (number of instances, instance order, instance weights, etc)
+ *
+ *
+ * - Degenerate cases
+ *
+ * - building scheme with zero instances
+ * - all but one predictor attribute values missing
+ * - all predictor attribute values missing
+ * - all but one class values missing
+ * - all class values missing
+ *
+ *
+ *
+ * Running CheckAttributeSelection with the debug option set will output the
+ * training dataset for any failed tests.
+ *
+ * The weka.attributeSelection.AbstractAttributeSelectionTest
+ * uses this class to test all the schemes. Any changes here, have to be
+ * checked in that abstract test class, too.
+ *
+
+ * Valid options are:
+ *
+ * -D
+ * Turn on debugging output.
+ *
+ * -S
+ * Silent mode - prints nothing to stdout.
+ *
+ * -N <num>
+ * The number of instances in the datasets (default 20).
+ *
+ * -nominal <num>
+ * The number of nominal attributes (default 2).
+ *
+ * -nominal-values <num>
+ * The number of values for nominal attributes (default 1).
+ *
+ * -numeric <num>
+ * The number of numeric attributes (default 1).
+ *
+ * -string <num>
+ * The number of string attributes (default 1).
+ *
+ * -date <num>
+ * The number of date attributes (default 1).
+ *
+ * -relational <num>
+ * The number of relational attributes (default 1).
+ *
+ * -num-instances-relational <num>
+ * The number of instances in relational/bag attributes (default 10).
+ *
+ * -words <comma-separated-list>
+ * The words to use in string attributes.
+ *
+ * -word-separators <chars>
+ * The word separators to use in string attributes.
+ *
+ * -eval name [options]
+ * Full name and options of the evaluator analyzed.
+ * eg: weka.attributeSelection.CfsSubsetEval
+ *
+ * -search name [options]
+ * Full name and options of the search method analyzed.
+ * eg: weka.attributeSelection.Ranker
+ *
+ * -test <eval|search>
+ * The scheme to test, either the evaluator or the search method.
+ * (Default: eval)
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.CfsSubsetEval:
+ *
+ *
+ * -M
+ * Treat missing values as a seperate value.
+ *
+ * -L
+ * Don't include locally predictive attributes.
+ *
+ *
+ * Options specific to search method weka.attributeSelection.Ranker:
+ *
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * Any starting attributes specified are
+ * ignored during the ranking.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @author Len Trigg (trigg@cs.waikato.ac.nz)
+ * @author FracPete (fracpete at waikato dot ac dot nz)
+ * @version $Revision: 4783 $
+ * @see TestInstances
+ */
+public class CheckAttributeSelection
+ extends CheckScheme {
+
+ /*
+ * Note about test methods:
+ * - methods return array of booleans
+ * - first index: success or not
+ * - second index: acceptable or not (e.g., Exception is OK)
+ *
+ * FracPete (fracpete at waikato dot ac dot nz)
+ */
+
+ /*** The evaluator to be examined */
+ protected ASEvaluation m_Evaluator = new CfsSubsetEval();
+
+ /*** The search method to be used */
+ protected ASSearch m_Search = new Ranker();
+
+ /** whether to test the evaluator (default) or the search method */
+ protected boolean m_TestEvaluator = true;
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+ Vector result = new Vector();
+
+ Enumeration en = super.listOptions();
+ while (en.hasMoreElements())
+ result.addElement(en.nextElement());
+
+ result.addElement(new Option(
+ "\tFull name and options of the evaluator analyzed.\n"
+ +"\teg: weka.attributeSelection.CfsSubsetEval",
+ "eval", 1, "-eval name [options]"));
+
+ result.addElement(new Option(
+ "\tFull name and options of the search method analyzed.\n"
+ +"\teg: weka.attributeSelection.Ranker",
+ "search", 1, "-search name [options]"));
+
+ result.addElement(new Option(
+ "\tThe scheme to test, either the evaluator or the search method.\n"
+ +"\t(Default: eval)",
+ "test", 1, "-test "));
+
+ if ((m_Evaluator != null) && (m_Evaluator instanceof OptionHandler)) {
+ result.addElement(new Option("", "", 0,
+ "\nOptions specific to evaluator "
+ + m_Evaluator.getClass().getName()
+ + ":"));
+ Enumeration enm = ((OptionHandler) m_Evaluator).listOptions();
+ while (enm.hasMoreElements())
+ result.addElement(enm.nextElement());
+ }
+
+ if ((m_Search != null) && (m_Search instanceof OptionHandler)) {
+ result.addElement(new Option("", "", 0,
+ "\nOptions specific to search method "
+ + m_Search.getClass().getName()
+ + ":"));
+ Enumeration enm = ((OptionHandler) m_Search).listOptions();
+ while (enm.hasMoreElements())
+ result.addElement(enm.nextElement());
+ }
+
+ return result.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -D
+ * Turn on debugging output.
+ *
+ * -S
+ * Silent mode - prints nothing to stdout.
+ *
+ * -N <num>
+ * The number of instances in the datasets (default 20).
+ *
+ * -nominal <num>
+ * The number of nominal attributes (default 2).
+ *
+ * -nominal-values <num>
+ * The number of values for nominal attributes (default 1).
+ *
+ * -numeric <num>
+ * The number of numeric attributes (default 1).
+ *
+ * -string <num>
+ * The number of string attributes (default 1).
+ *
+ * -date <num>
+ * The number of date attributes (default 1).
+ *
+ * -relational <num>
+ * The number of relational attributes (default 1).
+ *
+ * -num-instances-relational <num>
+ * The number of instances in relational/bag attributes (default 10).
+ *
+ * -words <comma-separated-list>
+ * The words to use in string attributes.
+ *
+ * -word-separators <chars>
+ * The word separators to use in string attributes.
+ *
+ * -eval name [options]
+ * Full name and options of the evaluator analyzed.
+ * eg: weka.attributeSelection.CfsSubsetEval
+ *
+ * -search name [options]
+ * Full name and options of the search method analyzed.
+ * eg: weka.attributeSelection.Ranker
+ *
+ * -test <eval|search>
+ * The scheme to test, either the evaluator or the search method.
+ * (Default: eval)
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.CfsSubsetEval:
+ *
+ *
+ * -M
+ * Treat missing values as a seperate value.
+ *
+ * -L
+ * Don't include locally predictive attributes.
+ *
+ *
+ * Options specific to search method weka.attributeSelection.Ranker:
+ *
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * Any starting attributes specified are
+ * ignored during the ranking.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String[] options) throws Exception {
+ String tmpStr;
+ String[] tmpOptions;
+
+ super.setOptions(options);
+
+ tmpStr = Utils.getOption("eval", options);
+ tmpOptions = Utils.splitOptions(tmpStr);
+ if (tmpOptions.length != 0) {
+ tmpStr = tmpOptions[0];
+ tmpOptions[0] = "";
+ setEvaluator(
+ (ASEvaluation) forName(
+ "weka.attributeSelection",
+ ASEvaluation.class,
+ tmpStr,
+ tmpOptions));
+ }
+
+ tmpStr = Utils.getOption("search", options);
+ tmpOptions = Utils.splitOptions(tmpStr);
+ if (tmpOptions.length != 0) {
+ tmpStr = tmpOptions[0];
+ tmpOptions[0] = "";
+ setSearch(
+ (ASSearch) forName(
+ "weka.attributeSelection",
+ ASSearch.class,
+ tmpStr,
+ tmpOptions));
+ }
+
+ tmpStr = Utils.getOption("test", options);
+ setTestEvaluator(!tmpStr.equalsIgnoreCase("search"));
+ }
+
+ /**
+ * Gets the current settings of the CheckAttributeSelection.
+ *
+ * @return an array of strings suitable for passing to setOptions
+ */
+ public String[] getOptions() {
+ Vector result;
+ String[] options;
+ int i;
+
+ result = new Vector();
+
+ options = super.getOptions();
+ for (i = 0; i < options.length; i++)
+ result.add(options[i]);
+
+ result.add("-eval");
+ if (getEvaluator() instanceof OptionHandler)
+ result.add(
+ getEvaluator().getClass().getName()
+ + " "
+ + Utils.joinOptions(((OptionHandler) getEvaluator()).getOptions()));
+ else
+ result.add(
+ getEvaluator().getClass().getName());
+
+ result.add("-search");
+ if (getSearch() instanceof OptionHandler)
+ result.add(
+ getSearch().getClass().getName()
+ + " "
+ + Utils.joinOptions(((OptionHandler) getSearch()).getOptions()));
+ else
+ result.add(
+ getSearch().getClass().getName());
+
+ result.add("-test");
+ if (getTestEvaluator())
+ result.add("eval");
+ else
+ result.add("search");
+
+ return (String[]) result.toArray(new String[result.size()]);
+ }
+
+ /**
+ * Begin the tests, reporting results to System.out
+ */
+ public void doTests() {
+
+ if (getTestObject() == null) {
+ println("\n=== No scheme set ===");
+ return;
+ }
+ println("\n=== Check on scheme: "
+ + getTestObject().getClass().getName()
+ + " ===\n");
+
+ // Start tests
+ m_ClasspathProblems = false;
+ println("--> Checking for interfaces");
+ canTakeOptions();
+ boolean weightedInstancesHandler = weightedInstancesHandler()[0];
+ boolean multiInstanceHandler = multiInstanceHandler()[0];
+ println("--> Scheme tests");
+ declaresSerialVersionUID();
+ testsPerClassType(Attribute.NOMINAL, weightedInstancesHandler, multiInstanceHandler);
+ testsPerClassType(Attribute.NUMERIC, weightedInstancesHandler, multiInstanceHandler);
+ testsPerClassType(Attribute.DATE, weightedInstancesHandler, multiInstanceHandler);
+ testsPerClassType(Attribute.STRING, weightedInstancesHandler, multiInstanceHandler);
+ testsPerClassType(Attribute.RELATIONAL, weightedInstancesHandler, multiInstanceHandler);
+ }
+
+ /**
+ * Set the evaluator to test.
+ *
+ * @param value the evaluator to use.
+ */
+ public void setEvaluator(ASEvaluation value) {
+ m_Evaluator = value;
+ }
+
+ /**
+ * Get the current evaluator
+ *
+ * @return the current evaluator
+ */
+ public ASEvaluation getEvaluator() {
+ return m_Evaluator;
+ }
+
+ /**
+ * Set the search method to test.
+ *
+ * @param value the search method to use.
+ */
+ public void setSearch(ASSearch value) {
+ m_Search = value;
+ }
+
+ /**
+ * Get the current search method
+ *
+ * @return the current search method
+ */
+ public ASSearch getSearch() {
+ return m_Search;
+ }
+
+ /**
+ * Sets whether the evaluator or the search method is being tested.
+ *
+ * @param value if true then the evaluator will be tested
+ */
+ public void setTestEvaluator(boolean value) {
+ m_TestEvaluator = value;
+ }
+
+ /**
+ * Gets whether the evaluator is being tested or the search method.
+ *
+ * @return true if the evaluator is being tested
+ */
+ public boolean getTestEvaluator() {
+ return m_TestEvaluator;
+ }
+
+ /**
+ * returns either the evaluator or the search method.
+ *
+ * @return the object to be tested
+ * @see #m_TestEvaluator
+ */
+ protected Object getTestObject() {
+ if (getTestEvaluator())
+ return getEvaluator();
+ else
+ return getSearch();
+ }
+
+ /**
+ * returns deep copies of the given object
+ *
+ * @param obj the object to copy
+ * @param num the number of copies
+ * @return the deep copies
+ * @throws Exception if copying fails
+ */
+ protected Object[] makeCopies(Object obj, int num) throws Exception {
+ if (obj == null)
+ throw new Exception("No object set");
+
+ Object[] objs = new Object[num];
+ SerializedObject so = new SerializedObject(obj);
+ for(int i = 0; i < objs.length; i++) {
+ objs[i] = so.getObject();
+ }
+
+ return objs;
+ }
+
+ /**
+ * Performs a attribute selection with the given search and evaluation scheme
+ * on the provided data. The generated AttributeSelection object is returned.
+ *
+ * @param search the search scheme to use
+ * @param eval the evaluator to use
+ * @param data the data to work on
+ * @return the used attribute selection object
+ * @throws Exception if the attribute selection fails
+ */
+ protected AttributeSelection search(ASSearch search, ASEvaluation eval,
+ Instances data) throws Exception {
+
+ AttributeSelection result;
+
+ result = new AttributeSelection();
+ result.setSeed(42);
+ result.setSearch(search);
+ result.setEvaluator(eval);
+ result.SelectAttributes(data);
+
+ return result;
+ }
+
+ /**
+ * Run a battery of tests for a given class attribute type
+ *
+ * @param classType true if the class attribute should be numeric
+ * @param weighted true if the scheme says it handles weights
+ * @param multiInstance true if the scheme handles multi-instance data
+ */
+ protected void testsPerClassType(int classType,
+ boolean weighted,
+ boolean multiInstance) {
+
+ boolean PNom = canPredict(true, false, false, false, false, multiInstance, classType)[0];
+ boolean PNum = canPredict(false, true, false, false, false, multiInstance, classType)[0];
+ boolean PStr = canPredict(false, false, true, false, false, multiInstance, classType)[0];
+ boolean PDat = canPredict(false, false, false, true, false, multiInstance, classType)[0];
+ boolean PRel;
+ if (!multiInstance)
+ PRel = canPredict(false, false, false, false, true, multiInstance, classType)[0];
+ else
+ PRel = false;
+
+ if (PNom || PNum || PStr || PDat || PRel) {
+ if (weighted)
+ instanceWeights(PNom, PNum, PStr, PDat, PRel, multiInstance, classType);
+
+ if (classType == Attribute.NOMINAL)
+ canHandleNClasses(PNom, PNum, PStr, PDat, PRel, multiInstance, 4);
+
+ if (!multiInstance) {
+ canHandleClassAsNthAttribute(PNom, PNum, PStr, PDat, PRel, multiInstance, classType, 0);
+ canHandleClassAsNthAttribute(PNom, PNum, PStr, PDat, PRel, multiInstance, classType, 1);
+ }
+
+ canHandleZeroTraining(PNom, PNum, PStr, PDat, PRel, multiInstance, classType);
+ boolean handleMissingPredictors = canHandleMissing(PNom, PNum, PStr, PDat, PRel,
+ multiInstance, classType,
+ true, false, 20)[0];
+ if (handleMissingPredictors)
+ canHandleMissing(PNom, PNum, PStr, PDat, PRel, multiInstance, classType, true, false, 100);
+
+ boolean handleMissingClass = canHandleMissing(PNom, PNum, PStr, PDat, PRel,
+ multiInstance, classType,
+ false, true, 20)[0];
+ if (handleMissingClass)
+ canHandleMissing(PNom, PNum, PStr, PDat, PRel, multiInstance, classType, false, true, 100);
+
+ correctSearchInitialisation(PNom, PNum, PStr, PDat, PRel, multiInstance, classType);
+ datasetIntegrity(PNom, PNum, PStr, PDat, PRel, multiInstance, classType,
+ handleMissingPredictors, handleMissingClass);
+ }
+ }
+
+ /**
+ * Checks whether the scheme can take command line options.
+ *
+ * @return index 0 is true if the scheme can take options
+ */
+ protected boolean[] canTakeOptions() {
+
+ boolean[] result = new boolean[2];
+
+ print("options...");
+ if (getTestObject() instanceof OptionHandler) {
+ println("yes");
+ if (m_Debug) {
+ println("\n=== Full report ===");
+ Enumeration enu = ((OptionHandler) getTestObject()).listOptions();
+ while (enu.hasMoreElements()) {
+ Option option = (Option) enu.nextElement();
+ print(option.synopsis() + "\n"
+ + option.description() + "\n");
+ }
+ println("\n");
+ }
+ result[0] = true;
+ }
+ else {
+ println("no");
+ result[0] = false;
+ }
+
+ return result;
+ }
+
+ /**
+ * Checks whether the scheme says it can handle instance weights.
+ *
+ * @return true if the scheme handles instance weights
+ */
+ protected boolean[] weightedInstancesHandler() {
+
+ boolean[] result = new boolean[2];
+
+ print("weighted instances scheme...");
+ if (getTestObject() instanceof WeightedInstancesHandler) {
+ println("yes");
+ result[0] = true;
+ }
+ else {
+ println("no");
+ result[0] = false;
+ }
+
+ return result;
+ }
+
+ /**
+ * Checks whether the scheme handles multi-instance data.
+ *
+ * @return true if the scheme handles multi-instance data
+ */
+ protected boolean[] multiInstanceHandler() {
+ boolean[] result = new boolean[2];
+
+ print("multi-instance scheme...");
+ if (getTestObject() instanceof MultiInstanceCapabilitiesHandler) {
+ println("yes");
+ result[0] = true;
+ }
+ else {
+ println("no");
+ result[0] = false;
+ }
+
+ return result;
+ }
+
+ /**
+ * tests for a serialVersionUID. Fails in case the schemes don't declare
+ * a UID (both must!).
+ *
+ * @return index 0 is true if the scheme declares a UID
+ */
+ protected boolean[] declaresSerialVersionUID() {
+ boolean[] result = new boolean[2];
+ boolean eval;
+ boolean search;
+
+ print("serialVersionUID...");
+
+ eval = !SerializationHelper.needsUID(m_Evaluator.getClass());
+ search = !SerializationHelper.needsUID(m_Search.getClass());
+
+ result[0] = eval && search;
+
+ if (result[0])
+ println("yes");
+ else
+ println("no");
+
+ return result;
+ }
+
+ /**
+ * Checks basic prediction of the scheme, for simple non-troublesome
+ * datasets.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NOMINAL, NUMERIC, etc.)
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ */
+ protected boolean[] canPredict(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType) {
+
+ print("basic predict");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ FastVector accepts = new FastVector();
+ accepts.addElement("unary");
+ accepts.addElement("binary");
+ accepts.addElement("nominal");
+ accepts.addElement("numeric");
+ accepts.addElement("string");
+ accepts.addElement("date");
+ accepts.addElement("relational");
+ accepts.addElement("multi-instance");
+ accepts.addElement("not in classpath");
+ int numTrain = getNumInstances(), numClasses = 2, missingLevel = 0;
+ boolean predictorMissing = false, classMissing = false;
+
+ return runBasicTest(nominalPredictor, numericPredictor, stringPredictor,
+ datePredictor, relationalPredictor,
+ multiInstance,
+ classType,
+ missingLevel, predictorMissing, classMissing,
+ numTrain, numClasses,
+ accepts);
+ }
+
+ /**
+ * Checks whether nominal schemes can handle more than two classes.
+ * If a scheme is only designed for two-class problems it should
+ * throw an appropriate exception for multi-class problems.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param numClasses the number of classes to test
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ */
+ protected boolean[] canHandleNClasses(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int numClasses) {
+
+ print("more than two class problems");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, Attribute.NOMINAL);
+ print("...");
+ FastVector accepts = new FastVector();
+ accepts.addElement("number");
+ accepts.addElement("class");
+ int numTrain = getNumInstances(), missingLevel = 0;
+ boolean predictorMissing = false, classMissing = false;
+
+ return runBasicTest(nominalPredictor, numericPredictor, stringPredictor,
+ datePredictor, relationalPredictor,
+ multiInstance,
+ Attribute.NOMINAL,
+ missingLevel, predictorMissing, classMissing,
+ numTrain, numClasses,
+ accepts);
+ }
+
+ /**
+ * Checks whether the scheme can handle class attributes as Nth attribute.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param classIndex the index of the class attribute (0-based, -1 means last attribute)
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ * @see TestInstances#CLASS_IS_LAST
+ */
+ protected boolean[] canHandleClassAsNthAttribute(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType,
+ int classIndex) {
+
+ if (classIndex == TestInstances.CLASS_IS_LAST)
+ print("class attribute as last attribute");
+ else
+ print("class attribute as " + (classIndex + 1) + ". attribute");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ FastVector accepts = new FastVector();
+ int numTrain = getNumInstances(), numClasses = 2, missingLevel = 0;
+ boolean predictorMissing = false, classMissing = false;
+
+ return runBasicTest(nominalPredictor, numericPredictor, stringPredictor,
+ datePredictor, relationalPredictor,
+ multiInstance,
+ classType,
+ classIndex,
+ missingLevel, predictorMissing, classMissing,
+ numTrain, numClasses,
+ accepts);
+ }
+
+ /**
+ * Checks whether the scheme can handle zero training instances.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ */
+ protected boolean[] canHandleZeroTraining(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType) {
+
+ print("handle zero training instances");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ FastVector accepts = new FastVector();
+ accepts.addElement("train");
+ accepts.addElement("value");
+ int numTrain = 0, numClasses = 2, missingLevel = 0;
+ boolean predictorMissing = false, classMissing = false;
+
+ return runBasicTest(
+ nominalPredictor, numericPredictor, stringPredictor,
+ datePredictor, relationalPredictor,
+ multiInstance,
+ classType,
+ missingLevel, predictorMissing, classMissing,
+ numTrain, numClasses,
+ accepts);
+ }
+
+ /**
+ * Checks whether the scheme correctly initialises models when
+ * ASSearch.search is called. This test calls search with
+ * one training dataset. ASSearch is then called on a training set with
+ * different structure, and then again with the original training set.
+ * If the equals method of the ASEvaluation class returns false, this is
+ * noted as incorrect search initialisation.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @return index 0 is true if the test was passed, index 1 is always false
+ */
+ protected boolean[] correctSearchInitialisation(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType) {
+
+ boolean[] result = new boolean[2];
+ print("correct initialisation during search");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ int numTrain = getNumInstances(),
+ numClasses = 2, missingLevel = 0;
+ boolean predictorMissing = false, classMissing = false;
+
+ Instances train1 = null;
+ Instances train2 = null;
+ ASSearch search = null;
+ ASEvaluation evaluation1A = null;
+ ASEvaluation evaluation1B = null;
+ ASEvaluation evaluation2 = null;
+ AttributeSelection attsel1A = null;
+ AttributeSelection attsel1B = null;
+ int stage = 0;
+ try {
+
+ // Make two train sets with different numbers of attributes
+ train1 = makeTestDataset(42, numTrain,
+ nominalPredictor ? getNumNominal() : 0,
+ numericPredictor ? getNumNumeric() : 0,
+ stringPredictor ? getNumString() : 0,
+ datePredictor ? getNumDate() : 0,
+ relationalPredictor ? getNumRelational() : 0,
+ numClasses,
+ classType,
+ multiInstance);
+ train2 = makeTestDataset(84, numTrain,
+ nominalPredictor ? getNumNominal() + 1 : 0,
+ numericPredictor ? getNumNumeric() + 1 : 0,
+ stringPredictor ? getNumString() : 0,
+ datePredictor ? getNumDate() : 0,
+ relationalPredictor ? getNumRelational() : 0,
+ numClasses,
+ classType,
+ multiInstance);
+ if (missingLevel > 0) {
+ addMissing(train1, missingLevel, predictorMissing, classMissing);
+ addMissing(train2, missingLevel, predictorMissing, classMissing);
+ }
+
+ search = ASSearch.makeCopies(getSearch(), 1)[0];
+ evaluation1A = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ evaluation1B = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ evaluation2 = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ } catch (Exception ex) {
+ throw new Error("Error setting up for tests: " + ex.getMessage());
+ }
+ try {
+ stage = 0;
+ attsel1A = search(search, evaluation1A, train1);
+
+ stage = 1;
+ search(search, evaluation2, train2);
+
+ stage = 2;
+ attsel1B = search(search, evaluation1B, train1);
+
+ stage = 3;
+ if (!attsel1A.toResultsString().equals(attsel1B.toResultsString())) {
+ if (m_Debug) {
+ println(
+ "\n=== Full report ===\n"
+ + "\nFirst search\n"
+ + attsel1A.toResultsString()
+ + "\n\n");
+ println(
+ "\nSecond search\n"
+ + attsel1B.toResultsString()
+ + "\n\n");
+ }
+ throw new Exception("Results differ between search calls");
+ }
+ println("yes");
+ result[0] = true;
+
+ if (false && m_Debug) {
+ println(
+ "\n=== Full report ===\n"
+ + "\nFirst search\n"
+ + evaluation1A.toString()
+ + "\n\n");
+ println(
+ "\nSecond search\n"
+ + evaluation1B.toString()
+ + "\n\n");
+ }
+ }
+ catch (Exception ex) {
+ println("no");
+ result[0] = false;
+ if (m_Debug) {
+ println("\n=== Full Report ===");
+ print("Problem during training");
+ switch (stage) {
+ case 0:
+ print(" of dataset 1");
+ break;
+ case 1:
+ print(" of dataset 2");
+ break;
+ case 2:
+ print(" of dataset 1 (2nd build)");
+ break;
+ case 3:
+ print(", comparing results from builds of dataset 1");
+ break;
+ }
+ println(": " + ex.getMessage() + "\n");
+ println("here are the datasets:\n");
+ println("=== Train1 Dataset ===\n"
+ + train1.toString() + "\n");
+ println("=== Train2 Dataset ===\n"
+ + train2.toString() + "\n");
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Checks basic missing value handling of the scheme. If the missing
+ * values cause an exception to be thrown by the scheme, this will be
+ * recorded.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param predictorMissing true if the missing values may be in
+ * the predictors
+ * @param classMissing true if the missing values may be in the class
+ * @param missingLevel the percentage of missing values
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ */
+ protected boolean[] canHandleMissing(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType,
+ boolean predictorMissing,
+ boolean classMissing,
+ int missingLevel) {
+
+ if (missingLevel == 100)
+ print("100% ");
+ print("missing");
+ if (predictorMissing) {
+ print(" predictor");
+ if (classMissing)
+ print(" and");
+ }
+ if (classMissing)
+ print(" class");
+ print(" values");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ FastVector accepts = new FastVector();
+ accepts.addElement("missing");
+ accepts.addElement("value");
+ accepts.addElement("train");
+ accepts.addElement("no attributes");
+ int numTrain = getNumInstances(), numClasses = 2;
+
+ return runBasicTest(nominalPredictor, numericPredictor, stringPredictor,
+ datePredictor, relationalPredictor,
+ multiInstance,
+ classType,
+ missingLevel, predictorMissing, classMissing,
+ numTrain, numClasses,
+ accepts);
+ }
+
+ /**
+ * Checks whether the scheme can handle instance weights.
+ * This test compares the scheme performance on two datasets
+ * that are identical except for the training weights. If the
+ * results change, then the scheme must be using the weights. It
+ * may be possible to get a false positive from this test if the
+ * weight changes aren't significant enough to induce a change
+ * in scheme performance (but the weights are chosen to minimize
+ * the likelihood of this).
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @return index 0 true if the test was passed
+ */
+ protected boolean[] instanceWeights(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType) {
+
+ print("scheme uses instance weights");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ int numTrain = 2*getNumInstances(),
+ numClasses = 2, missingLevel = 0;
+ boolean predictorMissing = false, classMissing = false;
+
+ boolean[] result = new boolean[2];
+ Instances train = null;
+ ASSearch[] search = null;
+ ASEvaluation evaluationB = null;
+ ASEvaluation evaluationI = null;
+ AttributeSelection attselB = null;
+ AttributeSelection attselI = null;
+ boolean evalFail = false;
+ try {
+ train = makeTestDataset(42, numTrain,
+ nominalPredictor ? getNumNominal() + 1 : 0,
+ numericPredictor ? getNumNumeric() + 1 : 0,
+ stringPredictor ? getNumString() : 0,
+ datePredictor ? getNumDate() : 0,
+ relationalPredictor ? getNumRelational() : 0,
+ numClasses,
+ classType,
+ multiInstance);
+ if (missingLevel > 0)
+ addMissing(train, missingLevel, predictorMissing, classMissing);
+ search = ASSearch.makeCopies(getSearch(), 2);
+ evaluationB = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ evaluationI = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ attselB = search(search[0], evaluationB, train);
+ } catch (Exception ex) {
+ throw new Error("Error setting up for tests: " + ex.getMessage());
+ }
+ try {
+
+ // Now modify instance weights and re-built/test
+ for (int i = 0; i < train.numInstances(); i++) {
+ train.instance(i).setWeight(0);
+ }
+ Random random = new Random(1);
+ for (int i = 0; i < train.numInstances() / 2; i++) {
+ int inst = Math.abs(random.nextInt()) % train.numInstances();
+ int weight = Math.abs(random.nextInt()) % 10 + 1;
+ train.instance(inst).setWeight(weight);
+ }
+ attselI = search(search[1], evaluationI, train);
+ if (attselB.toResultsString().equals(attselI.toResultsString())) {
+ // println("no");
+ evalFail = true;
+ throw new Exception("evalFail");
+ }
+
+ println("yes");
+ result[0] = true;
+ } catch (Exception ex) {
+ println("no");
+ result[0] = false;
+
+ if (m_Debug) {
+ println("\n=== Full Report ===");
+
+ if (evalFail) {
+ println("Results don't differ between non-weighted and "
+ + "weighted instance models.");
+ println("Here are the results:\n");
+ println("\nboth methods\n");
+ println(evaluationB.toString());
+ } else {
+ print("Problem during training");
+ println(": " + ex.getMessage() + "\n");
+ }
+ println("Here is the dataset:\n");
+ println("=== Train Dataset ===\n"
+ + train.toString() + "\n");
+ println("=== Train Weights ===\n");
+ for (int i = 0; i < train.numInstances(); i++) {
+ println(" " + (i + 1)
+ + " " + train.instance(i).weight());
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Checks whether the scheme alters the training dataset during
+ * training. If the scheme needs to modify the training
+ * data it should take a copy of the training data. Currently checks
+ * for changes to header structure, number of instances, order of
+ * instances, instance weights.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param predictorMissing true if we know the scheme can handle
+ * (at least) moderate missing predictor values
+ * @param classMissing true if we know the scheme can handle
+ * (at least) moderate missing class values
+ * @return index 0 is true if the test was passed
+ */
+ protected boolean[] datasetIntegrity(
+ boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType,
+ boolean predictorMissing,
+ boolean classMissing) {
+
+ print("scheme doesn't alter original datasets");
+ printAttributeSummary(
+ nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance, classType);
+ print("...");
+ int numTrain = getNumInstances(),
+ numClasses = 2, missingLevel = 20;
+
+ boolean[] result = new boolean[2];
+ Instances train = null;
+ Instances trainCopy = null;
+ ASSearch search = null;
+ ASEvaluation evaluation = null;
+ try {
+ train = makeTestDataset(42, numTrain,
+ nominalPredictor ? getNumNominal() : 0,
+ numericPredictor ? getNumNumeric() : 0,
+ stringPredictor ? getNumString() : 0,
+ datePredictor ? getNumDate() : 0,
+ relationalPredictor ? getNumRelational() : 0,
+ numClasses,
+ classType,
+ multiInstance);
+ if (missingLevel > 0)
+ addMissing(train, missingLevel, predictorMissing, classMissing);
+ search = ASSearch.makeCopies(getSearch(), 1)[0];
+ evaluation = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ trainCopy = new Instances(train);
+ } catch (Exception ex) {
+ throw new Error("Error setting up for tests: " + ex.getMessage());
+ }
+ try {
+ search(search, evaluation, trainCopy);
+ compareDatasets(train, trainCopy);
+
+ println("yes");
+ result[0] = true;
+ } catch (Exception ex) {
+ println("no");
+ result[0] = false;
+
+ if (m_Debug) {
+ println("\n=== Full Report ===");
+ print("Problem during training");
+ println(": " + ex.getMessage() + "\n");
+ println("Here are the datasets:\n");
+ println("=== Train Dataset (original) ===\n"
+ + trainCopy.toString() + "\n");
+ println("=== Train Dataset ===\n"
+ + train.toString() + "\n");
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Runs a text on the datasets with the given characteristics.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param missingLevel the percentage of missing values
+ * @param predictorMissing true if the missing values may be in
+ * the predictors
+ * @param classMissing true if the missing values may be in the class
+ * @param numTrain the number of instances in the training set
+ * @param numClasses the number of classes
+ * @param accepts the acceptable string in an exception
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ */
+ protected boolean[] runBasicTest(boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType,
+ int missingLevel,
+ boolean predictorMissing,
+ boolean classMissing,
+ int numTrain,
+ int numClasses,
+ FastVector accepts) {
+
+ return runBasicTest(
+ nominalPredictor,
+ numericPredictor,
+ stringPredictor,
+ datePredictor,
+ relationalPredictor,
+ multiInstance,
+ classType,
+ TestInstances.CLASS_IS_LAST,
+ missingLevel,
+ predictorMissing,
+ classMissing,
+ numTrain,
+ numClasses,
+ accepts);
+ }
+
+ /**
+ * Runs a text on the datasets with the given characteristics.
+ *
+ * @param nominalPredictor if true use nominal predictor attributes
+ * @param numericPredictor if true use numeric predictor attributes
+ * @param stringPredictor if true use string predictor attributes
+ * @param datePredictor if true use date predictor attributes
+ * @param relationalPredictor if true use relational predictor attributes
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param classIndex the attribute index of the class
+ * @param missingLevel the percentage of missing values
+ * @param predictorMissing true if the missing values may be in
+ * the predictors
+ * @param classMissing true if the missing values may be in the class
+ * @param numTrain the number of instances in the training set
+ * @param numClasses the number of classes
+ * @param accepts the acceptable string in an exception
+ * @return index 0 is true if the test was passed, index 1 is true if test
+ * was acceptable
+ */
+ protected boolean[] runBasicTest(boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType,
+ int classIndex,
+ int missingLevel,
+ boolean predictorMissing,
+ boolean classMissing,
+ int numTrain,
+ int numClasses,
+ FastVector accepts) {
+
+ boolean[] result = new boolean[2];
+ Instances train = null;
+ ASSearch search = null;
+ ASEvaluation evaluation = null;
+ try {
+ train = makeTestDataset(42, numTrain,
+ nominalPredictor ? getNumNominal() : 0,
+ numericPredictor ? getNumNumeric() : 0,
+ stringPredictor ? getNumString() : 0,
+ datePredictor ? getNumDate() : 0,
+ relationalPredictor ? getNumRelational() : 0,
+ numClasses,
+ classType,
+ classIndex,
+ multiInstance);
+ if (missingLevel > 0)
+ addMissing(train, missingLevel, predictorMissing, classMissing);
+ search = ASSearch.makeCopies(getSearch(), 1)[0];
+ evaluation = ASEvaluation.makeCopies(getEvaluator(), 1)[0];
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Error setting up for tests: " + ex.getMessage());
+ }
+ try {
+ search(search, evaluation, train);
+ println("yes");
+ result[0] = true;
+ }
+ catch (Exception ex) {
+ boolean acceptable = false;
+ String msg;
+ if (ex.getMessage() == null)
+ msg = "";
+ else
+ msg = ex.getMessage().toLowerCase();
+ if (msg.indexOf("not in classpath") > -1)
+ m_ClasspathProblems = true;
+ for (int i = 0; i < accepts.size(); i++) {
+ if (msg.indexOf((String)accepts.elementAt(i)) >= 0) {
+ acceptable = true;
+ }
+ }
+
+ println("no" + (acceptable ? " (OK error message)" : ""));
+ result[1] = acceptable;
+
+ if (m_Debug) {
+ println("\n=== Full Report ===");
+ print("Problem during training");
+ println(": " + ex.getMessage() + "\n");
+ if (!acceptable) {
+ if (accepts.size() > 0) {
+ print("Error message doesn't mention ");
+ for (int i = 0; i < accepts.size(); i++) {
+ if (i != 0) {
+ print(" or ");
+ }
+ print('"' + (String)accepts.elementAt(i) + '"');
+ }
+ }
+ println("here is the dataset:\n");
+ println("=== Train Dataset ===\n"
+ + train.toString() + "\n");
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Make a simple set of instances, which can later be modified
+ * for use in specific tests.
+ *
+ * @param seed the random number seed
+ * @param numInstances the number of instances to generate
+ * @param numNominal the number of nominal attributes
+ * @param numNumeric the number of numeric attributes
+ * @param numString the number of string attributes
+ * @param numDate the number of date attributes
+ * @param numRelational the number of relational attributes
+ * @param numClasses the number of classes (if nominal class)
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param multiInstance whether the dataset should a multi-instance dataset
+ * @return the test dataset
+ * @throws Exception if the dataset couldn't be generated
+ * @see #process(Instances)
+ */
+ protected Instances makeTestDataset(int seed, int numInstances,
+ int numNominal, int numNumeric,
+ int numString, int numDate,
+ int numRelational,
+ int numClasses, int classType,
+ boolean multiInstance)
+ throws Exception {
+
+ return makeTestDataset(
+ seed,
+ numInstances,
+ numNominal,
+ numNumeric,
+ numString,
+ numDate,
+ numRelational,
+ numClasses,
+ classType,
+ TestInstances.CLASS_IS_LAST,
+ multiInstance);
+ }
+
+ /**
+ * Make a simple set of instances with variable position of the class
+ * attribute, which can later be modified for use in specific tests.
+ *
+ * @param seed the random number seed
+ * @param numInstances the number of instances to generate
+ * @param numNominal the number of nominal attributes
+ * @param numNumeric the number of numeric attributes
+ * @param numString the number of string attributes
+ * @param numDate the number of date attributes
+ * @param numRelational the number of relational attributes
+ * @param numClasses the number of classes (if nominal class)
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ * @param classIndex the index of the class (0-based, -1 as last)
+ * @param multiInstance whether the dataset should a multi-instance dataset
+ * @return the test dataset
+ * @throws Exception if the dataset couldn't be generated
+ * @see TestInstances#CLASS_IS_LAST
+ * @see #process(Instances)
+ */
+ protected Instances makeTestDataset(int seed, int numInstances,
+ int numNominal, int numNumeric,
+ int numString, int numDate,
+ int numRelational,
+ int numClasses, int classType,
+ int classIndex,
+ boolean multiInstance)
+ throws Exception {
+
+ TestInstances dataset = new TestInstances();
+
+ dataset.setSeed(seed);
+ dataset.setNumInstances(numInstances);
+ dataset.setNumNominal(numNominal);
+ dataset.setNumNumeric(numNumeric);
+ dataset.setNumString(numString);
+ dataset.setNumDate(numDate);
+ dataset.setNumRelational(numRelational);
+ dataset.setNumClasses(numClasses);
+ dataset.setClassType(classType);
+ dataset.setClassIndex(classIndex);
+ dataset.setNumClasses(numClasses);
+ dataset.setMultiInstance(multiInstance);
+ dataset.setWords(getWords());
+ dataset.setWordSeparators(getWordSeparators());
+
+ return process(dataset.generate());
+ }
+
+ /**
+ * Print out a short summary string for the dataset characteristics
+ *
+ * @param nominalPredictor true if nominal predictor attributes are present
+ * @param numericPredictor true if numeric predictor attributes are present
+ * @param stringPredictor true if string predictor attributes are present
+ * @param datePredictor true if date predictor attributes are present
+ * @param relationalPredictor true if relational predictor attributes are present
+ * @param multiInstance whether multi-instance is needed
+ * @param classType the class type (NUMERIC, NOMINAL, etc.)
+ */
+ protected void printAttributeSummary(boolean nominalPredictor,
+ boolean numericPredictor,
+ boolean stringPredictor,
+ boolean datePredictor,
+ boolean relationalPredictor,
+ boolean multiInstance,
+ int classType) {
+
+ String str = "";
+
+ if (numericPredictor)
+ str += " numeric";
+
+ if (nominalPredictor) {
+ if (str.length() > 0)
+ str += " &";
+ str += " nominal";
+ }
+
+ if (stringPredictor) {
+ if (str.length() > 0)
+ str += " &";
+ str += " string";
+ }
+
+ if (datePredictor) {
+ if (str.length() > 0)
+ str += " &";
+ str += " date";
+ }
+
+ if (relationalPredictor) {
+ if (str.length() > 0)
+ str += " &";
+ str += " relational";
+ }
+
+ str += " predictors)";
+
+ switch (classType) {
+ case Attribute.NUMERIC:
+ str = " (numeric class," + str;
+ break;
+ case Attribute.NOMINAL:
+ str = " (nominal class," + str;
+ break;
+ case Attribute.STRING:
+ str = " (string class," + str;
+ break;
+ case Attribute.DATE:
+ str = " (date class," + str;
+ break;
+ case Attribute.RELATIONAL:
+ str = " (relational class," + str;
+ break;
+ }
+
+ print(str);
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 4783 $");
+ }
+
+ /**
+ * Test method for this class
+ *
+ * @param args the commandline parameters
+ */
+ public static void main(String [] args) {
+ runCheck(new CheckAttributeSelection(), args);
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ChiSquaredAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ChiSquaredAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ChiSquaredAttributeEval.java (revision 29)
@@ -0,0 +1,463 @@
+/*
+ * 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.
+ */
+
+/*
+ * ChiSquaredAttributeEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Capabilities;
+import weka.core.ContingencyTables;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.filters.Filter;
+import weka.filters.supervised.attribute.Discretize;
+import weka.filters.unsupervised.attribute.NumericToBinary;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * ChiSquaredAttributeEval :
+ *
+ * Evaluates the worth of an attribute by computing the value of the chi-squared statistic with respect to the class.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+ * -B
+ * just binarize numeric attributes instead
+ * of properly discretizing them.
+ *
+
+ *
+ * @author Eibe Frank (eibe@cs.waikato.ac.nz)
+ * @version $Revision: 5447 $
+ * @see Discretize
+ * @see NumericToBinary
+ */
+public class ChiSquaredAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -8316857822521717692L;
+
+ /** Treat missing values as a seperate value */
+ private boolean m_missing_merge;
+
+ /** Just binarize numeric attributes */
+ private boolean m_Binarize;
+
+ /** The chi-squared value for each attribute */
+ private double[] m_ChiSquareds;
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "ChiSquaredAttributeEval :\n\nEvaluates the worth of an attribute "
+ +"by computing the value of the chi-squared statistic with respect to the class.\n";
+ }
+
+ /**
+ * Constructor
+ */
+ public ChiSquaredAttributeEval () {
+ resetOptions();
+ }
+
+ /**
+ * Returns an enumeration describing the available options
+ * @return an enumeration of all the available options
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(2);
+ newVector.addElement(new Option("\ttreat missing values as a seperate "
+ + "value.", "M", 0, "-M"));
+ newVector.addElement(new Option("\tjust binarize numeric attributes instead \n"
+ +"\tof properly discretizing them.", "B", 0,
+ "-B"));
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+ * -B
+ * just binarize numeric attributes instead
+ * of properly discretizing them.
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+
+ resetOptions();
+ setMissingMerge(!(Utils.getFlag('M', options)));
+ setBinarizeNumericAttributes(Utils.getFlag('B', options));
+ }
+
+
+ /**
+ * Gets the current settings.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[2];
+ int current = 0;
+
+ if (!getMissingMerge()) {
+ options[current++] = "-M";
+ }
+ if (getBinarizeNumericAttributes()) {
+ options[current++] = "-B";
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String binarizeNumericAttributesTipText() {
+ return "Just binarize numeric attributes instead of properly discretizing them.";
+ }
+
+ /**
+ * Binarize numeric attributes.
+ *
+ * @param b true=binarize numeric attributes
+ */
+ public void setBinarizeNumericAttributes (boolean b) {
+ m_Binarize = b;
+ }
+
+
+ /**
+ * get whether numeric attributes are just being binarized.
+ *
+ * @return true if missing values are being distributed.
+ */
+ public boolean getBinarizeNumericAttributes () {
+ return m_Binarize;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String missingMergeTipText() {
+ return "Distribute counts for missing values. Counts are distributed "
+ +"across other values in proportion to their frequency. Otherwise, "
+ +"missing is treated as a separate value.";
+ }
+
+ /**
+ * distribute the counts for missing values across observed values
+ *
+ * @param b true=distribute missing values.
+ */
+ public void setMissingMerge (boolean b) {
+ m_missing_merge = b;
+ }
+
+
+ /**
+ * get whether missing values are being distributed or not
+ *
+ * @return true if missing values are being distributed.
+ */
+ public boolean getMissingMerge () {
+ return m_missing_merge;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Initializes a chi-squared attribute evaluator.
+ * Discretizes all attributes that are numeric.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ int classIndex = data.classIndex();
+ int numInstances = data.numInstances();
+
+ if (!m_Binarize) {
+ Discretize disTransform = new Discretize();
+ disTransform.setUseBetterEncoding(true);
+ disTransform.setInputFormat(data);
+ data = Filter.useFilter(data, disTransform);
+ } else {
+ NumericToBinary binTransform = new NumericToBinary();
+ binTransform.setInputFormat(data);
+ data = Filter.useFilter(data, binTransform);
+ }
+ int numClasses = data.attribute(classIndex).numValues();
+
+ // Reserve space and initialize counters
+ double[][][] counts = new double[data.numAttributes()][][];
+ for (int k = 0; k < data.numAttributes(); k++) {
+ if (k != classIndex) {
+ int numValues = data.attribute(k).numValues();
+ counts[k] = new double[numValues + 1][numClasses + 1];
+ }
+ }
+
+ // Initialize counters
+ double[] temp = new double[numClasses + 1];
+ for (int k = 0; k < numInstances; k++) {
+ Instance inst = data.instance(k);
+ if (inst.classIsMissing()) {
+ temp[numClasses] += inst.weight();
+ } else {
+ temp[(int)inst.classValue()] += inst.weight();
+ }
+ }
+ for (int k = 0; k < counts.length; k++) {
+ if (k != classIndex) {
+ for (int i = 0; i < temp.length; i++) {
+ counts[k][0][i] = temp[i];
+ }
+ }
+ }
+
+ // Get counts
+ for (int k = 0; k < numInstances; k++) {
+ Instance inst = data.instance(k);
+ for (int i = 0; i < inst.numValues(); i++) {
+ if (inst.index(i) != classIndex) {
+ if (inst.isMissingSparse(i) || inst.classIsMissing()) {
+ if (!inst.isMissingSparse(i)) {
+ counts[inst.index(i)][(int)inst.valueSparse(i)][numClasses] +=
+ inst.weight();
+ counts[inst.index(i)][0][numClasses] -= inst.weight();
+ } else if (!inst.classIsMissing()) {
+ counts[inst.index(i)][data.attribute(inst.index(i)).numValues()]
+ [(int)inst.classValue()] += inst.weight();
+ counts[inst.index(i)][0][(int)inst.classValue()] -=
+ inst.weight();
+ } else {
+ counts[inst.index(i)][data.attribute(inst.index(i)).numValues()]
+ [numClasses] += inst.weight();
+ counts[inst.index(i)][0][numClasses] -= inst.weight();
+ }
+ } else {
+ counts[inst.index(i)][(int)inst.valueSparse(i)]
+ [(int)inst.classValue()] += inst.weight();
+ counts[inst.index(i)][0][(int)inst.classValue()] -= inst.weight();
+ }
+ }
+ }
+ }
+
+ // distribute missing counts if required
+ if (m_missing_merge) {
+
+ for (int k = 0; k < data.numAttributes(); k++) {
+ if (k != classIndex) {
+ int numValues = data.attribute(k).numValues();
+
+ // Compute marginals
+ double[] rowSums = new double[numValues];
+ double[] columnSums = new double[numClasses];
+ double sum = 0;
+ for (int i = 0; i < numValues; i++) {
+ for (int j = 0; j < numClasses; j++) {
+ rowSums[i] += counts[k][i][j];
+ columnSums[j] += counts[k][i][j];
+ }
+ sum += rowSums[i];
+ }
+
+ if (Utils.gr(sum, 0)) {
+ double[][] additions = new double[numValues][numClasses];
+
+ // Compute what needs to be added to each row
+ for (int i = 0; i < numValues; i++) {
+ for (int j = 0; j < numClasses; j++) {
+ additions[i][j] = (rowSums[i] / sum) * counts[k][numValues][j];
+ }
+ }
+
+ // Compute what needs to be added to each column
+ for (int i = 0; i < numClasses; i++) {
+ for (int j = 0; j < numValues; j++) {
+ additions[j][i] += (columnSums[i] / sum) *
+ counts[k][j][numClasses];
+ }
+ }
+
+ // Compute what needs to be added to each cell
+ for (int i = 0; i < numClasses; i++) {
+ for (int j = 0; j < numValues; j++) {
+ additions[j][i] += (counts[k][j][i] / sum) *
+ counts[k][numValues][numClasses];
+ }
+ }
+
+ // Make new contingency table
+ double[][] newTable = new double[numValues][numClasses];
+ for (int i = 0; i < numValues; i++) {
+ for (int j = 0; j < numClasses; j++) {
+ newTable[i][j] = counts[k][i][j] + additions[i][j];
+ }
+ }
+ counts[k] = newTable;
+ }
+ }
+ }
+ }
+
+ // Compute chi-squared values
+ m_ChiSquareds = new double[data.numAttributes()];
+ for (int i = 0; i < data.numAttributes(); i++) {
+ if (i != classIndex) {
+ m_ChiSquareds[i] = ContingencyTables.
+ chiVal(ContingencyTables.reduceMatrix(counts[i]), false);
+ }
+ }
+ }
+
+ /**
+ * Reset options to their default values
+ */
+ protected void resetOptions () {
+ m_ChiSquareds = null;
+ m_missing_merge = true;
+ m_Binarize = false;
+ }
+
+
+ /**
+ * evaluates an individual attribute by measuring its
+ * chi-squared value.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the chi-squared value
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute (int attribute)
+ throws Exception {
+
+ return m_ChiSquareds[attribute];
+ }
+
+ /**
+ * Describe the attribute evaluator
+ * @return a description of the attribute evaluator as a string
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_ChiSquareds == null) {
+ text.append("Chi-squared attribute evaluator has not been built");
+ }
+ else {
+ text.append("\tChi-squared Ranking Filter");
+ if (!m_missing_merge) {
+ text.append("\n\tMissing values treated as seperate");
+ }
+ if (m_Binarize) {
+ text.append("\n\tNumeric attributes are just binarized");
+ }
+ }
+
+ text.append("\n");
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5447 $");
+ }
+
+ /**
+ * Main method.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new ChiSquaredAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ClassifierAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ClassifierAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ClassifierAttributeEval.java (revision 29)
@@ -0,0 +1,468 @@
+/*
+ * 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.
+ */
+
+/*
+ * ClassifierAttributeEval.java
+ * Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.classifiers.Classifier;
+import weka.classifiers.AbstractClassifier;
+import weka.classifiers.Evaluation;
+import weka.classifiers.rules.OneR;
+import weka.core.Capabilities;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.filters.Filter;
+import weka.filters.unsupervised.attribute.Remove;
+
+import java.util.Enumeration;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+
+ * ClassifierAttributeEval :
+ *
+ * Evaluates the worth of an attribute by using a user-specified classifier.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -S <seed>
+ * Random number seed for cross validation.
+ * (default = 1)
+ *
+ * -F <folds>
+ * Number of folds for cross validation.
+ * (default = 10)
+ *
+ * -D
+ * Use training data for evaluation rather than cross validaton.
+ *
+ * -B <classname + options>
+ * Classifier to use.
+ * (default = OneR)
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @author FracPete (fracpete at waikato dot ac dot nz)
+ * @version $Revision: 5928 $
+ */
+public class ClassifierAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator, OptionHandler {
+
+ /** for serialization. */
+ private static final long serialVersionUID = 2442390690522602284L;
+
+ /** The training instances. */
+ protected Instances m_trainInstances;
+
+ /** Random number seed. */
+ protected int m_randomSeed;
+
+ /** Number of folds for cross validation. */
+ protected int m_folds;
+
+ /** Use training data to evaluate merit rather than x-val. */
+ protected boolean m_evalUsingTrainingData;
+
+ /** The classifier to use for evaluating the attribute. */
+ protected Classifier m_Classifier;
+
+ /**
+ * Constructor.
+ */
+ public ClassifierAttributeEval () {
+ resetOptions();
+ }
+
+ /**
+ * Returns a string describing this attribute evaluator.
+ *
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "ClassifierAttributeEval :\n\nEvaluates the worth of an attribute by "
+ +"using a user-specified classifier.\n";
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+ Vector result = new Vector();
+
+ result.addElement(new Option(
+ "\tRandom number seed for cross validation.\n"
+ + "\t(default = 1)",
+ "S", 1, "-S "));
+
+ result.addElement(new Option(
+ "\tNumber of folds for cross validation.\n"
+ + "\t(default = 10)",
+ "F", 1, "-F "));
+
+ result.addElement(new Option(
+ "\tUse training data for evaluation rather than cross validaton.",
+ "D", 0, "-D"));
+
+ result.addElement(new Option(
+ "\tClassifier to use.\n"
+ + "\t(default = OneR)",
+ "B", 1, "-B "));
+
+ return result.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -S <seed>
+ * Random number seed for cross validation.
+ * (default = 1)
+ *
+ * -F <folds>
+ * Number of folds for cross validation.
+ * (default = 10)
+ *
+ * -D
+ * Use training data for evaluation rather than cross validaton.
+ *
+ * -B <classname + options>
+ * Classifier to use.
+ * (default = OneR)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String [] options) throws Exception {
+ String tmpStr;
+ String[] tmpOptions;
+
+ tmpStr = Utils.getOption('S', options);
+ if (tmpStr.length() != 0)
+ setSeed(Integer.parseInt(tmpStr));
+
+ tmpStr = Utils.getOption('F', options);
+ if (tmpStr.length() != 0)
+ setFolds(Integer.parseInt(tmpStr));
+
+ tmpStr = Utils.getOption('B', options);
+ if (tmpStr.length() != 0) {
+ tmpOptions = Utils.splitOptions(tmpStr);
+ tmpStr = tmpOptions[0];
+ tmpOptions[0] = "";
+ setClassifier((Classifier) Utils.forName(Classifier.class, tmpStr, tmpOptions));
+ }
+
+ setEvalUsingTrainingData(Utils.getFlag('D', options));
+ Utils.checkForRemainingOptions(options);
+ }
+
+ /**
+ * returns the current setup.
+ *
+ * @return the options of the current setup
+ */
+ public String[] getOptions() {
+ Vector result;
+
+ result = new Vector();
+
+ if (getEvalUsingTrainingData())
+ result.add("-D");
+
+ result.add("-S");
+ result.add("" + getSeed());
+
+ result.add("-F");
+ result.add("" + getFolds());
+
+ result.add("-B");
+ result.add(
+ new String(
+ m_Classifier.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)m_Classifier).getOptions())).trim());
+
+ return result.toArray(new String[result.size()]);
+ }
+
+ /**
+ * Set the random number seed for cross validation.
+ *
+ * @param value the seed to use
+ */
+ public void setSeed(int value) {
+ m_randomSeed = value;
+ }
+
+ /**
+ * Get the random number seed.
+ *
+ * @return an int value
+ */
+ public int getSeed() {
+ return m_randomSeed;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text.
+ *
+ * @return a string describing this option
+ */
+ public String seedTipText() {
+ return "Set the seed for use in cross validation.";
+ }
+
+ /**
+ * Set the number of folds to use for cross validation.
+ *
+ * @param value the number of folds
+ */
+ public void setFolds(int value) {
+ m_folds = value;
+ if (m_folds < 2)
+ m_folds = 2;
+ }
+
+ /**
+ * Get the number of folds used for cross validation.
+ *
+ * @return the number of folds
+ */
+ public int getFolds() {
+ return m_folds;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text.
+ *
+ * @return a string describing this option
+ */
+ public String foldsTipText() {
+ return "Set the number of folds for cross validation.";
+ }
+
+ /**
+ * Use the training data to evaluate attributes rather than cross validation.
+ *
+ * @param value true if training data is to be used for evaluation
+ */
+ public void setEvalUsingTrainingData(boolean value) {
+ m_evalUsingTrainingData = value;
+ }
+
+ /**
+ * Returns true if the training data is to be used for evaluation.
+ *
+ * @return true if training data is to be used for evaluation
+ */
+ public boolean getEvalUsingTrainingData() {
+ return m_evalUsingTrainingData;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text.
+ *
+ * @return a string describing this option
+ */
+ public String evalUsingTrainingDataTipText() {
+ return "Use the training data to evaluate attributes rather than "
+ + "cross validation.";
+ }
+
+ /**
+ * Set the classifier to use for evaluating the attribute.
+ *
+ * @param value the classifier to use
+ */
+ public void setClassifier(Classifier value) {
+ m_Classifier = value;
+ }
+
+ /**
+ * Returns the classifier to use for evaluating the attribute.
+ *
+ * @return the classifier in use
+ */
+ public Classifier getClassifier() {
+ return m_Classifier;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text.
+ *
+ * @return a string describing this option
+ */
+ public String classifierTipText() {
+ return "The classifier to use for evaluating the attribute.";
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ if (m_Classifier != null) {
+ result = m_Classifier.getCapabilities();
+ result.setOwner(this);
+ }
+ else {
+ result = super.getCapabilities();
+ result.disableAll();
+ }
+
+ return result;
+ }
+
+ /**
+ * Initializes a ClassifierAttribute attribute evaluator.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been generated successfully
+ */
+ public void buildEvaluator (Instances data) throws Exception {
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ m_trainInstances = data;
+ }
+
+
+ /**
+ * Resets to defaults.
+ */
+ protected void resetOptions () {
+ m_trainInstances = null;
+ m_randomSeed = 1;
+ m_folds = 10;
+ m_evalUsingTrainingData = false;
+ m_Classifier = new OneR();
+ }
+
+
+ /**
+ * Evaluates an individual attribute by measuring the amount
+ * of information gained about the class given the attribute.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the evaluation
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute(int attribute) throws Exception {
+ int[] featArray;
+ double errorRate;
+ Evaluation eval;
+ Remove delTransform;
+ Instances train;
+ Classifier cls;
+
+ // create tmp dataset
+ featArray = new int[2]; // feat + class
+ delTransform = new Remove();
+ delTransform.setInvertSelection(true);
+ train = new Instances(m_trainInstances);
+ featArray[0] = attribute;
+ featArray[1] = train.classIndex();
+ delTransform.setAttributeIndicesArray(featArray);
+ delTransform.setInputFormat(train);
+ train = Filter.useFilter(train, delTransform);
+
+ // evaluate classifier
+ eval = new Evaluation(train);
+ cls = AbstractClassifier.makeCopy(m_Classifier);
+ if (m_evalUsingTrainingData) {
+ cls.buildClassifier(train);
+ eval.evaluateModel(cls, train);
+ }
+ else {
+ eval.crossValidateModel(cls, train, m_folds, new Random(m_randomSeed));
+ }
+ errorRate = eval.errorRate();
+
+ return (1 - errorRate)*100.0;
+ }
+
+ /**
+ * Return a description of the evaluator.
+ *
+ * @return description as a string
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_trainInstances == null) {
+ text.append("\tClassifier feature evaluator has not been built yet");
+ }
+ else {
+ text.append("\tClassifier feature evaluator.\n\n");
+ text.append("\tUsing ");
+ if (m_evalUsingTrainingData)
+ text.append("training data for evaluation of attributes.\n");
+ else
+ text.append(getFolds()+ " fold cross validation for evaluating attributes.\n");
+ text.append("\tClassifier in use: " + m_Classifier.getClass().getName() + " " + Utils.joinOptions(((OptionHandler)m_Classifier).getOptions()));
+ }
+ text.append("\n");
+
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5928 $");
+ }
+
+ /**
+ * Main method for executing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new ClassifierAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ClassifierSubsetEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ClassifierSubsetEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ClassifierSubsetEval.java (revision 29)
@@ -0,0 +1,705 @@
+/*
+ * 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.
+ */
+
+/*
+ * ClassifierSubsetEval.java
+ * Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.classifiers.Classifier;
+import weka.classifiers.AbstractClassifier;
+import weka.classifiers.Evaluation;
+import weka.classifiers.rules.ZeroR;
+import weka.core.Capabilities;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.filters.Filter;
+import weka.filters.unsupervised.attribute.Remove;
+
+import java.io.File;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Vector;
+
+
+/**
+
+ * Classifier subset evaluator:
+ *
+ * Evaluates attribute subsets on training data or a seperate hold out testing set. Uses a classifier to estimate the 'merit' of a set of attributes.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -B <classifier>
+ * class name of the classifier to use for accuracy estimation.
+ * Place any classifier options LAST on the command line
+ * following a "--". eg.:
+ * -B weka.classifiers.bayes.NaiveBayes ... -- -K
+ * (default: weka.classifiers.rules.ZeroR)
+ *
+ * -T
+ * Use the training data to estimate accuracy.
+ *
+ * -H <filename>
+ * Name of the hold out/test set to
+ * estimate accuracy on.
+ *
+ *
+ * Options specific to scheme weka.classifiers.rules.ZeroR:
+ *
+ *
+ * -D
+ * If set, classifier is run in debug mode and
+ * may output additional info to the console
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5928 $
+ */
+public class ClassifierSubsetEval
+ extends HoldOutSubsetEvaluator
+ implements OptionHandler, ErrorBasedMeritEvaluator {
+
+ /** for serialization */
+ static final long serialVersionUID = 7532217899385278710L;
+
+ /** training instances */
+ private Instances m_trainingInstances;
+
+ /** class index */
+ private int m_classIndex;
+
+ /** number of attributes in the training data */
+ private int m_numAttribs;
+
+ /** number of training instances */
+ private int m_numInstances;
+
+ /** holds the classifier to use for error estimates */
+ private Classifier m_Classifier = new ZeroR();
+
+ /** holds the evaluation object to use for evaluating the classifier */
+ private Evaluation m_Evaluation;
+
+ /** the file that containts hold out/test instances */
+ private File m_holdOutFile = new File("Click to set hold out or "
+ +"test instances");
+
+ /** the instances to test on */
+ private Instances m_holdOutInstances = null;
+
+ /** evaluate on training data rather than seperate hold out/test set */
+ private boolean m_useTraining = true;
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return
+ "Classifier subset evaluator:\n\nEvaluates attribute subsets on training data or a seperate "
+ + "hold out testing set. Uses a classifier to estimate the 'merit' of a set of attributes.";
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(3);
+
+ newVector.addElement(new Option(
+ "\tclass name of the classifier to use for accuracy estimation.\n"
+ + "\tPlace any classifier options LAST on the command line\n"
+ + "\tfollowing a \"--\". eg.:\n"
+ + "\t\t-B weka.classifiers.bayes.NaiveBayes ... -- -K\n"
+ + "\t(default: weka.classifiers.rules.ZeroR)",
+ "B", 1, "-B "));
+
+ newVector.addElement(new Option(
+ "\tUse the training data to estimate"
+ +" accuracy.",
+ "T",0,"-T"));
+
+ newVector.addElement(new Option(
+ "\tName of the hold out/test set to "
+ +"\n\testimate accuracy on.",
+ "H", 1,"-H "));
+
+ if ((m_Classifier != null) &&
+ (m_Classifier instanceof OptionHandler)) {
+ newVector.addElement(new Option("", "", 0, "\nOptions specific to "
+ + "scheme "
+ + m_Classifier.getClass().getName()
+ + ":"));
+ Enumeration enu = ((OptionHandler)m_Classifier).listOptions();
+
+ while (enu.hasMoreElements()) {
+ newVector.addElement(enu.nextElement());
+ }
+ }
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -B <classifier>
+ * class name of the classifier to use for accuracy estimation.
+ * Place any classifier options LAST on the command line
+ * following a "--". eg.:
+ * -B weka.classifiers.bayes.NaiveBayes ... -- -K
+ * (default: weka.classifiers.rules.ZeroR)
+ *
+ * -T
+ * Use the training data to estimate accuracy.
+ *
+ * -H <filename>
+ * Name of the hold out/test set to
+ * estimate accuracy on.
+ *
+ *
+ * Options specific to scheme weka.classifiers.rules.ZeroR:
+ *
+ *
+ * -D
+ * If set, classifier is run in debug mode and
+ * may output additional info to the console
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('B', options);
+ if (optionString.length() == 0)
+ optionString = ZeroR.class.getName();
+ setClassifier(AbstractClassifier.forName(optionString,
+ Utils.partitionOptions(options)));
+
+ optionString = Utils.getOption('H',options);
+ if (optionString.length() != 0) {
+ setHoldOutFile(new File(optionString));
+ }
+
+ setUseTraining(Utils.getFlag('T',options));
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String classifierTipText() {
+ return "Classifier to use for estimating the accuracy of subsets";
+ }
+
+ /**
+ * Set the classifier to use for accuracy estimation
+ *
+ * @param newClassifier the Classifier to use.
+ */
+ public void setClassifier (Classifier newClassifier) {
+ m_Classifier = newClassifier;
+ }
+
+
+ /**
+ * Get the classifier used as the base learner.
+ *
+ * @return the classifier used as the classifier
+ */
+ public Classifier getClassifier () {
+ return m_Classifier;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String holdOutFileTipText() {
+ return "File containing hold out/test instances.";
+ }
+
+ /**
+ * Gets the file that holds hold out/test instances.
+ * @return File that contains hold out instances
+ */
+ public File getHoldOutFile() {
+ return m_holdOutFile;
+ }
+
+
+ /**
+ * Set the file that contains hold out/test instances
+ * @param h the hold out file
+ */
+ public void setHoldOutFile(File h) {
+ m_holdOutFile = h;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String useTrainingTipText() {
+ return "Use training data instead of hold out/test instances.";
+ }
+
+ /**
+ * Get if training data is to be used instead of hold out/test data
+ * @return true if training data is to be used instead of hold out data
+ */
+ public boolean getUseTraining() {
+ return m_useTraining;
+ }
+
+ /**
+ * Set if training data is to be used instead of hold out/test data
+ * @param t true if training data is to be used instead of hold out data
+ */
+ public void setUseTraining(boolean t) {
+ m_useTraining = t;
+ }
+
+ /**
+ * Gets the current settings of ClassifierSubsetEval
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] classifierOptions = new String[0];
+
+ if ((m_Classifier != null) &&
+ (m_Classifier instanceof OptionHandler)) {
+ classifierOptions = ((OptionHandler)m_Classifier).getOptions();
+ }
+
+ String[] options = new String[6 + classifierOptions.length];
+ int current = 0;
+
+ if (getClassifier() != null) {
+ options[current++] = "-B";
+ options[current++] = getClassifier().getClass().getName();
+ }
+
+ if (getUseTraining()) {
+ options[current++] = "-T";
+ }
+ options[current++] = "-H"; options[current++] = getHoldOutFile().getPath();
+
+ if (classifierOptions.length > 0) {
+ options[current++] = "--";
+ System.arraycopy(classifierOptions, 0, options, current,
+ classifierOptions.length);
+ current += classifierOptions.length;
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ if (getClassifier() == null) {
+ result = super.getCapabilities();
+ result.disableAll();
+ } else {
+ result = getClassifier().getCapabilities();
+ }
+
+ // set dependencies
+ for (Capability cap: Capability.values())
+ result.enableDependency(cap);
+
+ return result;
+ }
+
+ /**
+ * Generates a attribute evaluator. Has to initialize all fields of the
+ * evaluator that are not being set via options.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ m_trainingInstances = data;
+ m_classIndex = m_trainingInstances.classIndex();
+ m_numAttribs = m_trainingInstances.numAttributes();
+ m_numInstances = m_trainingInstances.numInstances();
+
+ // load the testing data
+ if (!m_useTraining &&
+ (!getHoldOutFile().getPath().startsWith("Click to set"))) {
+ java.io.Reader r = new java.io.BufferedReader(
+ new java.io.FileReader(getHoldOutFile().getPath()));
+ m_holdOutInstances = new Instances(r);
+ m_holdOutInstances.setClassIndex(m_trainingInstances.classIndex());
+ if (m_trainingInstances.equalHeaders(m_holdOutInstances) == false) {
+ throw new Exception("Hold out/test set is not compatable with "
+ +"training data.\n"
+ + m_trainingInstances.equalHeadersMsg(m_holdOutInstances));
+ }
+ }
+ }
+
+ /**
+ * Evaluates a subset of attributes
+ *
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @return the error rate
+ * @throws Exception if the subset could not be evaluated
+ */
+ public double evaluateSubset (BitSet subset)
+ throws Exception {
+ int i,j;
+ double errorRate = 0;
+ int numAttributes = 0;
+ Instances trainCopy=null;
+ Instances testCopy=null;
+
+ Remove delTransform = new Remove();
+ delTransform.setInvertSelection(true);
+ // copy the training instances
+ trainCopy = new Instances(m_trainingInstances);
+
+ if (!m_useTraining) {
+ if (m_holdOutInstances == null) {
+ throw new Exception("Must specify a set of hold out/test instances "
+ +"with -H");
+ }
+ // copy the test instances
+ testCopy = new Instances(m_holdOutInstances);
+ }
+
+ // count attributes set in the BitSet
+ for (i = 0; i < m_numAttribs; i++) {
+ if (subset.get(i)) {
+ numAttributes++;
+ }
+ }
+
+ // set up an array of attribute indexes for the filter (+1 for the class)
+ int[] featArray = new int[numAttributes + 1];
+
+ for (i = 0, j = 0; i < m_numAttribs; i++) {
+ if (subset.get(i)) {
+ featArray[j++] = i;
+ }
+ }
+
+ featArray[j] = m_classIndex;
+ delTransform.setAttributeIndicesArray(featArray);
+ delTransform.setInputFormat(trainCopy);
+ trainCopy = Filter.useFilter(trainCopy, delTransform);
+ if (!m_useTraining) {
+ testCopy = Filter.useFilter(testCopy, delTransform);
+ }
+
+ // build the classifier
+ m_Classifier.buildClassifier(trainCopy);
+
+ m_Evaluation = new Evaluation(trainCopy);
+ if (!m_useTraining) {
+ m_Evaluation.evaluateModel(m_Classifier, testCopy);
+ } else {
+ m_Evaluation.evaluateModel(m_Classifier, trainCopy);
+ }
+
+ if (m_trainingInstances.classAttribute().isNominal()) {
+ errorRate = m_Evaluation.errorRate();
+ } else {
+ errorRate = m_Evaluation.meanAbsoluteError();
+ }
+
+ m_Evaluation = null;
+ // return the negative of the error rate as search methods need to
+ // maximize something
+ return -errorRate;
+ }
+
+ /**
+ * Evaluates a subset of attributes with respect to a set of instances.
+ * Calling this function overides any test/hold out instancs set from
+ * setHoldOutFile.
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @param holdOut a set of instances (possibly seperate and distinct
+ * from those use to build/train the evaluator) with which to
+ * evaluate the merit of the subset
+ * @return the "merit" of the subset on the holdOut data
+ * @throws Exception if the subset cannot be evaluated
+ */
+ public double evaluateSubset(BitSet subset, Instances holdOut)
+ throws Exception {
+ int i,j;
+ double errorRate;
+ int numAttributes = 0;
+ Instances trainCopy=null;
+ Instances testCopy=null;
+
+ if (m_trainingInstances.equalHeaders(holdOut) == false) {
+ throw new Exception("evaluateSubset : Incompatable instance types.\n"
+ + m_trainingInstances.equalHeadersMsg(holdOut));
+ }
+
+ Remove delTransform = new Remove();
+ delTransform.setInvertSelection(true);
+ // copy the training instances
+ trainCopy = new Instances(m_trainingInstances);
+
+ testCopy = new Instances(holdOut);
+
+ // count attributes set in the BitSet
+ for (i = 0; i < m_numAttribs; i++) {
+ if (subset.get(i)) {
+ numAttributes++;
+ }
+ }
+
+ // set up an array of attribute indexes for the filter (+1 for the class)
+ int[] featArray = new int[numAttributes + 1];
+
+ for (i = 0, j = 0; i < m_numAttribs; i++) {
+ if (subset.get(i)) {
+ featArray[j++] = i;
+ }
+ }
+
+ featArray[j] = m_classIndex;
+ delTransform.setAttributeIndicesArray(featArray);
+ delTransform.setInputFormat(trainCopy);
+ trainCopy = Filter.useFilter(trainCopy, delTransform);
+ testCopy = Filter.useFilter(testCopy, delTransform);
+
+ // build the classifier
+ m_Classifier.buildClassifier(trainCopy);
+
+ m_Evaluation = new Evaluation(trainCopy);
+ m_Evaluation.evaluateModel(m_Classifier, testCopy);
+
+ if (m_trainingInstances.classAttribute().isNominal()) {
+ errorRate = m_Evaluation.errorRate();
+ } else {
+ errorRate = m_Evaluation.meanAbsoluteError();
+ }
+
+ m_Evaluation = null;
+ // return the negative of the error as search methods need to
+ // maximize something
+ return -errorRate;
+ }
+
+ /**
+ * Evaluates a subset of attributes with respect to a single instance.
+ * Calling this function overides any hold out/test instances set
+ * through setHoldOutFile.
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @param holdOut a single instance (possibly not one of those used to
+ * build/train the evaluator) with which to evaluate the merit of the subset
+ * @param retrain true if the classifier should be retrained with respect
+ * to the new subset before testing on the holdOut instance.
+ * @return the "merit" of the subset on the holdOut instance
+ * @throws Exception if the subset cannot be evaluated
+ */
+ public double evaluateSubset(BitSet subset, Instance holdOut,
+ boolean retrain)
+ throws Exception {
+ int i,j;
+ double error;
+ int numAttributes = 0;
+ Instances trainCopy=null;
+ Instance testCopy=null;
+
+ if (m_trainingInstances.equalHeaders(holdOut.dataset()) == false) {
+ throw new Exception("evaluateSubset : Incompatable instance types.\n"
+ + m_trainingInstances.equalHeadersMsg(holdOut.dataset()));
+ }
+
+ Remove delTransform = new Remove();
+ delTransform.setInvertSelection(true);
+ // copy the training instances
+ trainCopy = new Instances(m_trainingInstances);
+
+ testCopy = (Instance)holdOut.copy();
+
+ // count attributes set in the BitSet
+ for (i = 0; i < m_numAttribs; i++) {
+ if (subset.get(i)) {
+ numAttributes++;
+ }
+ }
+
+ // set up an array of attribute indexes for the filter (+1 for the class)
+ int[] featArray = new int[numAttributes + 1];
+
+ for (i = 0, j = 0; i < m_numAttribs; i++) {
+ if (subset.get(i)) {
+ featArray[j++] = i;
+ }
+ }
+ featArray[j] = m_classIndex;
+ delTransform.setAttributeIndicesArray(featArray);
+ delTransform.setInputFormat(trainCopy);
+
+ if (retrain) {
+ trainCopy = Filter.useFilter(trainCopy, delTransform);
+ // build the classifier
+ m_Classifier.buildClassifier(trainCopy);
+ }
+
+ delTransform.input(testCopy);
+ testCopy = delTransform.output();
+
+ double pred;
+ double [] distrib;
+ distrib = m_Classifier.distributionForInstance(testCopy);
+ if (m_trainingInstances.classAttribute().isNominal()) {
+ pred = distrib[(int)testCopy.classValue()];
+ } else {
+ pred = distrib[0];
+ }
+
+ if (m_trainingInstances.classAttribute().isNominal()) {
+ error = 1.0 - pred;
+ } else {
+ error = testCopy.classValue() - pred;
+ }
+
+ // return the negative of the error as search methods need to
+ // maximize something
+ return -error;
+ }
+
+ /**
+ * Returns a string describing classifierSubsetEval
+ *
+ * @return the description as a string
+ */
+ public String toString() {
+ StringBuffer text = new StringBuffer();
+
+ if (m_trainingInstances == null) {
+ text.append("\tClassifier subset evaluator has not been built yet\n");
+ }
+ else {
+ text.append("\tClassifier Subset Evaluator\n");
+ text.append("\tLearning scheme: "
+ + getClassifier().getClass().getName() + "\n");
+ text.append("\tScheme options: ");
+ String[] classifierOptions = new String[0];
+
+ if (m_Classifier instanceof OptionHandler) {
+ classifierOptions = ((OptionHandler)m_Classifier).getOptions();
+
+ for (int i = 0; i < classifierOptions.length; i++) {
+ text.append(classifierOptions[i] + " ");
+ }
+ }
+
+ text.append("\n");
+ text.append("\tHold out/test set: ");
+ if (!m_useTraining) {
+ if (getHoldOutFile().getPath().startsWith("Click to set")) {
+ text.append("none\n");
+ } else {
+ text.append(getHoldOutFile().getPath()+'\n');
+ }
+ } else {
+ text.append("Training data\n");
+ }
+ if (m_trainingInstances.attribute(m_classIndex).isNumeric()) {
+ text.append("\tAccuracy estimation: MAE\n");
+ } else {
+ text.append("\tAccuracy estimation: classification error\n");
+ }
+ }
+ return text.toString();
+ }
+
+ /**
+ * reset to defaults
+ */
+ protected void resetOptions () {
+ m_trainingInstances = null;
+ m_Evaluation = null;
+ m_Classifier = new ZeroR();
+ m_holdOutFile = new File("Click to set hold out or test instances");
+ m_holdOutInstances = null;
+ m_useTraining = false;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5928 $");
+ }
+
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new ClassifierSubsetEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ConsistencySubsetEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ConsistencySubsetEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ConsistencySubsetEval.java (revision 29)
@@ -0,0 +1,522 @@
+/*
+ * 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.
+ */
+
+/*
+ * ConsistencySubsetEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Capabilities;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+import weka.filters.Filter;
+import weka.filters.supervised.attribute.Discretize;
+
+import java.io.Serializable;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+/**
+
+ * ConsistencySubsetEval :
+ *
+ * Evaluates the worth of a subset of attributes by the level of consistency in the class values when the training instances are projected onto the subset of attributes.
+ *
+ * Consistency of any subset can never be lower than that of the full set of attributes, hence the usual practice is to use this subset evaluator in conjunction with a Random or Exhaustive search which looks for the smallest subset with consistency equal to that of the full set of attributes.
+ *
+ * For more information see:
+ *
+ * H. Liu, R. Setiono: A probabilistic approach to feature selection - A filter solution. In: 13th International Conference on Machine Learning, 319-327, 1996.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @inproceedings{Liu1996,
+ * author = {H. Liu and R. Setiono},
+ * booktitle = {13th International Conference on Machine Learning},
+ * pages = {319-327},
+ * title = {A probabilistic approach to feature selection - A filter solution},
+ * year = {1996}
+ * }
+ *
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5447 $
+ * @see Discretize
+ */
+public class ConsistencySubsetEval
+ extends ASEvaluation
+ implements SubsetEvaluator,
+ TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -2880323763295270402L;
+
+ /** training instances */
+ private Instances m_trainInstances;
+
+ /** class index */
+ private int m_classIndex;
+
+ /** number of attributes in the training data */
+ private int m_numAttribs;
+
+ /** number of instances in the training data */
+ private int m_numInstances;
+
+ /** Discretise numeric attributes */
+ private Discretize m_disTransform;
+
+ /** Hash table for evaluating feature subsets */
+ private Hashtable m_table;
+
+ /**
+ * Class providing keys to the hash table.
+ */
+ public class hashKey
+ implements Serializable, RevisionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 6144138512017017408L;
+
+ /** Array of attribute values for an instance */
+ private double [] attributes;
+
+ /** True for an index if the corresponding attribute value is missing. */
+ private boolean [] missing;
+
+ /** The key */
+ private int key;
+
+ /**
+ * Constructor for a hashKey
+ *
+ * @param t an instance from which to generate a key
+ * @param numAtts the number of attributes
+ * @throws Exception if something goes wrong
+ */
+ public hashKey(Instance t, int numAtts) throws Exception {
+
+ int i;
+ int cindex = t.classIndex();
+
+ key = -999;
+ attributes = new double [numAtts];
+ missing = new boolean [numAtts];
+ for (i=0;i"));
+ newVector.addElement(new Option(
+ "\tName of a directory to search for cost files when loading\n"
+ +"\tcosts on demand (default current directory).",
+ "N", 1, "-N "));
+ newVector.addElement(new Option(
+ "\tThe cost matrix in Matlab single line format.",
+ "cost-matrix", 1, "-cost-matrix "));
+ newVector.addElement(new Option(
+ "\tThe seed to use for random number generation.",
+ "S", 1, "-S "));
+
+ newVector.addElement(new Option(
+ "\tFull name of base evaluator. Options after -- are "
+ +"passed to the evaluator.\n"
+ + "\t(default: " + defaultEvaluatorString() +")",
+ "W", 1, "-W"));
+
+ if (m_evaluator instanceof OptionHandler) {
+ newVector.addElement(new Option(
+ "",
+ "", 0, "\nOptions specific to evaluator "
+ + m_evaluator.getClass().getName() + ":"));
+ Enumeration enu = ((OptionHandler)m_evaluator).listOptions();
+ while (enu.hasMoreElements()) {
+ newVector.addElement(enu.nextElement());
+ }
+ }
+
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+ * Valid options are:
+ *
+ * -C <cost file name>
+ * File name of a cost matrix to use. If this is not supplied,
+ * a cost matrix will be loaded on demand. The name of the
+ * on-demand file is the relation name of the training data
+ * plus ".cost", and the path to the on-demand file is
+ * specified with the -N option.
+ *
+ * -N <directory>
+ * Name of a directory to search for cost files when loading
+ * costs on demand (default current directory).
+ *
+ * -cost-matrix <matrix>
+ * The cost matrix in Matlab single line format.
+ *
+ * -S <integer>
+ * The seed to use for random number generation.
+ *
+ * -W
+ * Full name of base evaluator.
+ * (default: weka.attributeSelection.CfsSubsetEval)
+ *
+ * Options after -- are passed to the designated evaluator.
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String[] options) throws Exception {
+ String costFile = Utils.getOption('C', options);
+ if (costFile.length() != 0) {
+ try {
+ setCostMatrix(new CostMatrix(new BufferedReader(
+ new FileReader(costFile))));
+ } catch (Exception ex) {
+ // now flag as possible old format cost matrix. Delay cost matrix
+ // loading until buildClassifer is called
+ setCostMatrix(null);
+ }
+ setCostMatrixSource(new SelectedTag(MATRIX_SUPPLIED,
+ TAGS_MATRIX_SOURCE));
+ m_CostFile = costFile;
+ } else {
+ setCostMatrixSource(new SelectedTag(MATRIX_ON_DEMAND,
+ TAGS_MATRIX_SOURCE));
+ }
+
+ String demandDir = Utils.getOption('N', options);
+ if (demandDir.length() != 0) {
+ setOnDemandDirectory(new File(demandDir));
+ }
+
+ String cost_matrix = Utils.getOption("cost-matrix", options);
+ if (cost_matrix.length() != 0) {
+ StringWriter writer = new StringWriter();
+ CostMatrix.parseMatlab(cost_matrix).write(writer);
+ setCostMatrix(new CostMatrix(new StringReader(writer.toString())));
+ setCostMatrixSource(new SelectedTag(MATRIX_SUPPLIED,
+ TAGS_MATRIX_SOURCE));
+ }
+
+ String seed = Utils.getOption('S', options);
+ if (seed.length() != 0) {
+ setSeed(Integer.parseInt(seed));
+ } else {
+ setSeed(1);
+ }
+
+ String evaluatorName = Utils.getOption('W', options);
+
+ if (evaluatorName.length() > 0) {
+
+ // This is just to set the evaluator in case the option
+ // parsing fails.
+ setEvaluator(ASEvaluation.forName(evaluatorName, null));
+ setEvaluator(ASEvaluation.forName(evaluatorName,
+ Utils.partitionOptions(options)));
+ } else {
+
+ // This is just to set the classifier in case the option
+ // parsing fails.
+ setEvaluator(ASEvaluation.forName(defaultEvaluatorString(), null));
+ setEvaluator(ASEvaluation.forName(defaultEvaluatorString(),
+ Utils.partitionOptions(options)));
+ }
+ }
+
+ /**
+ * Gets the current settings of the subset evaluator.
+ *
+ * @return an array of strings suitable for passing to setOptions
+ */
+ public String[] getOptions() {
+ ArrayList options = new ArrayList();
+
+ if (m_MatrixSource == MATRIX_SUPPLIED) {
+ if (m_CostFile != null) {
+ options.add("-C");
+ options.add("" + m_CostFile);
+ }
+ else {
+ options.add("-cost-matrix");
+ options.add(getCostMatrix().toMatlab());
+ }
+ } else {
+ options.add("-N");
+ options.add("" + getOnDemandDirectory());
+ }
+
+ options.add("-S");
+ options.add("" + getSeed());
+
+ options.add("-W");
+ options.add(m_evaluator.getClass().getName());
+
+ if (m_evaluator instanceof OptionHandler) {
+ String[] evaluatorOptions = ((OptionHandler)m_evaluator).getOptions();
+ if (evaluatorOptions.length > 0) {
+ options.add("--");
+ for (int i = 0; i < evaluatorOptions.length; i++) {
+ options.add(evaluatorOptions[i]);
+ }
+ }
+ }
+
+ return options.toArray(new String[0]);
+ }
+
+ /**
+ * @return a description of the classifier suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+
+ return "A meta subset evaluator that makes its base subset evaluator cost-sensitive. ";
+ }
+
+ /**
+ * Return the name of the default evaluator.
+ *
+ * @return the name of the default evaluator
+ */
+ public String defaultEvaluatorString() {
+ return "weka.attributeSelection.CfsSubsetEval";
+ }
+
+ /**
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String costMatrixSourceTipText() {
+
+ return "Sets where to get the cost matrix. The two options are"
+ + "to use the supplied explicit cost matrix (the setting of the "
+ + "costMatrix property), or to load a cost matrix from a file when "
+ + "required (this file will be loaded from the directory set by the "
+ + "onDemandDirectory property and will be named relation_name"
+ + CostMatrix.FILE_EXTENSION + ").";
+ }
+
+ /**
+ * Gets the source location method of the cost matrix. Will be one of
+ * MATRIX_ON_DEMAND or MATRIX_SUPPLIED.
+ *
+ * @return the cost matrix source.
+ */
+ public SelectedTag getCostMatrixSource() {
+
+ return new SelectedTag(m_MatrixSource, TAGS_MATRIX_SOURCE);
+ }
+
+ /**
+ * Sets the source location of the cost matrix. Values other than
+ * MATRIX_ON_DEMAND or MATRIX_SUPPLIED will be ignored.
+ *
+ * @param newMethod the cost matrix location method.
+ */
+ public void setCostMatrixSource(SelectedTag newMethod) {
+
+ if (newMethod.getTags() == TAGS_MATRIX_SOURCE) {
+ m_MatrixSource = newMethod.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String onDemandDirectoryTipText() {
+
+ return "Sets the directory where cost files are loaded from. This option "
+ + "is used when the costMatrixSource is set to \"On Demand\".";
+ }
+
+ /**
+ * Returns the directory that will be searched for cost files when
+ * loading on demand.
+ *
+ * @return The cost file search directory.
+ */
+ public File getOnDemandDirectory() {
+
+ return m_OnDemandDirectory;
+ }
+
+ /**
+ * Sets the directory that will be searched for cost files when
+ * loading on demand.
+ *
+ * @param newDir The cost file search directory.
+ */
+ public void setOnDemandDirectory(File newDir) {
+
+ if (newDir.isDirectory()) {
+ m_OnDemandDirectory = newDir;
+ } else {
+ m_OnDemandDirectory = new File(newDir.getParent());
+ }
+ m_MatrixSource = MATRIX_ON_DEMAND;
+ }
+
+ /**
+ * Gets the evaluator specification string, which contains the class name of
+ * the evaluator and any options to the evaluator
+ *
+ * @return the evaluator string.
+ */
+ protected String getEvaluatorSpec() {
+
+ ASEvaluation ase = getEvaluator();
+ if (ase instanceof OptionHandler) {
+ return ase.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)ase).getOptions());
+ }
+ return ase.getClass().getName();
+ }
+
+ /**
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String costMatrixTipText() {
+ return "Sets the cost matrix explicitly. This matrix is used if the "
+ + "costMatrixSource property is set to \"Supplied\".";
+ }
+
+ /**
+ * Gets the misclassification cost matrix.
+ *
+ * @return the cost matrix
+ */
+ public CostMatrix getCostMatrix() {
+
+ return m_CostMatrix;
+ }
+
+ /**
+ * Sets the misclassification cost matrix.
+ *
+ * @param newCostMatrix the cost matrix
+ */
+ public void setCostMatrix(CostMatrix newCostMatrix) {
+
+ m_CostMatrix = newCostMatrix;
+ m_MatrixSource = MATRIX_SUPPLIED;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String seedTipText() {
+ return "The random number seed to be used.";
+ }
+
+ /**
+ * Set the seed for random number generation.
+ *
+ * @param seed the seed
+ */
+ public void setSeed(int seed) {
+
+ m_seed = seed;
+ }
+
+ /**
+ * Gets the seed for the random number generations.
+ *
+ * @return the seed for the random number generation
+ */
+ public int getSeed() {
+
+ return m_seed;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String evaluatorTipText() {
+ return "The base evaluator to be used.";
+ }
+
+ /**
+ * Set the base evaluator.
+ *
+ * @param newEvaluator the evaluator to use.
+ * @throws IllegalArgumentException if the evaluator is of the wrong type
+ */
+ public void setEvaluator(ASEvaluation newEvaluator) throws IllegalArgumentException {
+
+ m_evaluator = newEvaluator;
+ }
+
+ /**
+ * Get the evaluator used as the base evaluator.
+ *
+ * @return the evaluator used as the base evaluator
+ */
+ public ASEvaluation getEvaluator() {
+
+ return m_evaluator;
+ }
+
+ /**
+ * Returns default capabilities of the classifier.
+ *
+ * @return the capabilities of this classifier
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ if (getEvaluator() != null) {
+ result = getEvaluator().getCapabilities();
+ } else {
+ result = new Capabilities(this);
+ result.disableAll();
+ }
+
+ // class
+ result.disableAllClasses();
+ result.disableAllClassDependencies();
+ result.enable(Capability.NOMINAL_CLASS);
+
+ return result;
+ }
+
+ /**
+ * Generates a attribute evaluator. Has to initialize all fields of the
+ * evaluator that are not being set via options.
+ *
+ * @param data set of instances serving as training data
+ * @exception Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator(Instances data) throws Exception {
+ // can evaluator handle the data?
+ getCapabilities().testWithFail(data);
+
+ // remove instances with missing class
+ data = new Instances(data);
+ data.deleteWithMissingClass();
+
+ if (m_evaluator == null) {
+ throw new Exception("No base evaluator has been set!");
+ }
+
+ if (m_MatrixSource == MATRIX_ON_DEMAND) {
+ String costName = data.relationName() + CostMatrix.FILE_EXTENSION;
+ File costFile = new File(getOnDemandDirectory(), costName);
+ if (!costFile.exists()) {
+ throw new Exception("On-demand cost file doesn't exist: " + costFile);
+ }
+ setCostMatrix(new CostMatrix(new BufferedReader(
+ new FileReader(costFile))));
+ } else if (m_CostMatrix == null) {
+ // try loading an old format cost file
+ m_CostMatrix = new CostMatrix(data.numClasses());
+ m_CostMatrix.readOldFormat(new BufferedReader(
+ new FileReader(m_CostFile)));
+ }
+
+ Random random = null;
+ if (!(m_evaluator instanceof WeightedInstancesHandler)) {
+ random = new Random(m_seed);
+ }
+ data = m_CostMatrix.applyCostMatrix(data, random);
+ m_evaluator.buildEvaluator(data);
+ }
+
+ /**
+ * Provides a chance for a attribute evaluator to do any special
+ * post processing of the selected attribute set.
+ *
+ * @param attributeSet the set of attributes found by the search
+ * @return a possibly ranked list of postprocessed attributes
+ * @exception Exception if postprocessing fails for some reason
+ */
+ public int [] postProcess(int [] attributeSet)
+ throws Exception {
+ return m_evaluator.postProcess(attributeSet);
+ }
+
+ /**
+ * Output a representation of this evaluator
+ *
+ * @return a string representation of the classifier
+ */
+ public String toString() {
+
+ if (m_evaluator == null) {
+ return "CostSensitiveASEvaluation: No model built yet.";
+ }
+
+ String result = (m_evaluator instanceof AttributeEvaluator)
+ ? "CostSensitiveAttributeEval using "
+ : "CostSensitiveSubsetEval using ";
+
+ result += "\n\n" + getEvaluatorSpec()
+ + "\n\nEvaluator\n"
+ + m_evaluator.toString()
+ + "\n\nCost Matrix\n"
+ + m_CostMatrix.toString();
+
+ return result;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5987 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/CostSensitiveAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/CostSensitiveAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/CostSensitiveAttributeEval.java (revision 29)
@@ -0,0 +1,164 @@
+/*
+ * 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.
+ */
+
+/*
+ * CostSensitiveAttributeEval.java
+ * Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+
+import java.util.BitSet;
+import java.io.Serializable;
+
+/**
+
+ * A meta subset evaluator that makes its base subset evaluator cost-sensitive.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -C <cost file name>
+ * File name of a cost matrix to use. If this is not supplied,
+ * a cost matrix will be loaded on demand. The name of the
+ * on-demand file is the relation name of the training data
+ * plus ".cost", and the path to the on-demand file is
+ * specified with the -N option.
+ *
+ * -N <directory>
+ * Name of a directory to search for cost files when loading
+ * costs on demand (default current directory).
+ *
+ * -cost-matrix <matrix>
+ * The cost matrix in Matlab single line format.
+ *
+ * -S <integer>
+ * The seed to use for random number generation.
+ *
+ * -W
+ * Full name of base evaluator.
+ * (default: weka.attributeSelection.ReliefFAttributeEval)
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.ReliefFAttributeEval:
+ *
+ *
+ * -M <num instances>
+ * Specify the number of instances to
+ * sample when estimating attributes.
+ * If not specified, then all instances
+ * will be used.
+ *
+ * -D <seed>
+ * Seed for randomly sampling instances.
+ * (Default = 1)
+ *
+ * -K <number of neighbours>
+ * Number of nearest neighbours (k) used
+ * to estimate attribute relevances
+ * (Default = 10).
+ *
+ * -W
+ * Weight nearest neighbours by distance
+ *
+ * -A <num>
+ * Specify sigma value (used in an exp
+ * function to control how quickly
+ * weights for more distant instances
+ * decrease. Use in conjunction with -W.
+ * Sensible value=1/5 to 1/10 of the
+ * number of nearest neighbours.
+ * (Default = 2)
+ *
+
+ *
+ * @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ * @version $Revision: 5563 $
+ */
+public class CostSensitiveAttributeEval
+ extends CostSensitiveASEvaluation
+ implements Serializable, AttributeEvaluator, OptionHandler {
+
+ /** For serialization */
+ static final long serialVersionUID = 4484876541145458447L;
+
+ /**
+ * Default constructor.
+ */
+ public CostSensitiveAttributeEval() {
+ setEvaluator(new ReliefFAttributeEval());
+ }
+
+ /**
+ * Return the name of the default evaluator.
+ *
+ * @return the name of the default evaluator
+ */
+ public String defaultEvaluatorString() {
+ return "weka.attributeSelection.ReliefFAttributeEval";
+ }
+
+ /**
+ * Set the base evaluator.
+ *
+ * @param newEvaluator the evaluator to use.
+ * @throws IllegalArgumentException if the evaluator is not an instance of AttributeEvaluator
+ */
+ public void setEvaluator(ASEvaluation newEvaluator) throws IllegalArgumentException {
+ if (!(newEvaluator instanceof AttributeEvaluator)) {
+ throw new IllegalArgumentException("Evaluator must be an AttributeEvaluator!");
+ }
+
+ m_evaluator = newEvaluator;
+ }
+
+ /**
+ * Evaluates an individual attribute. Delegates the actual evaluation to the
+ * base attribute evaluator.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the "merit" of the attribute
+ * @exception Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute(int attribute) throws Exception {
+ return ((AttributeEvaluator)m_evaluator).evaluateAttribute(attribute);
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5563 $");
+ }
+
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new CostSensitiveAttributeEval(), args);
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/CostSensitiveSubsetEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/CostSensitiveSubsetEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/CostSensitiveSubsetEval.java (revision 29)
@@ -0,0 +1,135 @@
+/*
+ * 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.
+ */
+
+/*
+ * CostSensitiveSubsetEval.java
+ * Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+
+import java.util.BitSet;
+import java.io.Serializable;
+
+/**
+
+ * A meta subset evaluator that makes its base subset evaluator cost-sensitive.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -C <cost file name>
+ * File name of a cost matrix to use. If this is not supplied,
+ * a cost matrix will be loaded on demand. The name of the
+ * on-demand file is the relation name of the training data
+ * plus ".cost", and the path to the on-demand file is
+ * specified with the -N option.
+ *
+ * -N <directory>
+ * Name of a directory to search for cost files when loading
+ * costs on demand (default current directory).
+ *
+ * -cost-matrix <matrix>
+ * The cost matrix in Matlab single line format.
+ *
+ * -S <integer>
+ * The seed to use for random number generation.
+ *
+ * -W
+ * Full name of base evaluator.
+ * (default: weka.attributeSelection.CfsSubsetEval)
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.CfsSubsetEval:
+ *
+ *
+ * -M
+ * Treat missing values as a seperate value.
+ *
+ * -L
+ * Don't include locally predictive attributes.
+ *
+
+ *
+ * @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ * @version $Revision: 5563 $
+ */
+public class CostSensitiveSubsetEval
+ extends CostSensitiveASEvaluation
+ implements Serializable, SubsetEvaluator, OptionHandler {
+
+ /** For serialization */
+ static final long serialVersionUID = 2924546096103426700L;
+
+ /**
+ * Default constructor.
+ */
+ public CostSensitiveSubsetEval() {
+ setEvaluator(new CfsSubsetEval());
+ }
+
+ /**
+ * Set the base evaluator.
+ *
+ * @param newEvaluator the evaluator to use.
+ * @throws IllegalArgumentException if the evaluator is not an instance of SubsetEvaluator
+ */
+ public void setEvaluator(ASEvaluation newEvaluator) throws IllegalArgumentException {
+ if (!(newEvaluator instanceof SubsetEvaluator)) {
+ throw new IllegalArgumentException("Evaluator must be an SubsetEvaluator!");
+ }
+
+ m_evaluator = newEvaluator;
+ }
+
+ /**
+ * Evaluates a subset of attributes. Delegates the actual evaluation to
+ * the base subset evaluator.
+ *
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @return the "merit" of the subset
+ * @exception Exception if the subset could not be evaluated
+ */
+ public double evaluateSubset(BitSet subset) throws Exception {
+ return ((SubsetEvaluator)m_evaluator).evaluateSubset(subset);
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5563 $");
+ }
+
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new CostSensitiveSubsetEval(), args);
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ErrorBasedMeritEvaluator.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ErrorBasedMeritEvaluator.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ErrorBasedMeritEvaluator.java (revision 29)
@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+/*
+ * ErrorBasedMeritEvaluator.java
+ * Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+
+/**
+ * Interface for evaluators that calculate the "merit" of attributes/subsets
+ * as the error of a learning scheme
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.6 $
+ */
+public interface ErrorBasedMeritEvaluator {
+
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ExhaustiveSearch.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ExhaustiveSearch.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ExhaustiveSearch.java (revision 29)
@@ -0,0 +1,451 @@
+/*
+ * 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.
+ */
+
+/*
+ * ExhaustiveSearch.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+
+import java.math.BigInteger;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * ExhaustiveSearch :
+ *
+ * Performs an exhaustive search through the space of attribute subsets starting from the empty set of attrubutes. Reports the best subset found.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -V
+ * Output subsets as the search progresses.
+ * (default = false).
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.15 $
+ */
+public class ExhaustiveSearch
+ extends ASSearch
+ implements OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 5741842861142379712L;
+
+ /** the best feature set found during the search */
+ private BitSet m_bestGroup;
+
+ /** the merit of the best subset found */
+ private double m_bestMerit;
+
+ /** does the data have a class */
+ private boolean m_hasClass;
+
+ /** holds the class index */
+ private int m_classIndex;
+
+ /** number of attributes in the data */
+ private int m_numAttribs;
+
+ /** if true, then ouput new best subsets as the search progresses */
+ private boolean m_verbose;
+
+ /** the number of subsets evaluated during the search */
+ private int m_evaluations;
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "ExhaustiveSearch : \n\nPerforms an exhaustive search through "
+ +"the space of attribute subsets starting from the empty set of "
+ +"attrubutes. Reports the best subset found.";
+ }
+
+ /**
+ * Constructor
+ */
+ public ExhaustiveSearch () {
+ resetOptions();
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(2);
+
+ newVector.addElement(new Option("\tOutput subsets as the search progresses."
+ +"\n\t(default = false)."
+ , "V", 0
+ , "-V"));
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -V
+ * Output subsets as the search progresses.
+ * (default = false).
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ *
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+
+ resetOptions();
+
+ setVerbose(Utils.getFlag('V',options));
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String verboseTipText() {
+ return "Print progress information. Sends progress info to the terminal "
+ +"as the search progresses.";
+ }
+
+ /**
+ * set whether or not to output new best subsets as the search proceeds
+ * @param v true if output is to be verbose
+ */
+ public void setVerbose(boolean v) {
+ m_verbose = v;
+ }
+
+ /**
+ * get whether or not output is verbose
+ * @return true if output is set to verbose
+ */
+ public boolean getVerbose() {
+ return m_verbose;
+ }
+
+ /**
+ * Gets the current settings of RandomSearch.
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[1];
+ int current = 0;
+
+ if (m_verbose) {
+ options[current++] = "-V";
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+ return options;
+ }
+
+ /**
+ * prints a description of the search
+ * @return a description of the search as a string
+ */
+ public String toString() {
+ StringBuffer text = new StringBuffer();
+
+ text.append("\tExhaustive Search.\n\tStart set: ");
+
+ text.append("no attributes\n");
+
+ text.append("\tNumber of evaluations: "+m_evaluations+"\n");
+ text.append("\tMerit of best subset found: "
+ +Utils.doubleToString(Math.abs(m_bestMerit),8,3)+"\n");
+
+ return text.toString();
+ }
+
+ /**
+ * Searches the attribute subset space using an exhaustive search.
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+ double best_merit;
+ double tempMerit;
+ boolean done = false;
+ int sizeOfBest;
+ int tempSize;
+
+ BigInteger space = BigInteger.ZERO;
+
+ m_evaluations = 0;
+ m_numAttribs = data.numAttributes();
+ m_bestGroup = new BitSet(m_numAttribs);
+
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator!");
+ }
+
+ if (ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ }
+ else {
+ m_hasClass = true;
+ m_classIndex = data.classIndex();
+ }
+
+ SubsetEvaluator ASEvaluator = (SubsetEvaluator)ASEval;
+ m_numAttribs = data.numAttributes();
+
+ best_merit = ASEvaluator.evaluateSubset(m_bestGroup);
+ m_evaluations++;
+ sizeOfBest = countFeatures(m_bestGroup);
+
+ BitSet tempGroup = new BitSet(m_numAttribs);
+ tempMerit = ASEvaluator.evaluateSubset(tempGroup);
+
+ if (m_verbose) {
+ System.out.println("Zero feature subset ("
+ +Utils.doubleToString(Math.
+ abs(tempMerit),8,5)
+ +")");
+ }
+
+ if (tempMerit >= best_merit) {
+ tempSize = countFeatures(tempGroup);
+ if (tempMerit > best_merit ||
+ (tempSize < sizeOfBest)) {
+ best_merit = tempMerit;
+ m_bestGroup = (BitSet)(tempGroup.clone());
+ sizeOfBest = tempSize;
+ }
+ }
+
+ int numatts = (m_hasClass)
+ ? m_numAttribs - 1
+ : m_numAttribs;
+ BigInteger searchSpaceEnd =
+ BigInteger.ONE.add(BigInteger.ONE).pow(numatts).subtract(BigInteger.ONE);
+
+ while (!done) {
+ // the next subset
+ space = space.add(BigInteger.ONE);
+ if (space.equals(searchSpaceEnd)) {
+ done = true;
+ }
+ tempGroup.clear();
+ for (int i = 0; i < numatts; i++) {
+ if (space.testBit(i)) {
+ if (!m_hasClass) {
+ tempGroup.set(i);
+ } else {
+ int j = (i >= m_classIndex)
+ ? i + 1
+ : i;
+ tempGroup.set(j);
+ }
+ }
+ }
+
+ tempMerit = ASEvaluator.evaluateSubset(tempGroup);
+ m_evaluations++;
+ if (tempMerit >= best_merit) {
+ tempSize = countFeatures(tempGroup);
+ if (tempMerit > best_merit ||
+ (tempSize < sizeOfBest)) {
+ best_merit = tempMerit;
+ m_bestGroup = (BitSet)(tempGroup.clone());
+ sizeOfBest = tempSize;
+ if (m_verbose) {
+ System.out.println("New best subset ("
+ +Utils.doubleToString(Math.
+ abs(best_merit),8,5)
+ +"): "+printSubset(m_bestGroup));
+ }
+ }
+ }
+ }
+
+ m_bestMerit = best_merit;
+
+ return attributeList(m_bestGroup);
+ }
+
+ /**
+ * counts the number of features in a subset
+ * @param featureSet the feature set for which to count the features
+ * @return the number of features in the subset
+ */
+ private int countFeatures(BitSet featureSet) {
+ int count = 0;
+ for (int i=0;i=0;i--) {
+ if (temp.get(i)) {
+
+ temp.clear(i);
+
+ int newP;
+ if (i != (m_numAttribs-1-counter)) {
+ newP = i+1;
+ if (newP == m_classIndex) {
+ newP++;
+ }
+
+ if (newP < m_numAttribs) {
+ temp.set(newP);
+
+ for (j=0;j
+ * Lei Yu, Huan Liu: Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution. In: Proceedings of the Twentieth International Conference on Machine Learning, 856-863, 2003.
+
+ *
+ *
+ * CONTACT INFORMATION
+ *
+ * For algorithm implementation:
+ * Zheng Zhao: zhaozheng at asu.edu
+ *
+ * For the algorithm:
+ * Lei Yu: leiyu at asu.edu
+ * Huan Liu: hliu at asu.edu
+ *
+ * Data Mining and Machine Learning Lab
+ * Computer Science and Engineering Department
+ * Fulton School of Engineering
+ * Arizona State University
+ * Tempe, AZ 85287
+ *
+ * FCBFSearch.java
+ *
+ * Copyright (C) 2004 Data Mining and Machine Learning Lab,
+ * Computer Science and Engineering Department,
+ * Fulton School of Engineering,
+ * Arizona State University
+ *
+ */
+
+
+package weka.attributeSelection;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Range;
+import weka.core.RevisionUtils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformation.Type;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * FCBF :
+ *
+ * Feature selection method based on correlation measureand relevance&redundancy analysis. Use in conjunction with an attribute set evaluator (SymmetricalUncertAttributeEval).
+ *
+ * For more information see:
+ *
+ * Lei Yu, Huan Liu: Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution. In: Proceedings of the Twentieth International Conference on Machine Learning, 856-863, 2003.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @inproceedings{Yu2003,
+ * author = {Lei Yu and Huan Liu},
+ * booktitle = {Proceedings of the Twentieth International Conference on Machine Learning},
+ * pages = {856-863},
+ * publisher = {AAAI Press},
+ * title = {Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution},
+ * year = {2003}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -D <create dataset>
+ * Specify Whether the selector generates a new dataset.
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * Any starting attributes specified are
+ * ignored during the ranking.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @author Zheng Zhao: zhaozheng at asu.edu
+ * @version $Revision: 1.7 $
+ */
+public class FCBFSearch
+ extends ASSearch
+ implements RankedOutputSearch, StartSetHandler, OptionHandler,
+ TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 8209699587428369942L;
+
+ /** Holds the starting set as an array of attributes */
+ private int[] m_starting;
+
+ /** Holds the start set for the search as a range */
+ private Range m_startRange;
+
+ /** Holds the ordered list of attributes */
+ private int[] m_attributeList;
+
+ /** Holds the list of attribute merit scores */
+ private double[] m_attributeMerit;
+
+ /** Data has class attribute---if unsupervised evaluator then no class */
+ private boolean m_hasClass;
+
+ /** Class index of the data if supervised evaluator */
+ private int m_classIndex;
+
+ /** The number of attribtes */
+ private int m_numAttribs;
+
+ /**
+ * A threshold by which to discard attributes---used by the
+ * AttributeSelection module
+ */
+ private double m_threshold;
+
+ /** The number of attributes to select. -1 indicates that all attributes
+ are to be retained. Has precedence over m_threshold */
+ private int m_numToSelect = -1;
+
+ /** Used to compute the number to select */
+ private int m_calculatedNumToSelect = -1;
+
+ /*-----------------add begin 2004-11-15 by alan-----------------*/
+ /** Used to determine whether we create a new dataset according to the selected features */
+ private boolean m_generateOutput = false;
+
+ /** Used to store the ref of the Evaluator we use*/
+ private ASEvaluation m_asEval;
+
+ /** Holds the list of attribute merit scores generated by FCBF */
+ private double[][] m_rankedFCBF;
+
+ /** Hold the list of selected features*/
+ private double[][] m_selectedFeatures;
+ /*-----------------add end 2004-11-15 by alan-----------------*/
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return
+ "FCBF : \n\nFeature selection method based on correlation measure"
+ + "and relevance&redundancy analysis. "
+ + "Use in conjunction with an attribute set evaluator (SymmetricalUncertAttributeEval).\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.INPROCEEDINGS);
+ result.setValue(Field.AUTHOR, "Lei Yu and Huan Liu");
+ result.setValue(Field.TITLE, "Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution");
+ result.setValue(Field.BOOKTITLE, "Proceedings of the Twentieth International Conference on Machine Learning");
+ result.setValue(Field.YEAR, "2003");
+ result.setValue(Field.PAGES, "856-863");
+ result.setValue(Field.PUBLISHER, "AAAI Press");
+
+ return result;
+ }
+
+ /**
+ * Constructor
+ */
+ public FCBFSearch () {
+ resetOptions();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String numToSelectTipText() {
+ return "Specify the number of attributes to retain. The default value "
+ +"(-1) indicates that all attributes are to be retained. Use either "
+ +"this option or a threshold to reduce the attribute set.";
+ }
+
+ /**
+ * Specify the number of attributes to select from the ranked list. -1
+ * indicates that all attributes are to be retained.
+ * @param n the number of attributes to retain
+ */
+ public void setNumToSelect(int n) {
+ m_numToSelect = n;
+ }
+
+ /**
+ * Gets the number of attributes to be retained.
+ * @return the number of attributes to retain
+ */
+ public int getNumToSelect() {
+ return m_numToSelect;
+ }
+
+ /**
+ * Gets the calculated number to select. This might be computed
+ * from a threshold, or if < 0 is set as the number to select then
+ * it is set to the number of attributes in the (transformed) data.
+ * @return the calculated number of attributes to select
+ */
+ public int getCalculatedNumToSelect() {
+ if (m_numToSelect >= 0) {
+ m_calculatedNumToSelect = m_numToSelect;
+ }
+ if (m_selectedFeatures.length>0
+ && m_selectedFeatures.length"));
+
+ newVector.addElement(new Option(
+ "\tSpecify a starting set of attributes.\n"
+ + "\t\tEg. 1,3,5-7.\n"
+ + "\tAny starting attributes specified are\n"
+ + "\tignored during the ranking.",
+ "P", 1 , "-P "));
+
+ newVector.addElement(new Option(
+ "\tSpecify a theshold by which attributes\n"
+ + "\tmay be discarded from the ranking.",
+ "T", 1, "-T "));
+
+ newVector.addElement(new Option(
+ "\tSpecify number of attributes to select",
+ "N", 1, "-N "));
+
+ return newVector.elements();
+
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -D <create dataset>
+ * Specify Whether the selector generates a new dataset.
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * Any starting attributes specified are
+ * ignored during the ranking.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ *
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('D', options);
+ if (optionString.length() != 0) {
+ setGenerateDataOutput(Boolean.getBoolean(optionString));
+ }
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ optionString = Utils.getOption('T', options);
+ if (optionString.length() != 0) {
+ Double temp;
+ temp = Double.valueOf(optionString);
+ setThreshold(temp.doubleValue());
+ }
+
+ optionString = Utils.getOption('N', options);
+ if (optionString.length() != 0) {
+ setNumToSelect(Integer.parseInt(optionString));
+ }
+ }
+
+ /**
+ * Gets the current settings of ReliefFAttributeEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[8];
+ int current = 0;
+
+ options[current++] = "-D";
+ options[current++] = ""+getGenerateDataOutput();
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = ""+startSetToString();
+ }
+
+ options[current++] = "-T";
+ options[current++] = "" + getThreshold();
+
+ options[current++] = "-N";
+ options[current++] = ""+getNumToSelect();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+ return options;
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is
+ * used by getOptions to return the actual attributes specified
+ * as the starting set. This is better than using m_startRanges.getRanges()
+ * as the same start set can be specified in different ways from the
+ * command line---eg 1,2,3 == 1-3. This is to ensure that stuff that
+ * is stored in a database is comparable.
+ * @return a comma seperated list of individual attribute numbers as a String
+ */
+ private String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ (m_hasClass == true && i != m_classIndex)) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ }
+ else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * Kind of a dummy search algorithm. Calls a Attribute evaluator to
+ * evaluate each attribute not included in the startSet and then sorts
+ * them to produce a ranked list of attributes.
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+ int i, j;
+
+ if (!(ASEval instanceof AttributeSetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not an "
+ + "Attribute Set evaluator!");
+ }
+
+ m_numAttribs = data.numAttributes();
+
+ if (ASEval instanceof UnsupervisedAttributeEvaluator) {
+ m_hasClass = false;
+ }
+ else {
+ m_classIndex = data.classIndex();
+ if (m_classIndex >= 0) {
+ m_hasClass = true;
+ } else {
+ m_hasClass = false;
+ }
+ }
+
+ // get the transformed data and check to see if the transformer
+ // preserves a class index
+ if (ASEval instanceof AttributeTransformer) {
+ data = ((AttributeTransformer)ASEval).transformedHeader();
+ if (m_classIndex >= 0 && data.classIndex() >= 0) {
+ m_classIndex = data.classIndex();
+ m_hasClass = true;
+ }
+ }
+
+
+ m_startRange.setUpper(m_numAttribs - 1);
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+
+ int sl=0;
+ if (m_starting != null) {
+ sl = m_starting.length;
+ }
+ if ((m_starting != null) && (m_hasClass == true)) {
+ // see if the supplied list contains the class index
+ boolean ok = false;
+ for (i = 0; i < sl; i++) {
+ if (m_starting[i] == m_classIndex) {
+ ok = true;
+ break;
+ }
+ }
+
+ if (ok == false) {
+ sl++;
+ }
+ }
+ else {
+ if (m_hasClass == true) {
+ sl++;
+ }
+ }
+
+
+ m_attributeList = new int[m_numAttribs - sl];
+ m_attributeMerit = new double[m_numAttribs - sl];
+
+ // add in those attributes not in the starting (omit list)
+ for (i = 0, j = 0; i < m_numAttribs; i++) {
+ if (!inStarting(i)) {
+ m_attributeList[j++] = i;
+ }
+ }
+
+ this.m_asEval = ASEval;
+ AttributeSetEvaluator ASEvaluator = (AttributeSetEvaluator)ASEval;
+
+ for (i = 0; i < m_attributeList.length; i++) {
+ m_attributeMerit[i] = ASEvaluator.evaluateAttribute(m_attributeList[i]);
+ }
+
+ double[][] tempRanked = rankedAttributes();
+ int[] rankedAttributes = new int[m_selectedFeatures.length];
+
+ for (i = 0; i < m_selectedFeatures.length; i++) {
+ rankedAttributes[i] = (int)tempRanked[i][0];
+ }
+ return rankedAttributes;
+ }
+
+
+
+ /**
+ * Sorts the evaluated attribute list
+ *
+ * @return an array of sorted (highest eval to lowest) attribute indexes
+ * @throws Exception of sorting can't be done.
+ */
+ public double[][] rankedAttributes ()
+ throws Exception {
+ int i, j;
+
+ if (m_attributeList == null || m_attributeMerit == null) {
+ throw new Exception("Search must be performed before a ranked "
+ + "attribute list can be obtained");
+ }
+
+ int[] ranked = Utils.sort(m_attributeMerit);
+ // reverse the order of the ranked indexes
+ double[][] bestToWorst = new double[ranked.length][2];
+
+ for (i = ranked.length - 1, j = 0; i >= 0; i--) {
+ bestToWorst[j++][0] = ranked[i];
+ //alan: means in the arrary ranked, varialbe is from ranked as from small to large
+ }
+
+ // convert the indexes to attribute indexes
+ for (i = 0; i < bestToWorst.length; i++) {
+ int temp = ((int)bestToWorst[i][0]);
+ bestToWorst[i][0] = m_attributeList[temp]; //for the index
+ bestToWorst[i][1] = m_attributeMerit[temp]; //for the value of the index
+ }
+
+ if (m_numToSelect > bestToWorst.length) {
+ throw new Exception("More attributes requested than exist in the data");
+ }
+
+ this.FCBFElimination(bestToWorst);
+
+ if (m_numToSelect <= 0) {
+ if (m_threshold == -Double.MAX_VALUE) {
+ m_calculatedNumToSelect = m_selectedFeatures.length;
+ } else {
+ determineNumToSelectFromThreshold(m_selectedFeatures);
+ }
+ }
+ /* if (m_numToSelect > 0) {
+ determineThreshFromNumToSelect(bestToWorst);
+ } */
+
+ return m_selectedFeatures;
+ }
+
+ private void determineNumToSelectFromThreshold(double [][] ranking) {
+ int count = 0;
+ for (int i = 0; i < ranking.length; i++) {
+ if (ranking[i][1] > m_threshold) {
+ count++;
+ }
+ }
+ m_calculatedNumToSelect = count;
+ }
+
+ private void determineThreshFromNumToSelect(double [][] ranking)
+ throws Exception {
+ if (m_numToSelect > ranking.length) {
+ throw new Exception("More attributes requested than exist in the data");
+ }
+
+ if (m_numToSelect == ranking.length) {
+ return;
+ }
+
+ m_threshold = (ranking[m_numToSelect-1][1] +
+ ranking[m_numToSelect][1]) / 2.0;
+ }
+
+ /**
+ * returns a description of the search as a String
+ * @return a description of the search
+ */
+ public String toString () {
+ StringBuffer BfString = new StringBuffer();
+ BfString.append("\tAttribute ranking.\n");
+
+ if (m_starting != null) {
+ BfString.append("\tIgnored attributes: ");
+
+ BfString.append(startSetToString());
+ BfString.append("\n");
+ }
+
+ if (m_threshold != -Double.MAX_VALUE) {
+ BfString.append("\tThreshold for discarding attributes: "
+ + Utils.doubleToString(m_threshold,8,4)+"\n");
+ }
+
+ BfString.append("\n\n");
+
+ BfString.append(" J || SU(j,Class) || I || SU(i,j). \n");
+
+ for (int i=0; i
+ * Class for running an arbitrary attribute evaluator on data that has been passed through an
+ * arbitrary filter (note: filters that alter the order or number of attributes are not allowed).
+ * Like the evaluator, the structure of the filter is based exclusively on the training data.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -W <evaluator specification>
+ * Full name of base evaluator to use, followed by evaluator options.
+ * eg: "weka.attributeSelection.InfoGainAttributeEval -M"
+ *
+ * -F <filter specification>
+ * Full class name of filter to use, followed
+ * by filter options.
+ * eg: "weka.filters.supervised.instance.SpreadSubsample -M 1"
+ *
+
+ *
+ * @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ * @version $Revision: 5563 $
+ */
+public class FilteredAttributeEval
+ extends ASEvaluation
+ implements Serializable, AttributeEvaluator, OptionHandler {
+
+ /** For serialization */
+ static final long serialVersionUID = 2111121880778327334L;
+
+ /** Base evaluator */
+ protected AttributeEvaluator m_evaluator = new InfoGainAttributeEval();
+
+ /** Filter */
+ protected Filter m_filter = new weka.filters.supervised.instance.SpreadSubsample();
+
+ /** Filtered instances structure */
+ protected Instances m_filteredInstances;
+
+ public FilteredAttributeEval() {
+ m_filteredInstances = null;
+ }
+
+ /**
+ * Returns default capabilities of the evaluator.
+ *
+ * @return the capabilities of this evaluator.
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ if (getFilter() == null) {
+ result = super.getCapabilities();
+ result.disableAll();
+ } else {
+ result = getFilter().getCapabilities();
+ }
+
+ // set dependencies
+ for (Capability cap: Capability.values()) {
+ result.enableDependency(cap);
+ }
+
+ return result;
+ }
+
+ /**
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Class for running an arbitrary attribute evaluator on data that has been passed "
+ + "through an arbitrary filter (note: filters that alter the order or number of "
+ + "attributes are not allowed). Like the evaluator, the structure of the filter "
+ + "is based exclusively on the training data.";
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+ Vector newVector = new Vector(2);
+
+ newVector.addElement(new Option(
+ "\tFull name of base evaluator to use, followed by "
+ +"evaluator options.\n"
+ + "\teg: \"weka.attributeSelection.InfoGainAttributeEval -M\"",
+ "W", 1, "-W "));
+
+ newVector.addElement(new Option(
+ "\tFull class name of filter to use, followed\n"
+ + "\tby filter options.\n"
+ + "\teg: \"weka.filters.supervised.instance.SpreadSubsample -M 1\"",
+ "F", 1, "-F "));
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -W <evaluator specification>
+ * Full name of base evaluator to use, followed by evaluator options.
+ * eg: "weka.attributeSelection.InfoGainAttributeEval -M"
+ *
+ * -F <filter specification>
+ * Full class name of filter to use, followed
+ * by filter options.
+ * eg: "weka.filters.supervised.instance.SpreadSubsample -M 1"
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String[] options) throws Exception {
+ String evaluator = Utils.getOption('W', options);
+
+ if (evaluator.length() > 0) {
+ String[] evaluatorSpec = Utils.splitOptions(evaluator);
+ if (evaluatorSpec.length == 0) {
+ throw new IllegalArgumentException("Invalid evaluator specification string");
+ }
+
+ String evaluatorName = evaluatorSpec[0];
+ evaluatorSpec[0] = "";
+ setAttributeEvaluator((ASEvaluation)Utils.forName(AttributeEvaluator.class,
+ evaluatorName, evaluatorSpec));
+
+ } else {
+ setAttributeEvaluator(new InfoGainAttributeEval());
+ }
+
+ // Same for filter
+ String filterString = Utils.getOption('F', options);
+ if (filterString.length() > 0) {
+ String [] filterSpec = Utils.splitOptions(filterString);
+ if (filterSpec.length == 0) {
+ throw new IllegalArgumentException("Invalid filter specification string");
+ }
+ String filterName = filterSpec[0];
+ filterSpec[0] = "";
+ setFilter((Filter) Utils.forName(Filter.class, filterName, filterSpec));
+ } else {
+ setFilter(new weka.filters.supervised.instance.SpreadSubsample());
+ }
+ }
+
+ /**
+ * Gets the current settings of the subset evaluator.
+ *
+ * @return an array of strings suitable for passing to setOptions
+ */
+ public String[] getOptions() {
+ ArrayList options = new ArrayList();
+
+ options.add("-W");
+ options.add(getEvaluatorSpec());
+
+ options.add("-F");
+ options.add(getFilterSpec());
+
+ return options.toArray(new String[0]);
+ }
+
+ /**
+ * Get the evaluator + options as a string
+ *
+ * @return a String containing the name of the evalautor + any options
+ */
+ protected String getEvaluatorSpec() {
+ AttributeEvaluator a = m_evaluator;
+ if (a instanceof OptionHandler) {
+ return a.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)a).getOptions());
+ }
+ return a.getClass().getName();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String attributeEvaluatorTipText() {
+ return "The attribute evaluator to be used.";
+ }
+
+ /**
+ * Set the attribute evaluator to use
+ *
+ * @param newEvaluator the attribute evaluator to use
+ */
+ public void setAttributeEvaluator(ASEvaluation newEvaluator) {
+ if (!(newEvaluator instanceof AttributeEvaluator)) {
+ throw new IllegalArgumentException("Evaluator must be an AttributeEvaluator!");
+ }
+ m_evaluator = (AttributeEvaluator)newEvaluator;
+ }
+
+ /**
+ * Get the attribute evaluator to use
+ *
+ * @return the attribute evaluator to use
+ */
+ public ASEvaluation getAttributeEvaluator() {
+ return (ASEvaluation)m_evaluator;
+ }
+
+ /**
+ * Get the filter + options as a string
+ *
+ * @return a String containing the name of the filter + any options
+ */
+ protected String getFilterSpec() {
+ Filter c = getFilter();
+ if (c instanceof OptionHandler) {
+ return c.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)c).getOptions());
+ }
+ return c.getClass().getName();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String filterTipText() {
+ return "The filter to be used.";
+ }
+
+ /**
+ * Set the filter to use
+ *
+ * @param newFilter the filter to use
+ */
+ public void setFilter(Filter newFilter) {
+ m_filter = newFilter;
+ }
+
+ /**
+ * Get the filter to use
+ *
+ * @return the filter to use
+ */
+ public Filter getFilter() {
+ return m_filter;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5563 $");
+ }
+
+ /**
+ * Initializes a filtered attribute evaluator.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator(Instances data) throws Exception {
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ // Structure of original
+ Instances original = new Instances(data, 0);
+
+ m_filter.setInputFormat(data);
+ data = Filter.useFilter(data, m_filter);
+
+ // Can only proceed if filter has not altered the order or
+ // number of attributes in the data
+ if (data.numAttributes() != original.numAttributes()) {
+ throw new Exception("Filter must not alter the number of "
+ +"attributes in the data!");
+ }
+
+ // Check the class index (if set)
+ if (original.classIndex() >= 0) {
+ if (data.classIndex() != original.classIndex()) {
+ throw new Exception("Filter must not change the class attribute!");
+ }
+ }
+
+ // check the order
+ for (int i = 0; i < original.numAttributes(); i++) {
+ if (!data.attribute(i).name().equals(original.attribute(i).name())) {
+ throw new Exception("Filter must not alter the order of the attributes!");
+ }
+ }
+
+ // can the evaluator handle this data?
+ ((ASEvaluation)getAttributeEvaluator()).getCapabilities().testWithFail(data);
+ m_filteredInstances = data.stringFreeStructure();
+
+ ((ASEvaluation)m_evaluator).buildEvaluator(data);
+ }
+
+ /**
+ * Evaluates an individual attribute by delegating to the base
+ * evaluator.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the merit of the attribute according to the base evaluator
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute(int attribute) throws Exception {
+ return m_evaluator.evaluateAttribute(attribute);
+ }
+
+ /**
+ * Describe the attribute evaluator
+ * @return a description of the attribute evaluator as a string
+ */
+ public String toString() {
+ StringBuffer text = new StringBuffer();
+
+ if (m_filteredInstances == null) {
+ text.append("Filtered attribute evaluator has not been built");
+ } else {
+ text.append("Filtered Attribute Evaluator");
+ text.append("\nFilter: " + getFilterSpec());
+ text.append("\nAttribute evaluator: " + getEvaluatorSpec());
+ text.append("\n\nFiltered header:\n");
+ text.append(m_filteredInstances);
+ }
+ text.append("\n");
+ return text.toString();
+ }
+
+ // ============
+ // Test method.
+ // ============
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new FilteredAttributeEval(), args);
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/FilteredSubsetEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/FilteredSubsetEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/FilteredSubsetEval.java (revision 29)
@@ -0,0 +1,397 @@
+/*
+ * 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.
+ */
+
+/*
+ * FilteredSubsetEval.java
+ * Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.filters.Filter;
+import weka.core.Instances;
+import weka.core.Capabilities;
+import weka.core.Capabilities.Capability;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+
+import java.util.Enumeration;
+import java.util.Vector;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.io.Serializable;
+
+/**
+
+ * Class for running an arbitrary subset evaluator on data that has been passed through an arbitrary
+ * filter (note: filters that alter the order or number of attributes are not allowed).
+ * Like the evaluator, the structure of the filter is based exclusively on the training data.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -W <evaluator specification>
+ * Full name of base evaluator to use, followed by evaluator options.
+ * eg: "weka.attributeSelection.CfsSubsetEval -L"
+ *
+ * -F <filter specification>
+ * Full class name of filter to use, followed
+ * by filter options.
+ * eg: "weka.filters.supervised.instance.SpreadSubsample -M 1"
+ *
+
+ *
+ * @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ * @version $Revision: 5563 $
+ */
+public class FilteredSubsetEval
+ extends ASEvaluation
+ implements Serializable, SubsetEvaluator, OptionHandler {
+
+ /** For serialization */
+ static final long serialVersionUID = 2111121880778327334L;
+
+ /** Base evaluator */
+ protected SubsetEvaluator m_evaluator = new CfsSubsetEval();
+
+ /** Filter */
+ protected Filter m_filter = new weka.filters.supervised.instance.SpreadSubsample();
+
+ /** Filtered instances structure */
+ protected Instances m_filteredInstances;
+
+ public FilteredSubsetEval() {
+ m_filteredInstances = null;
+ }
+
+ /**
+ * Returns default capabilities of the evaluator.
+ *
+ * @return the capabilities of this evaluator.
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ if (getFilter() == null) {
+ result = super.getCapabilities();
+ result.disableAll();
+ } else {
+ result = getFilter().getCapabilities();
+ }
+
+ // set dependencies
+ for (Capability cap: Capability.values()) {
+ result.enableDependency(cap);
+ }
+
+ return result;
+ }
+
+ /**
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Class for running an arbitrary subset evaluator on data that has been passed "
+ + "through an arbitrary filter (note: filters that alter the order or number of "
+ + "attributes are not allowed). Like the evaluator, the structure of the filter "
+ + "is based exclusively on the training data.";
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+ Vector newVector = new Vector(2);
+
+ newVector.addElement(new Option(
+ "\tFull name of base evaluator to use, followed by "
+ +"evaluator options.\n"
+ + "\teg: \"weka.attributeSelection.CfsSubsetEval -L\"",
+ "W", 1, "-W "));
+
+ newVector.addElement(new Option(
+ "\tFull class name of filter to use, followed\n"
+ + "\tby filter options.\n"
+ + "\teg: \"weka.filters.supervised.instance.SpreadSubsample -M 1\"",
+ "F", 1, "-F "));
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -W <evaluator specification>
+ * Full name of base evaluator to use, followed by evaluator options.
+ * eg: "weka.attributeSelection.CfsSubsetEval -L"
+ *
+ * -F <filter specification>
+ * Full class name of filter to use, followed
+ * by filter options.
+ * eg: "weka.filters.supervised.instance.SpreadSubsample -M 1"
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String[] options) throws Exception {
+ String evaluator = Utils.getOption('W', options);
+
+ if (evaluator.length() > 0) {
+ String[] evaluatorSpec = Utils.splitOptions(evaluator);
+ if (evaluatorSpec.length == 0) {
+ throw new IllegalArgumentException("Invalid evaluator specification string");
+ }
+
+ String evaluatorName = evaluatorSpec[0];
+ evaluatorSpec[0] = "";
+ setSubsetEvaluator((ASEvaluation)Utils.forName(SubsetEvaluator.class,
+ evaluatorName, evaluatorSpec));
+
+ } else {
+ setSubsetEvaluator(new CfsSubsetEval());
+ }
+
+ // Same for filter
+ String filterString = Utils.getOption('F', options);
+ if (filterString.length() > 0) {
+ String [] filterSpec = Utils.splitOptions(filterString);
+ if (filterSpec.length == 0) {
+ throw new IllegalArgumentException("Invalid filter specification string");
+ }
+ String filterName = filterSpec[0];
+ filterSpec[0] = "";
+ setFilter((Filter) Utils.forName(Filter.class, filterName, filterSpec));
+ } else {
+ setFilter(new weka.filters.supervised.instance.SpreadSubsample());
+ }
+ }
+
+ /**
+ * Gets the current settings of the subset evaluator.
+ *
+ * @return an array of strings suitable for passing to setOptions
+ */
+ public String[] getOptions() {
+ ArrayList options = new ArrayList();
+
+ options.add("-W");
+ options.add(getEvaluatorSpec());
+
+ options.add("-F");
+ options.add(getFilterSpec());
+
+ return options.toArray(new String[0]);
+ }
+
+ /**
+ * Get the evaluator + options as a string
+ *
+ * @return a String containing the name of the evalautor + any options
+ */
+ protected String getEvaluatorSpec() {
+ SubsetEvaluator a = m_evaluator;
+ if (a instanceof OptionHandler) {
+ return a.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)a).getOptions());
+ }
+ return a.getClass().getName();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String subsetEvaluatorTipText() {
+ return "The subset evaluator to be used.";
+ }
+
+ /**
+ * Set the subset evaluator to use
+ *
+ * @param newEvaluator the subset evaluator to use
+ */
+ public void setSubsetEvaluator(ASEvaluation newEvaluator) {
+ if (!(newEvaluator instanceof SubsetEvaluator)) {
+ throw new IllegalArgumentException("Evaluator must be a SubsetEvaluator!");
+ }
+ m_evaluator = (SubsetEvaluator)newEvaluator;
+ }
+
+ /**
+ * Get the subset evaluator to use
+ *
+ * @return the subset evaluator to use
+ */
+ public ASEvaluation getSubsetEvaluator() {
+ return (ASEvaluation)m_evaluator;
+ }
+
+ /**
+ * Get the filter + options as a string
+ *
+ * @return a String containing the name of the filter + any options
+ */
+ protected String getFilterSpec() {
+ Filter c = getFilter();
+ if (c instanceof OptionHandler) {
+ return c.getClass().getName() + " "
+ + Utils.joinOptions(((OptionHandler)c).getOptions());
+ }
+ return c.getClass().getName();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String filterTipText() {
+ return "The filter to be used.";
+ }
+
+ /**
+ * Set the filter to use
+ *
+ * @param newFilter the filter to use
+ */
+ public void setFilter(Filter newFilter) {
+ m_filter = newFilter;
+ }
+
+ /**
+ * Get the filter to use
+ *
+ * @return the filter to use
+ */
+ public Filter getFilter() {
+ return m_filter;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5563 $");
+ }
+
+ /**
+ * Initializes a filtered attribute evaluator.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator(Instances data) throws Exception {
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ // Structure of original
+ Instances original = new Instances(data, 0);
+
+ m_filter.setInputFormat(data);
+ data = Filter.useFilter(data, m_filter);
+
+ // Can only proceed if filter has not altered the order or
+ // number of attributes in the data
+ if (data.numAttributes() != original.numAttributes()) {
+ throw new Exception("Filter must not alter the number of "
+ +"attributes in the data!");
+ }
+
+ // Check the class index (if set)
+ if (original.classIndex() >= 0) {
+ if (data.classIndex() != original.classIndex()) {
+ throw new Exception("Filter must not change the class attribute!");
+ }
+ }
+
+ // check the order
+ for (int i = 0; i < original.numAttributes(); i++) {
+ if (!data.attribute(i).name().equals(original.attribute(i).name())) {
+ throw new Exception("Filter must not alter the order of the attributes!");
+ }
+ }
+
+ // can the evaluator handle this data?
+ ((ASEvaluation)getSubsetEvaluator()).getCapabilities().testWithFail(data);
+ m_filteredInstances = data.stringFreeStructure();
+
+ ((ASEvaluation)m_evaluator).buildEvaluator(data);
+ }
+
+ /**
+ * evaluates a subset of attributes
+ *
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @return the "merit" of the subset
+ * @exception Exception if the subset could not be evaluated
+ */
+ public double evaluateSubset(BitSet subset) throws Exception {
+ return m_evaluator.evaluateSubset(subset);
+ }
+
+ /**
+ * Describe the attribute evaluator
+ * @return a description of the attribute evaluator as a string
+ */
+ public String toString() {
+ StringBuffer text = new StringBuffer();
+
+ if (m_filteredInstances == null) {
+ text.append("Filtered attribute evaluator has not been built");
+ } else {
+ text.append("Filtered Attribute Evaluator");
+ text.append("\nFilter: " + getFilterSpec());
+ text.append("\nAttribute evaluator: " + getEvaluatorSpec());
+ text.append("\n\nFiltered header:\n");
+ text.append(m_filteredInstances);
+ }
+ text.append("\n");
+ return text.toString();
+ }
+
+ // ============
+ // Test method.
+ // ============
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new FilteredSubsetEval(), args);
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/GainRatioAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/GainRatioAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/GainRatioAttributeEval.java (revision 29)
@@ -0,0 +1,431 @@
+/*
+ * 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.
+ */
+
+/*
+ * GainRatioAttributeEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Capabilities;
+import weka.core.ContingencyTables;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.filters.Filter;
+import weka.filters.supervised.attribute.Discretize;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * GainRatioAttributeEval :
+ *
+ * Evaluates the worth of an attribute by measuring the gain ratio with respect to the class.
+ *
+ * GainR(Class, Attribute) = (H(Class) - H(Class | Attribute)) / H(Attribute).
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5447 $
+ * @see Discretize
+ */
+public class GainRatioAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -8504656625598579926L;
+
+ /** The training instances */
+ private Instances m_trainInstances;
+
+ /** The class index */
+ private int m_classIndex;
+
+ /** The number of attributes */
+ private int m_numAttribs;
+
+ /** The number of instances */
+ private int m_numInstances;
+
+ /** The number of classes */
+ private int m_numClasses;
+
+ /** Merge missing values */
+ private boolean m_missing_merge;
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "GainRatioAttributeEval :\n\nEvaluates the worth of an attribute "
+ +"by measuring the gain ratio with respect to the class.\n\n"
+ +"GainR(Class, Attribute) = (H(Class) - H(Class | Attribute)) / "
+ +"H(Attribute).\n";
+ }
+
+ /**
+ * Constructor
+ */
+ public GainRatioAttributeEval () {
+ resetOptions();
+ }
+
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(1);
+ newVector.addElement(new Option("\ttreat missing values as a seperate "
+ + "value.", "M", 0, "-M"));
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+ resetOptions();
+ setMissingMerge(!(Utils.getFlag('M', options)));
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String missingMergeTipText() {
+ return "Distribute counts for missing values. Counts are distributed "
+ +"across other values in proportion to their frequency. Otherwise, "
+ +"missing is treated as a separate value.";
+ }
+
+ /**
+ * distribute the counts for missing values across observed values
+ *
+ * @param b true=distribute missing values.
+ */
+ public void setMissingMerge (boolean b) {
+ m_missing_merge = b;
+ }
+
+
+ /**
+ * get whether missing values are being distributed or not
+ *
+ * @return true if missing values are being distributed.
+ */
+ public boolean getMissingMerge () {
+ return m_missing_merge;
+ }
+
+
+ /**
+ * Gets the current settings of WrapperSubsetEval.
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[1];
+ int current = 0;
+
+ if (!getMissingMerge()) {
+ options[current++] = "-M";
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Initializes a gain ratio attribute evaluator.
+ * Discretizes all attributes that are numeric.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ m_trainInstances = data;
+ m_classIndex = m_trainInstances.classIndex();
+ m_numAttribs = m_trainInstances.numAttributes();
+ m_numInstances = m_trainInstances.numInstances();
+ Discretize disTransform = new Discretize();
+ disTransform.setUseBetterEncoding(true);
+ disTransform.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, disTransform);
+ m_numClasses = m_trainInstances.attribute(m_classIndex).numValues();
+ }
+
+
+ /**
+ * reset options to default values
+ */
+ protected void resetOptions () {
+ m_trainInstances = null;
+ m_missing_merge = true;
+ }
+
+
+ /**
+ * evaluates an individual attribute by measuring the gain ratio
+ * of the class given the attribute.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the gain ratio
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute (int attribute)
+ throws Exception {
+ int i, j, ii, jj;
+ int ni, nj;
+ double sum = 0.0;
+ ni = m_trainInstances.attribute(attribute).numValues() + 1;
+ nj = m_numClasses + 1;
+ double[] sumi, sumj;
+ Instance inst;
+ double temp = 0.0;
+ sumi = new double[ni];
+ sumj = new double[nj];
+ double[][] counts = new double[ni][nj];
+ sumi = new double[ni];
+ sumj = new double[nj];
+
+ for (i = 0; i < ni; i++) {
+ sumi[i] = 0.0;
+
+ for (j = 0; j < nj; j++) {
+ sumj[j] = 0.0;
+ counts[i][j] = 0.0;
+ }
+ }
+
+ // Fill the contingency table
+ for (i = 0; i < m_numInstances; i++) {
+ inst = m_trainInstances.instance(i);
+
+ if (inst.isMissing(attribute)) {
+ ii = ni - 1;
+ }
+ else {
+ ii = (int)inst.value(attribute);
+ }
+
+ if (inst.isMissing(m_classIndex)) {
+ jj = nj - 1;
+ }
+ else {
+ jj = (int)inst.value(m_classIndex);
+ }
+
+ counts[ii][jj]++;
+ }
+
+ // get the row totals
+ for (i = 0; i < ni; i++) {
+ sumi[i] = 0.0;
+
+ for (j = 0; j < nj; j++) {
+ sumi[i] += counts[i][j];
+ sum += counts[i][j];
+ }
+ }
+
+ // get the column totals
+ for (j = 0; j < nj; j++) {
+ sumj[j] = 0.0;
+
+ for (i = 0; i < ni; i++) {
+ sumj[j] += counts[i][j];
+ }
+ }
+
+ // distribute missing counts
+ if (m_missing_merge &&
+ (sumi[ni-1] < m_numInstances) &&
+ (sumj[nj-1] < m_numInstances)) {
+ double[] i_copy = new double[sumi.length];
+ double[] j_copy = new double[sumj.length];
+ double[][] counts_copy = new double[sumi.length][sumj.length];
+
+ for (i = 0; i < ni; i++) {
+ System.arraycopy(counts[i], 0, counts_copy[i], 0, sumj.length);
+ }
+
+ System.arraycopy(sumi, 0, i_copy, 0, sumi.length);
+ System.arraycopy(sumj, 0, j_copy, 0, sumj.length);
+ double total_missing = (sumi[ni - 1] + sumj[nj - 1] -
+ counts[ni - 1][nj - 1]);
+
+ // do the missing i's
+ if (sumi[ni - 1] > 0.0) {
+ for (j = 0; j < nj - 1; j++) {
+ if (counts[ni - 1][j] > 0.0) {
+ for (i = 0; i < ni - 1; i++) {
+ temp = ((i_copy[i]/(sum - i_copy[ni - 1]))*counts[ni - 1][j]);
+ counts[i][j] += temp;
+ sumi[i] += temp;
+ }
+
+ counts[ni - 1][j] = 0.0;
+ }
+ }
+ }
+
+ sumi[ni - 1] = 0.0;
+
+ // do the missing j's
+ if (sumj[nj - 1] > 0.0) {
+ for (i = 0; i < ni - 1; i++) {
+ if (counts[i][nj - 1] > 0.0) {
+ for (j = 0; j < nj - 1; j++) {
+ temp = ((j_copy[j]/(sum - j_copy[nj - 1]))*counts[i][nj - 1]);
+ counts[i][j] += temp;
+ sumj[j] += temp;
+ }
+
+ counts[i][nj - 1] = 0.0;
+ }
+ }
+ }
+
+ sumj[nj - 1] = 0.0;
+
+ // do the both missing
+ if (counts[ni - 1][nj - 1] > 0.0 && total_missing != sum) {
+ for (i = 0; i < ni - 1; i++) {
+ for (j = 0; j < nj - 1; j++) {
+ temp = (counts_copy[i][j]/(sum - total_missing)) *
+ counts_copy[ni - 1][nj - 1];
+ counts[i][j] += temp;
+ sumi[i] += temp;
+ sumj[j] += temp;
+ }
+ }
+
+ counts[ni - 1][nj - 1] = 0.0;
+ }
+ }
+
+ return ContingencyTables.gainRatio(counts);
+ }
+
+
+ /**
+ * Return a description of the evaluator
+ * @return description as a string
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_trainInstances == null) {
+ text.append("\tGain Ratio evaluator has not been built");
+ }
+ else {
+ text.append("\tGain Ratio feature evaluator");
+
+ if (!m_missing_merge) {
+ text.append("\n\tMissing values treated as seperate");
+ }
+ }
+
+ text.append("\n");
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5447 $");
+ }
+
+ /**
+ * Main method.
+ *
+ * @param args the options
+ * -t training file
+ */
+ public static void main (String[] args) {
+ runEvaluator(new GainRatioAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/GeneticSearch.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/GeneticSearch.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/GeneticSearch.java (revision 29)
@@ -0,0 +1,1306 @@
+/*
+ * 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.
+ */
+
+/*
+ * GeneticSearch.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Range;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+
+import java.io.Serializable;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+
+ * GeneticSearch:
+ *
+ * Performs a search using the simple genetic algorithm described in Goldberg (1989).
+ *
+ * For more information see:
+ *
+ * David E. Goldberg (1989). Genetic algorithms in search, optimization and machine learning. Addison-Wesley.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @book{Goldberg1989,
+ * author = {David E. Goldberg},
+ * publisher = {Addison-Wesley},
+ * title = {Genetic algorithms in search, optimization and machine learning},
+ * year = {1989},
+ * ISBN = {0201157675}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.If supplied, the starting set becomes
+ * one member of the initial random
+ * population.
+ *
+ * -Z <population size>
+ * Set the size of the population (even number).
+ * (default = 20).
+ *
+ * -G <number of generations>
+ * Set the number of generations.
+ * (default = 20)
+ *
+ * -C <probability of crossover>
+ * Set the probability of crossover.
+ * (default = 0.6)
+ *
+ * -M <probability of mutation>
+ * Set the probability of mutation.
+ * (default = 0.033)
+ *
+ * -R <report frequency>
+ * Set frequency of generation reports.
+ * e.g, setting the value to 5 will
+ * report every 5th generation
+ * (default = number of generations)
+ *
+ * -S <seed>
+ * Set the random number seed.
+ * (default = 1)
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5286 $
+ */
+public class GeneticSearch
+ extends ASSearch
+ implements StartSetHandler, OptionHandler, TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -1618264232838472679L;
+
+ /**
+ * holds a starting set as an array of attributes. Becomes one member of the
+ * initial random population
+ */
+ private int[] m_starting;
+
+ /** holds the start set for the search as a Range */
+ private Range m_startRange;
+
+ /** does the data have a class */
+ private boolean m_hasClass;
+
+ /** holds the class index */
+ private int m_classIndex;
+
+ /** number of attributes in the data */
+ private int m_numAttribs;
+
+ /** the current population */
+ private GABitSet [] m_population;
+
+ /** the number of individual solutions */
+ private int m_popSize;
+
+ /** the best population member found during the search */
+ private GABitSet m_best;
+
+ /** the number of features in the best population member */
+ private int m_bestFeatureCount;
+
+ /** the number of entries to cache for lookup */
+ private int m_lookupTableSize;
+
+ /** the lookup table */
+ private Hashtable m_lookupTable;
+
+ /** random number generation */
+ private Random m_random;
+
+ /** seed for random number generation */
+ private int m_seed;
+
+ /** the probability of crossover occuring */
+ private double m_pCrossover;
+
+ /** the probability of mutation occuring */
+ private double m_pMutation;
+
+ /** sum of the current population fitness */
+ private double m_sumFitness;
+
+ private double m_maxFitness;
+ private double m_minFitness;
+ private double m_avgFitness;
+
+ /** the maximum number of generations to evaluate */
+ private int m_maxGenerations;
+
+ /** how often reports are generated */
+ private int m_reportFrequency;
+
+ /** holds the generation reports */
+ private StringBuffer m_generationReports;
+
+ // Inner class
+ /**
+ * A bitset for the genetic algorithm
+ */
+ protected class GABitSet
+ implements Cloneable, Serializable, RevisionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -2930607837482622224L;
+
+ /** the bitset */
+ private BitSet m_chromosome;
+
+ /** holds raw merit */
+ private double m_objective = -Double.MAX_VALUE;
+
+ /** the fitness */
+ private double m_fitness;
+
+ /**
+ * Constructor
+ */
+ public GABitSet () {
+ m_chromosome = new BitSet();
+ }
+
+ /**
+ * makes a copy of this GABitSet
+ * @return a copy of the object
+ * @throws CloneNotSupportedException if something goes wrong
+ */
+ public Object clone() throws CloneNotSupportedException {
+ GABitSet temp = new GABitSet();
+
+ temp.setObjective(this.getObjective());
+ temp.setFitness(this.getFitness());
+ temp.setChromosome((BitSet)(this.m_chromosome.clone()));
+ return temp;
+ //return super.clone();
+ }
+
+ /**
+ * sets the objective merit value
+ * @param objective the objective value of this population member
+ */
+ public void setObjective(double objective) {
+ m_objective = objective;
+ }
+
+ /**
+ * gets the objective merit
+ * @return the objective merit of this population member
+ */
+ public double getObjective() {
+ return m_objective;
+ }
+
+ /**
+ * sets the scaled fitness
+ * @param fitness the scaled fitness of this population member
+ */
+ public void setFitness(double fitness) {
+ m_fitness = fitness;
+ }
+
+ /**
+ * gets the scaled fitness
+ * @return the scaled fitness of this population member
+ */
+ public double getFitness() {
+ return m_fitness;
+ }
+
+ /**
+ * get the chromosome
+ * @return the chromosome of this population member
+ */
+ public BitSet getChromosome() {
+ return m_chromosome;
+ }
+
+ /**
+ * set the chromosome
+ * @param c the chromosome to be set for this population member
+ */
+ public void setChromosome(BitSet c) {
+ m_chromosome = c;
+ }
+
+ /**
+ * unset a bit in the chromosome
+ * @param bit the bit to be cleared
+ */
+ public void clear(int bit) {
+ m_chromosome.clear(bit);
+ }
+
+ /**
+ * set a bit in the chromosome
+ * @param bit the bit to be set
+ */
+ public void set(int bit) {
+ m_chromosome.set(bit);
+ }
+
+ /**
+ * get the value of a bit in the chromosome
+ * @param bit the bit to query
+ * @return the value of the bit
+ */
+ public boolean get(int bit) {
+ return m_chromosome.get(bit);
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5286 $");
+ }
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(6);
+
+ newVector.addElement(new Option("\tSpecify a starting set of attributes."
+ + "\n\tEg. 1,3,5-7."
+ +"If supplied, the starting set becomes"
+ +"\n\tone member of the initial random"
+ +"\n\tpopulation."
+ ,"P",1
+ , "-P "));
+ newVector.addElement(new Option("\tSet the size of the population (even number)."
+ +"\n\t(default = 20)."
+ , "Z", 1
+ , "-Z "));
+ newVector.addElement(new Option("\tSet the number of generations."
+ +"\n\t(default = 20)"
+ , "G", 1, "-G "));
+ newVector.addElement(new Option("\tSet the probability of crossover."
+ +"\n\t(default = 0.6)"
+ , "C", 1, "-C "));
+ newVector.addElement(new Option("\tSet the probability of mutation."
+ +"\n\t(default = 0.033)"
+ , "M", 1, "-M "));
+
+ newVector.addElement(new Option("\tSet frequency of generation reports."
+ +"\n\te.g, setting the value to 5 will "
+ +"\n\treport every 5th generation"
+ +"\n\t(default = number of generations)"
+ , "R", 1, "-R "));
+ newVector.addElement(new Option("\tSet the random number seed."
+ +"\n\t(default = 1)"
+ , "S", 1, "-S "));
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.If supplied, the starting set becomes
+ * one member of the initial random
+ * population.
+ *
+ * -Z <population size>
+ * Set the size of the population (even number).
+ * (default = 20).
+ *
+ * -G <number of generations>
+ * Set the number of generations.
+ * (default = 20)
+ *
+ * -C <probability of crossover>
+ * Set the probability of crossover.
+ * (default = 0.6)
+ *
+ * -M <probability of mutation>
+ * Set the probability of mutation.
+ * (default = 0.033)
+ *
+ * -R <report frequency>
+ * Set frequency of generation reports.
+ * e.g, setting the value to 5 will
+ * report every 5th generation
+ * (default = number of generations)
+ *
+ * -S <seed>
+ * Set the random number seed.
+ * (default = 1)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ *
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ optionString = Utils.getOption('Z', options);
+ if (optionString.length() != 0) {
+ setPopulationSize(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('G', options);
+ if (optionString.length() != 0) {
+ setMaxGenerations(Integer.parseInt(optionString));
+ setReportFrequency(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('C', options);
+ if (optionString.length() != 0) {
+ setCrossoverProb((new Double(optionString)).doubleValue());
+ }
+
+ optionString = Utils.getOption('M', options);
+ if (optionString.length() != 0) {
+ setMutationProb((new Double(optionString)).doubleValue());
+ }
+
+ optionString = Utils.getOption('R', options);
+ if (optionString.length() != 0) {
+ setReportFrequency(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('S', options);
+ if (optionString.length() != 0) {
+ setSeed(Integer.parseInt(optionString));
+ }
+ }
+
+ /**
+ * Gets the current settings of ReliefFAttributeEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[14];
+ int current = 0;
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = ""+startSetToString();
+ }
+ options[current++] = "-Z";
+ options[current++] = "" + getPopulationSize();
+ options[current++] = "-G";
+ options[current++] = "" + getMaxGenerations();
+ options[current++] = "-C";
+ options[current++] = "" + getCrossoverProb();
+ options[current++] = "-M";
+ options[current++] = "" + getMutationProb();
+ options[current++] = "-R";
+ options[current++] = "" + getReportFrequency();
+ options[current++] = "-S";
+ options[current++] = "" + getSeed();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+ return options;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String startSetTipText() {
+ return "Set a start point for the search. This is specified as a comma "
+ +"seperated list off attribute indexes starting at 1. It can include "
+ +"ranges. Eg. 1,2,5-9,17. The start set becomes one of the population "
+ +"members of the initial population.";
+ }
+
+ /**
+ * Sets a starting set of attributes for the search. It is the
+ * search method's responsibility to report this start set (if any)
+ * in its toString() method.
+ * @param startSet a string containing a list of attributes (and or ranges),
+ * eg. 1,2,6,10-15.
+ * @throws Exception if start set can't be set.
+ */
+ public void setStartSet (String startSet) throws Exception {
+ m_startRange.setRanges(startSet);
+ }
+
+ /**
+ * Returns a list of attributes (and or attribute ranges) as a String
+ * @return a list of attributes (and or attribute ranges)
+ */
+ public String getStartSet () {
+ return m_startRange.getRanges();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String seedTipText() {
+ return "Set the random seed.";
+ }
+
+ /**
+ * set the seed for random number generation
+ * @param s seed value
+ */
+ public void setSeed(int s) {
+ m_seed = s;
+ }
+
+ /**
+ * get the value of the random number generator's seed
+ * @return the seed for random number generation
+ */
+ public int getSeed() {
+ return m_seed;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String reportFrequencyTipText() {
+ return "Set how frequently reports are generated. Default is equal to "
+ +"the number of generations meaning that a report will be printed for "
+ +"initial and final generations. Setting the value to 5 will result in "
+ +"a report being printed every 5 generations.";
+ }
+
+ /**
+ * set how often reports are generated
+ * @param f generate reports every f generations
+ */
+ public void setReportFrequency(int f) {
+ m_reportFrequency = f;
+ }
+
+ /**
+ * get how often repports are generated
+ * @return how often reports are generated
+ */
+ public int getReportFrequency() {
+ return m_reportFrequency;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String mutationProbTipText() {
+ return "Set the probability of mutation occuring.";
+ }
+
+ /**
+ * set the probability of mutation
+ * @param m the probability for mutation occuring
+ */
+ public void setMutationProb(double m) {
+ m_pMutation = m;
+ }
+
+ /**
+ * get the probability of mutation
+ * @return the probability of mutation occuring
+ */
+ public double getMutationProb() {
+ return m_pMutation;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String crossoverProbTipText() {
+ return "Set the probability of crossover. This is the probability that "
+ +"two population members will exchange genetic material.";
+ }
+
+ /**
+ * set the probability of crossover
+ * @param c the probability that two population members will exchange
+ * genetic material
+ */
+ public void setCrossoverProb(double c) {
+ m_pCrossover = c;
+ }
+
+ /**
+ * get the probability of crossover
+ * @return the probability of crossover
+ */
+ public double getCrossoverProb() {
+ return m_pCrossover;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String maxGenerationsTipText() {
+ return "Set the number of generations to evaluate.";
+ }
+
+ /**
+ * set the number of generations to evaluate
+ * @param m the number of generations
+ */
+ public void setMaxGenerations(int m) {
+ m_maxGenerations = m;
+ }
+
+ /**
+ * get the number of generations
+ * @return the maximum number of generations
+ */
+ public int getMaxGenerations() {
+ return m_maxGenerations;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String populationSizeTipText() {
+ return "Set the population size (even number), this is the number of individuals "
+ +"(attribute sets) in the population.";
+ }
+
+ /**
+ * set the population size
+ * @param p the size of the population
+ */
+ public void setPopulationSize(int p) {
+ if (p % 2 == 0)
+ m_popSize = p;
+ else
+ System.err.println("Population size needs to be an even number!");
+ }
+
+ /**
+ * get the size of the population
+ * @return the population size
+ */
+ public int getPopulationSize() {
+ return m_popSize;
+ }
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return
+ "GeneticSearch:\n\nPerforms a search using the simple genetic "
+ + "algorithm described in Goldberg (1989).\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.BOOK);
+ result.setValue(Field.AUTHOR, "David E. Goldberg");
+ result.setValue(Field.YEAR, "1989");
+ result.setValue(Field.TITLE, "Genetic algorithms in search, optimization and machine learning");
+ result.setValue(Field.ISBN, "0201157675");
+ result.setValue(Field.PUBLISHER, "Addison-Wesley");
+
+ return result;
+ }
+
+ /**
+ * Constructor. Make a new GeneticSearch object
+ */
+ public GeneticSearch() {
+ resetOptions();
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is
+ * used by getOptions to return the actual attributes specified
+ * as the starting set. This is better than using m_startRanges.getRanges()
+ * as the same start set can be specified in different ways from the
+ * command line---eg 1,2,3 == 1-3. This is to ensure that stuff that
+ * is stored in a database is comparable.
+ * @return a comma seperated list of individual attribute numbers as a String
+ */
+ private String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ (m_hasClass == true && i != m_classIndex)) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ }
+ else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * returns a description of the search
+ * @return a description of the search as a String
+ */
+ public String toString() {
+ StringBuffer GAString = new StringBuffer();
+ GAString.append("\tGenetic search.\n\tStart set: ");
+
+ if (m_starting == null) {
+ GAString.append("no attributes\n");
+ }
+ else {
+ GAString.append(startSetToString()+"\n");
+ }
+ GAString.append("\tPopulation size: "+m_popSize);
+ GAString.append("\n\tNumber of generations: "+m_maxGenerations);
+ GAString.append("\n\tProbability of crossover: "
+ +Utils.doubleToString(m_pCrossover,6,3));
+ GAString.append("\n\tProbability of mutation: "
+ +Utils.doubleToString(m_pMutation,6,3));
+ GAString.append("\n\tReport frequency: "+m_reportFrequency);
+ GAString.append("\n\tRandom number seed: "+m_seed+"\n");
+ GAString.append(m_generationReports.toString());
+ return GAString.toString();
+ }
+
+ /**
+ * Searches the attribute subset space using a genetic algorithm.
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+
+ m_best = null;
+ m_generationReports = new StringBuffer();
+
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator!");
+ }
+
+ if (ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ }
+ else {
+ m_hasClass = true;
+ m_classIndex = data.classIndex();
+ }
+
+ SubsetEvaluator ASEvaluator = (SubsetEvaluator)ASEval;
+ m_numAttribs = data.numAttributes();
+
+ m_startRange.setUpper(m_numAttribs-1);
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+
+ // initial random population
+ m_lookupTable = new Hashtable(m_lookupTableSize);
+ m_random = new Random(m_seed);
+ m_population = new GABitSet [m_popSize];
+
+ // set up random initial population
+ initPopulation();
+ evaluatePopulation(ASEvaluator);
+ populationStatistics();
+ scalePopulation();
+ checkBest();
+ m_generationReports.append(populationReport(0));
+
+ boolean converged;
+ for (int i=1;i<=m_maxGenerations;i++) {
+ generation();
+ evaluatePopulation(ASEvaluator);
+ populationStatistics();
+ scalePopulation();
+ // find the best pop member and check for convergence
+ converged = checkBest();
+
+ if ((i == m_maxGenerations) ||
+ ((i % m_reportFrequency) == 0) ||
+ (converged == true)) {
+ m_generationReports.append(populationReport(i));
+ if (converged == true) {
+ break;
+ }
+ }
+ }
+ return attributeList(m_best.getChromosome());
+ }
+
+ /**
+ * converts a BitSet into a list of attribute indexes
+ * @param group the BitSet to convert
+ * @return an array of attribute indexes
+ **/
+ private int[] attributeList (BitSet group) {
+ int count = 0;
+
+ // count how many were selected
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ count++;
+ }
+ }
+
+ int[] list = new int[count];
+ count = 0;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ list[count++] = i;
+ }
+ }
+
+ return list;
+ }
+
+ /**
+ * checks to see if any population members in the current
+ * population are better than the best found so far. Also checks
+ * to see if the search has converged---that is there is no difference
+ * in fitness between the best and worse population member
+ * @return true is the search has converged
+ * @throws Exception if something goes wrong
+ */
+ private boolean checkBest() throws Exception {
+ int i,count,lowestCount = m_numAttribs;
+ double b = -Double.MAX_VALUE;
+ GABitSet localbest = null;
+ BitSet temp;
+ boolean converged = false;
+ int oldcount = Integer.MAX_VALUE;
+
+ if (m_maxFitness - m_minFitness > 0) {
+ // find the best in this population
+ for (i=0;i b) {
+ b = m_population[i].getObjective();
+ localbest = m_population[i];
+ oldcount = countFeatures(localbest.getChromosome());
+ } else if (Utils.eq(m_population[i].getObjective(), b)) {
+ // see if it contains fewer features
+ count = countFeatures(m_population[i].getChromosome());
+ if (count < oldcount) {
+ b = m_population[i].getObjective();
+ localbest = m_population[i];
+ oldcount = count;
+ }
+ }
+ }
+ } else {
+ // look for the smallest subset
+ for (i=0;i m_best.getObjective()) {
+ m_best = (GABitSet)localbest.clone();
+ m_bestFeatureCount = count;
+ } else if (Utils.eq(m_best.getObjective(), b)) {
+ // see if the localbest has fewer features than the best so far
+ if (count < m_bestFeatureCount) {
+ m_best = (GABitSet)localbest.clone();
+ m_bestFeatureCount = count;
+ }
+ }
+ return converged;
+ }
+
+ /**
+ * counts the number of features in a subset
+ * @param featureSet the feature set for which to count the features
+ * @return the number of features in the subset
+ */
+ private int countFeatures(BitSet featureSet) {
+ int count = 0;
+ for (int i=0;i best_fit) {
+ j = i;
+ best_fit = m_population[i].getFitness();
+ old_count = countFeatures(m_population[i].getChromosome());
+ } else if (Utils.eq(m_population[i].getFitness(), best_fit)) {
+ count = countFeatures(m_population[i].getChromosome());
+ if (count < old_count) {
+ j = i;
+ best_fit = m_population[i].getFitness();
+ old_count = count;
+ }
+ }
+ }
+ newPop[0] = (GABitSet)(m_population[j].clone());
+ newPop[1] = newPop[0];
+
+ for (j=2;j= 3) {
+ if (r < m_pCrossover) {
+ // cross point
+ int cp = Math.abs(m_random.nextInt());
+
+ cp %= (m_numAttribs-2);
+ cp ++;
+
+ for (i=0;i= r) {
+ break;
+ }
+ }
+
+ // if none was found, take first
+ if (i == m_popSize)
+ i = 0;
+
+ return i;
+ }
+
+ /**
+ * evaluates an entire population. Population members are looked up in
+ * a hash table and if they are not found then they are evaluated using
+ * ASEvaluator.
+ * @param ASEvaluator the subset evaluator to use for evaluating population
+ * members
+ * @throws Exception if something goes wrong during evaluation
+ */
+ private void evaluatePopulation (SubsetEvaluator ASEvaluator)
+ throws Exception {
+ int i;
+ double merit;
+
+ for (i=0;i m_numAttribs) {
+ throw new Exception("Problem in population init");
+ }
+ m_population[i].set(bit);
+ }
+ }
+ }
+
+ /**
+ * calculates summary statistics for the current population
+ */
+ private void populationStatistics() {
+ int i;
+
+ m_sumFitness = m_minFitness = m_maxFitness =
+ m_population[0].getObjective();
+
+ for (i=1;i m_maxFitness) {
+ m_maxFitness = m_population[i].getObjective();
+ }
+ else if (m_population[i].getObjective() < m_minFitness) {
+ m_minFitness = m_population[i].getObjective();
+ }
+ }
+ m_avgFitness = (m_sumFitness / m_popSize);
+ }
+
+ /**
+ * scales the raw (objective) merit of the population members
+ */
+ private void scalePopulation() {
+ int j;
+ double a = 0;
+ double b = 0;
+ double fmultiple = 2.0;
+ double delta;
+
+ // prescale
+ if (m_minFitness > ((fmultiple * m_avgFitness - m_maxFitness) /
+ (fmultiple - 1.0))) {
+ delta = m_maxFitness - m_avgFitness;
+ a = ((fmultiple - 1.0) * m_avgFitness / delta);
+ b = m_avgFitness * (m_maxFitness - fmultiple * m_avgFitness) / delta;
+ }
+ else {
+ delta = m_avgFitness - m_minFitness;
+ a = m_avgFitness / delta;
+ b = -m_minFitness * m_avgFitness / delta;
+ }
+
+ // scalepop
+ m_sumFitness = 0;
+ for (j=0;j
+ * GreedyStepwise :
+ *
+ * Performs a greedy forward or backward search through the space of attribute subsets. May start with no/all attributes or from an arbitrary point in the space. Stops when the addition/deletion of any remaining attributes results in a decrease in evaluation. Can also produce a ranked list of attributes by traversing the space from one side to the other and recording the order that attributes are selected.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -C
+ * Use conservative forward search
+ *
+ * -B
+ * Use a backward search instead of a
+ * forward one.
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ *
+ * -R
+ * Produce a ranked list of attributes.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ * Use in conjuction with -R
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @author Mark Hall
+ * @version $Revision: 1.10 $
+ */
+public class GreedyStepwise
+ extends ASSearch
+ implements RankedOutputSearch, StartSetHandler, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -6312951970168325471L;
+
+ /** does the data have a class */
+ protected boolean m_hasClass;
+
+ /** holds the class index */
+ protected int m_classIndex;
+
+ /** number of attributes in the data */
+ protected int m_numAttribs;
+
+ /** true if the user has requested a ranked list of attributes */
+ protected boolean m_rankingRequested;
+
+ /**
+ * go from one side of the search space to the other in order to generate
+ * a ranking
+ */
+ protected boolean m_doRank;
+
+ /** used to indicate whether or not ranking has been performed */
+ protected boolean m_doneRanking;
+
+ /**
+ * A threshold by which to discard attributes---used by the
+ * AttributeSelection module
+ */
+ protected double m_threshold;
+
+ /** The number of attributes to select. -1 indicates that all attributes
+ are to be retained. Has precedence over m_threshold */
+ protected int m_numToSelect = -1;
+
+ protected int m_calculatedNumToSelect;
+
+ /** the merit of the best subset found */
+ protected double m_bestMerit;
+
+ /** a ranked list of attribute indexes */
+ protected double [][] m_rankedAtts;
+ protected int m_rankedSoFar;
+
+ /** the best subset found */
+ protected BitSet m_best_group;
+ protected ASEvaluation m_ASEval;
+
+ protected Instances m_Instances;
+
+ /** holds the start set for the search as a Range */
+ protected Range m_startRange;
+
+ /** holds an array of starting attributes */
+ protected int [] m_starting;
+
+ /** Use a backwards search instead of a forwards one */
+ protected boolean m_backward = false;
+
+ /** If set then attributes will continue to be added during a forward
+ search as long as the merit does not degrade */
+ protected boolean m_conservativeSelection = false;
+
+ /**
+ * Constructor
+ */
+ public GreedyStepwise () {
+ m_threshold = -Double.MAX_VALUE;
+ m_doneRanking = false;
+ m_startRange = new Range();
+ m_starting = null;
+ resetOptions();
+ }
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "GreedyStepwise :\n\nPerforms a greedy forward or backward search "
+ +"through "
+ +"the space of attribute subsets. May start with no/all attributes or from "
+ +"an arbitrary point in the space. Stops when the addition/deletion of any "
+ +"remaining attributes results in a decrease in evaluation. "
+ +"Can also produce a ranked list of "
+ +"attributes by traversing the space from one side to the other and "
+ +"recording the order that attributes are selected.\n";
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String searchBackwardsTipText() {
+ return "Search backwards rather than forwards.";
+ }
+
+ /**
+ * Set whether to search backwards instead of forwards
+ *
+ * @param back true to search backwards
+ */
+ public void setSearchBackwards(boolean back) {
+ m_backward = back;
+ if (m_backward) {
+ setGenerateRanking(false);
+ }
+ }
+
+ /**
+ * Get whether to search backwards
+ *
+ * @return true if the search will proceed backwards
+ */
+ public boolean getSearchBackwards() {
+ return m_backward;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String thresholdTipText() {
+ return "Set threshold by which attributes can be discarded. Default value "
+ + "results in no attributes being discarded. Use in conjunction with "
+ + "generateRanking";
+ }
+
+ /**
+ * Set the threshold by which the AttributeSelection module can discard
+ * attributes.
+ * @param threshold the threshold.
+ */
+ public void setThreshold(double threshold) {
+ m_threshold = threshold;
+ }
+
+ /**
+ * Returns the threshold so that the AttributeSelection module can
+ * discard attributes from the ranking.
+ */
+ public double getThreshold() {
+ return m_threshold;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String numToSelectTipText() {
+ return "Specify the number of attributes to retain. The default value "
+ +"(-1) indicates that all attributes are to be retained. Use either "
+ +"this option or a threshold to reduce the attribute set.";
+ }
+
+ /**
+ * Specify the number of attributes to select from the ranked list
+ * (if generating a ranking). -1
+ * indicates that all attributes are to be retained.
+ * @param n the number of attributes to retain
+ */
+ public void setNumToSelect(int n) {
+ m_numToSelect = n;
+ }
+
+ /**
+ * Gets the number of attributes to be retained.
+ * @return the number of attributes to retain
+ */
+ public int getNumToSelect() {
+ return m_numToSelect;
+ }
+
+ /**
+ * Gets the calculated number of attributes to retain. This is the
+ * actual number of attributes to retain. This is the same as
+ * getNumToSelect if the user specifies a number which is not less
+ * than zero. Otherwise it should be the number of attributes in the
+ * (potentially transformed) data.
+ */
+ public int getCalculatedNumToSelect() {
+ if (m_numToSelect >= 0) {
+ m_calculatedNumToSelect = m_numToSelect;
+ }
+ return m_calculatedNumToSelect;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String generateRankingTipText() {
+ return "Set to true if a ranked list is required.";
+ }
+
+ /**
+ * Records whether the user has requested a ranked list of attributes.
+ * @param doRank true if ranking is requested
+ */
+ public void setGenerateRanking(boolean doRank) {
+ m_rankingRequested = doRank;
+ }
+
+ /**
+ * Gets whether ranking has been requested. This is used by the
+ * AttributeSelection module to determine if rankedAttributes()
+ * should be called.
+ * @return true if ranking has been requested.
+ */
+ public boolean getGenerateRanking() {
+ return m_rankingRequested;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String startSetTipText() {
+ return "Set the start point for the search. This is specified as a comma "
+ +"seperated list off attribute indexes starting at 1. It can include "
+ +"ranges. Eg. 1,2,5-9,17.";
+ }
+
+ /**
+ * Sets a starting set of attributes for the search. It is the
+ * search method's responsibility to report this start set (if any)
+ * in its toString() method.
+ * @param startSet a string containing a list of attributes (and or ranges),
+ * eg. 1,2,6,10-15.
+ * @throws Exception if start set can't be set.
+ */
+ public void setStartSet (String startSet) throws Exception {
+ m_startRange.setRanges(startSet);
+ }
+
+ /**
+ * Returns a list of attributes (and or attribute ranges) as a String
+ * @return a list of attributes (and or attribute ranges)
+ */
+ public String getStartSet () {
+ return m_startRange.getRanges();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String conservativeForwardSelectionTipText() {
+ return "If true (and forward search is selected) then attributes "
+ +"will continue to be added to the best subset as long as merit does "
+ +"not degrade.";
+ }
+
+ /**
+ * Set whether attributes should continue to be added during
+ * a forward search as long as merit does not decrease
+ * @param c true if atts should continue to be atted
+ */
+ public void setConservativeForwardSelection(boolean c) {
+ m_conservativeSelection = c;
+ }
+
+ /**
+ * Gets whether conservative selection has been enabled
+ * @return true if conservative forward selection is enabled
+ */
+ public boolean getConservativeForwardSelection() {
+ return m_conservativeSelection;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(5);
+
+ newVector.addElement(new Option("\tUse conservative forward search"
+ ,"-C", 0, "-C"));
+
+ newVector.addElement(new Option("\tUse a backward search instead of a"
+ +"\n\tforward one."
+ ,"-B", 0, "-B"));
+ newVector
+ .addElement(new Option("\tSpecify a starting set of attributes."
+ + "\n\tEg. 1,3,5-7."
+ ,"P",1
+ , "-P "));
+
+ newVector.addElement(new Option("\tProduce a ranked list of attributes."
+ ,"R",0,"-R"));
+ newVector
+ .addElement(new Option("\tSpecify a theshold by which attributes"
+ + "\n\tmay be discarded from the ranking."
+ +"\n\tUse in conjuction with -R","T",1
+ , "-T "));
+
+ newVector
+ .addElement(new Option("\tSpecify number of attributes to select"
+ ,"N",1
+ , "-N "));
+
+ return newVector.elements();
+
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -C
+ * Use conservative forward search
+ *
+ * -B
+ * Use a backward search instead of a
+ * forward one.
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ *
+ * -R
+ * Produce a ranked list of attributes.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ * Use in conjuction with -R
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ setSearchBackwards(Utils.getFlag('B', options));
+
+ setConservativeForwardSelection(Utils.getFlag('C', options));
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ setGenerateRanking(Utils.getFlag('R', options));
+
+ optionString = Utils.getOption('T', options);
+ if (optionString.length() != 0) {
+ Double temp;
+ temp = Double.valueOf(optionString);
+ setThreshold(temp.doubleValue());
+ }
+
+ optionString = Utils.getOption('N', options);
+ if (optionString.length() != 0) {
+ setNumToSelect(Integer.parseInt(optionString));
+ }
+ }
+
+ /**
+ * Gets the current settings of ReliefFAttributeEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[9];
+ int current = 0;
+
+ if (getSearchBackwards()) {
+ options[current++] = "-B";
+ }
+
+ if (getConservativeForwardSelection()) {
+ options[current++] = "-C";
+ }
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = ""+startSetToString();
+ }
+
+ if (getGenerateRanking()) {
+ options[current++] = "-R";
+ }
+ options[current++] = "-T";
+ options[current++] = "" + getThreshold();
+
+ options[current++] = "-N";
+ options[current++] = ""+getNumToSelect();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+ return options;
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is
+ * used by getOptions to return the actual attributes specified
+ * as the starting set. This is better than using m_startRanges.getRanges()
+ * as the same start set can be specified in different ways from the
+ * command line---eg 1,2,3 == 1-3. This is to ensure that stuff that
+ * is stored in a database is comparable.
+ * @return a comma seperated list of individual attribute numbers as a String
+ */
+ protected String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ (m_hasClass == true && i != m_classIndex)) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ }
+ else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * returns a description of the search.
+ * @return a description of the search as a String.
+ */
+ public String toString() {
+ StringBuffer FString = new StringBuffer();
+ FString.append("\tGreedy Stepwise ("
+ + ((m_backward)
+ ? "backwards)"
+ : "forwards)")+".\n\tStart set: ");
+
+ if (m_starting == null) {
+ if (m_backward) {
+ FString.append("all attributes\n");
+ } else {
+ FString.append("no attributes\n");
+ }
+ }
+ else {
+ FString.append(startSetToString()+"\n");
+ }
+ if (!m_doneRanking) {
+ FString.append("\tMerit of best subset found: "
+ +Utils.doubleToString(Math.abs(m_bestMerit),8,3)+"\n");
+ }
+
+ if ((m_threshold != -Double.MAX_VALUE) && (m_doneRanking)) {
+ FString.append("\tThreshold for discarding attributes: "
+ + Utils.doubleToString(m_threshold,8,4)+"\n");
+ }
+
+ return FString.toString();
+ }
+
+
+ /**
+ * Searches the attribute subset space by forward selection.
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+
+ int i;
+ double best_merit = -Double.MAX_VALUE;
+ double temp_best,temp_merit;
+ int temp_index=0;
+ BitSet temp_group;
+
+ if (data != null) { // this is a fresh run so reset
+ resetOptions();
+ m_Instances = data;
+ }
+ m_ASEval = ASEval;
+
+ m_numAttribs = m_Instances.numAttributes();
+
+ if (m_best_group == null) {
+ m_best_group = new BitSet(m_numAttribs);
+ }
+
+ if (!(m_ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(m_ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator!");
+ }
+
+ m_startRange.setUpper(m_numAttribs-1);
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+
+ if (m_ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ m_classIndex = -1;
+ }
+ else {
+ m_hasClass = true;
+ m_classIndex = m_Instances.classIndex();
+ }
+
+ SubsetEvaluator ASEvaluator = (SubsetEvaluator)m_ASEval;
+
+ if (m_rankedAtts == null) {
+ m_rankedAtts = new double[m_numAttribs][2];
+ m_rankedSoFar = 0;
+ }
+
+ // If a starting subset has been supplied, then initialise the bitset
+ if (m_starting != null && m_rankedSoFar <= 0) {
+ for (i = 0; i < m_starting.length; i++) {
+ if ((m_starting[i]) != m_classIndex) {
+ m_best_group.set(m_starting[i]);
+ }
+ }
+ } else {
+ if (m_backward && m_rankedSoFar <= 0) {
+ for (i = 0; i < m_numAttribs; i++) {
+ if (i != m_classIndex) {
+ m_best_group.set(i);
+ }
+ }
+ }
+ }
+
+ // Evaluate the initial subset
+ best_merit = ASEvaluator.evaluateSubset(m_best_group);
+
+ // main search loop
+ boolean done = false;
+ boolean addone = false;
+ boolean z;
+ while (!done) {
+ temp_group = (BitSet)m_best_group.clone();
+ temp_best = best_merit;
+ if (m_doRank) {
+ temp_best = -Double.MAX_VALUE;
+ }
+ done = true;
+ addone = false;
+ for (i=0;i= temp_best);
+ } else {
+ if (m_conservativeSelection) {
+ z = (temp_merit >= temp_best);
+ } else {
+ z = (temp_merit > temp_best);
+ }
+ }
+
+ if (z) {
+ temp_best = temp_merit;
+ temp_index = i;
+ addone = true;
+ done = false;
+ }
+
+ // unset this addition/deletion
+ if (m_backward) {
+ temp_group.set(i);
+ } else {
+ temp_group.clear(i);
+ }
+ if (m_doRank) {
+ done = false;
+ }
+ }
+ }
+ if (addone) {
+ if (m_backward) {
+ m_best_group.clear(temp_index);
+ } else {
+ m_best_group.set(temp_index);
+ }
+ best_merit = temp_best;
+ m_rankedAtts[m_rankedSoFar][0] = temp_index;
+ m_rankedAtts[m_rankedSoFar][1] = best_merit;
+ m_rankedSoFar++;
+ }
+ }
+ m_bestMerit = best_merit;
+ return attributeList(m_best_group);
+ }
+
+ /**
+ * Produces a ranked list of attributes. Search must have been performed
+ * prior to calling this function. Search is called by this function to
+ * complete the traversal of the the search space. A list of
+ * attributes and merits are returned. The attributes a ranked by the
+ * order they are added to the subset during a forward selection search.
+ * Individual merit values reflect the merit associated with adding the
+ * corresponding attribute to the subset; because of this, merit values
+ * may initially increase but then decrease as the best subset is
+ * "passed by" on the way to the far side of the search space.
+ *
+ * @return an array of attribute indexes and associated merit values
+ * @throws Exception if something goes wrong.
+ */
+ public double [][] rankedAttributes() throws Exception {
+
+ if (m_rankedAtts == null || m_rankedSoFar == -1) {
+ throw new Exception("Search must be performed before attributes "
+ +"can be ranked.");
+ }
+
+ m_doRank = true;
+ search (m_ASEval, null);
+
+ double [][] final_rank = new double [m_rankedSoFar][2];
+ for (int i=0;i final_rank.length) {
+ throw new Exception("More attributes requested than exist in the data");
+ }
+
+ if (m_numToSelect <= 0) {
+ if (m_threshold == -Double.MAX_VALUE) {
+ m_calculatedNumToSelect = final_rank.length;
+ } else {
+ determineNumToSelectFromThreshold(final_rank);
+ }
+ }
+
+ return final_rank;
+ }
+
+ private void determineNumToSelectFromThreshold(double [][] ranking) {
+ int count = 0;
+ for (int i = 0; i < ranking.length; i++) {
+ if (ranking[i][1] > m_threshold) {
+ count++;
+ }
+ }
+ m_calculatedNumToSelect = count;
+ }
+
+ /**
+ * converts a BitSet into a list of attribute indexes
+ * @param group the BitSet to convert
+ * @return an array of attribute indexes
+ **/
+ protected int[] attributeList (BitSet group) {
+ int count = 0;
+
+ // count how many were selected
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ count++;
+ }
+ }
+
+ int[] list = new int[count];
+ count = 0;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ list[count++] = i;
+ }
+ }
+
+ return list;
+ }
+
+ /**
+ * Resets options
+ */
+ protected void resetOptions() {
+ m_doRank = false;
+ m_best_group = null;
+ m_ASEval = null;
+ m_Instances = null;
+ m_rankedSoFar = -1;
+ m_rankedAtts = null;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.10 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/HoldOutSubsetEvaluator.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/HoldOutSubsetEvaluator.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/HoldOutSubsetEvaluator.java (revision 29)
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+/*
+ * HoldOutSubsetEvaluator.java
+ * Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instance;
+import weka.core.Instances;
+
+import java.util.BitSet;
+
+/**
+ * Abstract attribute subset evaluator capable of evaluating subsets with
+ * respect to a data set that is distinct from that used to initialize/
+ * train the subset evaluator.
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.7 $
+ */
+public abstract class HoldOutSubsetEvaluator
+ extends ASEvaluation
+ implements SubsetEvaluator {
+
+ /** for serialization */
+ private static final long serialVersionUID = 8280529785412054174L;
+
+ /**
+ * Evaluates a subset of attributes with respect to a set of instances.
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @param holdOut a set of instances (possibly seperate and distinct
+ * from those use to build/train the evaluator) with which to
+ * evaluate the merit of the subset
+ * @return the "merit" of the subset on the holdOut data
+ * @exception Exception if the subset cannot be evaluated
+ */
+ public abstract double evaluateSubset(BitSet subset, Instances holdOut)
+ throws Exception;
+
+ /**
+ * Evaluates a subset of attributes with respect to a single instance.
+ * @param subset a bitset representing the attribute subset to be
+ * evaluated
+ * @param holdOut a single instance (possibly not one of those used to
+ * build/train the evaluator) with which to evaluate the merit of the subset
+ * @param retrain true if the classifier should be retrained with respect
+ * to the new subset before testing on the holdOut instance.
+ * @return the "merit" of the subset on the holdOut instance
+ * @exception Exception if the subset cannot be evaluated
+ */
+ public abstract double evaluateSubset(BitSet subset,
+ Instance holdOut,
+ boolean retrain)
+ throws Exception;
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/InfoGainAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/InfoGainAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/InfoGainAttributeEval.java (revision 29)
@@ -0,0 +1,470 @@
+/*
+ * 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.
+ */
+
+/*
+ * InfoGainAttributeEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Capabilities;
+import weka.core.ContingencyTables;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.filters.Filter;
+import weka.filters.supervised.attribute.Discretize;
+import weka.filters.unsupervised.attribute.NumericToBinary;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * InfoGainAttributeEval :
+ *
+ * Evaluates the worth of an attribute by measuring the information gain with respect to the class.
+ *
+ * InfoGain(Class,Attribute) = H(Class) - H(Class | Attribute).
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+ * -B
+ * just binarize numeric attributes instead
+ * of properly discretizing them.
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5447 $
+ * @see Discretize
+ * @see NumericToBinary
+ */
+public class InfoGainAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -1949849512589218930L;
+
+ /** Treat missing values as a seperate value */
+ private boolean m_missing_merge;
+
+ /** Just binarize numeric attributes */
+ private boolean m_Binarize;
+
+ /** The info gain for each attribute */
+ private double[] m_InfoGains;
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "InfoGainAttributeEval :\n\nEvaluates the worth of an attribute "
+ +"by measuring the information gain with respect to the class.\n\n"
+ +"InfoGain(Class,Attribute) = H(Class) - H(Class | Attribute).\n";
+ }
+
+ /**
+ * Constructor
+ */
+ public InfoGainAttributeEval () {
+ resetOptions();
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(2);
+ newVector.addElement(new Option("\ttreat missing values as a seperate "
+ + "value.", "M", 0, "-M"));
+ newVector.addElement(new Option("\tjust binarize numeric attributes instead \n"
+ +"\tof properly discretizing them.", "B", 0,
+ "-B"));
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+ * -B
+ * just binarize numeric attributes instead
+ * of properly discretizing them.
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+
+ resetOptions();
+ setMissingMerge(!(Utils.getFlag('M', options)));
+ setBinarizeNumericAttributes(Utils.getFlag('B', options));
+ }
+
+
+ /**
+ * Gets the current settings of WrapperSubsetEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[2];
+ int current = 0;
+
+ if (!getMissingMerge()) {
+ options[current++] = "-M";
+ }
+ if (getBinarizeNumericAttributes()) {
+ options[current++] = "-B";
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String binarizeNumericAttributesTipText() {
+ return "Just binarize numeric attributes instead of properly discretizing them.";
+ }
+
+ /**
+ * Binarize numeric attributes.
+ *
+ * @param b true=binarize numeric attributes
+ */
+ public void setBinarizeNumericAttributes (boolean b) {
+ m_Binarize = b;
+ }
+
+
+ /**
+ * get whether numeric attributes are just being binarized.
+ *
+ * @return true if missing values are being distributed.
+ */
+ public boolean getBinarizeNumericAttributes () {
+ return m_Binarize;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String missingMergeTipText() {
+ return "Distribute counts for missing values. Counts are distributed "
+ +"across other values in proportion to their frequency. Otherwise, "
+ +"missing is treated as a separate value.";
+ }
+
+ /**
+ * distribute the counts for missing values across observed values
+ *
+ * @param b true=distribute missing values.
+ */
+ public void setMissingMerge (boolean b) {
+ m_missing_merge = b;
+ }
+
+
+ /**
+ * get whether missing values are being distributed or not
+ *
+ * @return true if missing values are being distributed.
+ */
+ public boolean getMissingMerge () {
+ return m_missing_merge;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Initializes an information gain attribute evaluator.
+ * Discretizes all attributes that are numeric.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ int classIndex = data.classIndex();
+ int numInstances = data.numInstances();
+
+ if (!m_Binarize) {
+ Discretize disTransform = new Discretize();
+ disTransform.setUseBetterEncoding(true);
+ disTransform.setInputFormat(data);
+ data = Filter.useFilter(data, disTransform);
+ } else {
+ NumericToBinary binTransform = new NumericToBinary();
+ binTransform.setInputFormat(data);
+ data = Filter.useFilter(data, binTransform);
+ }
+ int numClasses = data.attribute(classIndex).numValues();
+
+ // Reserve space and initialize counters
+ double[][][] counts = new double[data.numAttributes()][][];
+ for (int k = 0; k < data.numAttributes(); k++) {
+ if (k != classIndex) {
+ int numValues = data.attribute(k).numValues();
+ counts[k] = new double[numValues + 1][numClasses + 1];
+ }
+ }
+
+ // Initialize counters
+ double[] temp = new double[numClasses + 1];
+ for (int k = 0; k < numInstances; k++) {
+ Instance inst = data.instance(k);
+ if (inst.classIsMissing()) {
+ temp[numClasses] += inst.weight();
+ } else {
+ temp[(int)inst.classValue()] += inst.weight();
+ }
+ }
+ for (int k = 0; k < counts.length; k++) {
+ if (k != classIndex) {
+ for (int i = 0; i < temp.length; i++) {
+ counts[k][0][i] = temp[i];
+ }
+ }
+ }
+
+ // Get counts
+ for (int k = 0; k < numInstances; k++) {
+ Instance inst = data.instance(k);
+ for (int i = 0; i < inst.numValues(); i++) {
+ if (inst.index(i) != classIndex) {
+ if (inst.isMissingSparse(i) || inst.classIsMissing()) {
+ if (!inst.isMissingSparse(i)) {
+ counts[inst.index(i)][(int)inst.valueSparse(i)][numClasses] +=
+ inst.weight();
+ counts[inst.index(i)][0][numClasses] -= inst.weight();
+ } else if (!inst.classIsMissing()) {
+ counts[inst.index(i)][data.attribute(inst.index(i)).numValues()]
+ [(int)inst.classValue()] += inst.weight();
+ counts[inst.index(i)][0][(int)inst.classValue()] -=
+ inst.weight();
+ } else {
+ counts[inst.index(i)][data.attribute(inst.index(i)).numValues()]
+ [numClasses] += inst.weight();
+ counts[inst.index(i)][0][numClasses] -= inst.weight();
+ }
+ } else {
+ counts[inst.index(i)][(int)inst.valueSparse(i)]
+ [(int)inst.classValue()] += inst.weight();
+ counts[inst.index(i)][0][(int)inst.classValue()] -= inst.weight();
+ }
+ }
+ }
+ }
+
+ // distribute missing counts if required
+ if (m_missing_merge) {
+
+ for (int k = 0; k < data.numAttributes(); k++) {
+ if (k != classIndex) {
+ int numValues = data.attribute(k).numValues();
+
+ // Compute marginals
+ double[] rowSums = new double[numValues];
+ double[] columnSums = new double[numClasses];
+ double sum = 0;
+ for (int i = 0; i < numValues; i++) {
+ for (int j = 0; j < numClasses; j++) {
+ rowSums[i] += counts[k][i][j];
+ columnSums[j] += counts[k][i][j];
+ }
+ sum += rowSums[i];
+ }
+
+ if (Utils.gr(sum, 0)) {
+ double[][] additions = new double[numValues][numClasses];
+
+ // Compute what needs to be added to each row
+ for (int i = 0; i < numValues; i++) {
+ for (int j = 0; j < numClasses; j++) {
+ additions[i][j] = (rowSums[i] / sum) * counts[k][numValues][j];
+ }
+ }
+
+ // Compute what needs to be added to each column
+ for (int i = 0; i < numClasses; i++) {
+ for (int j = 0; j < numValues; j++) {
+ additions[j][i] += (columnSums[i] / sum) *
+ counts[k][j][numClasses];
+ }
+ }
+
+ // Compute what needs to be added to each cell
+ for (int i = 0; i < numClasses; i++) {
+ for (int j = 0; j < numValues; j++) {
+ additions[j][i] += (counts[k][j][i] / sum) *
+ counts[k][numValues][numClasses];
+ }
+ }
+
+ // Make new contingency table
+ double[][] newTable = new double[numValues][numClasses];
+ for (int i = 0; i < numValues; i++) {
+ for (int j = 0; j < numClasses; j++) {
+ newTable[i][j] = counts[k][i][j] + additions[i][j];
+ }
+ }
+ counts[k] = newTable;
+ }
+ }
+ }
+ }
+
+ // Compute info gains
+ m_InfoGains = new double[data.numAttributes()];
+ for (int i = 0; i < data.numAttributes(); i++) {
+ if (i != classIndex) {
+ m_InfoGains[i] =
+ (ContingencyTables.entropyOverColumns(counts[i])
+ - ContingencyTables.entropyConditionedOnRows(counts[i]));
+ }
+ }
+ }
+
+ /**
+ * Reset options to their default values
+ */
+ protected void resetOptions () {
+ m_InfoGains = null;
+ m_missing_merge = true;
+ m_Binarize = false;
+ }
+
+
+ /**
+ * evaluates an individual attribute by measuring the amount
+ * of information gained about the class given the attribute.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @return the info gain
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute (int attribute)
+ throws Exception {
+
+ return m_InfoGains[attribute];
+ }
+
+ /**
+ * Describe the attribute evaluator
+ * @return a description of the attribute evaluator as a string
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_InfoGains == null) {
+ text.append("Information Gain attribute evaluator has not been built");
+ }
+ else {
+ text.append("\tInformation Gain Ranking Filter");
+ if (!m_missing_merge) {
+ text.append("\n\tMissing values treated as seperate");
+ }
+ if (m_Binarize) {
+ text.append("\n\tNumeric attributes are just binarized");
+ }
+ }
+
+ text.append("\n");
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5447 $");
+ }
+
+ // ============
+ // Test method.
+ // ============
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new InfoGainAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/LFSMethods.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/LFSMethods.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/LFSMethods.java (revision 29)
@@ -0,0 +1,730 @@
+/*
+ * 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.
+ */
+
+/*
+ * LFSMethods.java
+ * Copyright (C) 2007 Martin Guetlein
+ *
+ */
+package weka.attributeSelection;
+
+import weka.core.FastVector;
+import weka.core.Instances;
+import weka.core.RevisionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+
+import java.io.Serializable;
+import java.util.BitSet;
+import java.util.Hashtable;
+
+/**
+ * @author Martin Guetlein (martin.guetlein@gmail.com)
+ * @version $Revision: 4899 $
+ */
+public class LFSMethods
+ implements RevisionHandler {
+
+ /** max-size of array bestGroupOfSize, should be suffient */
+ private final static int MAX_SUBSET_SIZE = 200;
+ private BitSet m_bestGroup;
+ private double m_bestMerit;
+ private int m_evalsTotal;
+ private int m_evalsCached;
+ private BitSet[] m_bestGroupOfSize = new BitSet[MAX_SUBSET_SIZE];
+
+ /**
+ * empty constructor
+ *
+ * methods are not static because of access to inner class Link2 and
+ * LinkedList2
+ *
+ */
+ public LFSMethods() {
+ }
+
+ /**
+ * @return best group found by forwardSearch/floatingForwardSearch
+ */
+ public BitSet getBestGroup() {
+ return m_bestGroup;
+ }
+
+ /**
+ * @return merit of best group found by forwardSearch/floatingForwardSearch
+ */
+ public double getBestMerit() {
+ return m_bestMerit;
+ }
+
+ /**
+ * @return best group of size found by forwardSearch
+ */
+ public BitSet getBestGroupOfSize(int size) {
+ return m_bestGroupOfSize[size];
+ }
+
+ /**
+ * @return number of cached / not performed evaluations
+ */
+ public int getNumEvalsCached() {
+ return m_evalsCached;
+ }
+
+ /**
+ * @return number totally performed evaluations
+ */
+ public int getNumEvalsTotal() {
+ return m_evalsTotal;
+ }
+
+ /**
+ * @return ranking (integer array) of attributes in data with evaluator (sorting is NOT stable!)
+ */
+ public int[] rankAttributes(Instances data, SubsetEvaluator evaluator,
+ boolean verbose) throws Exception {
+ if (verbose) {
+ System.out.println("Ranking attributes with " +
+ evaluator.getClass().getName());
+ }
+
+ double[] merit = new double[data.numAttributes()];
+ BitSet group = new BitSet(data.numAttributes());
+
+ for (int k = 0; k < data.numAttributes(); k++) {
+ if (k != data.classIndex()) {
+ group.set(k);
+ merit[k] -= evaluator.evaluateSubset(group);
+ m_evalsTotal++;
+ group.clear(k);
+ } else {
+ merit[k] = Double.MAX_VALUE;
+ }
+
+ if (verbose) {
+ System.out.println(k + ": " + merit[k]);
+ }
+ }
+
+ int[] ranking = Utils.sort(merit);
+
+ if (verbose) {
+ System.out.print("Ranking [ ");
+
+ for (int i = 0; i < ranking.length; i++) {
+ System.out.print(ranking[i] + " ");
+ }
+
+ System.out.println("]\n");
+ }
+
+ return ranking;
+ }
+
+ /**
+ * Performs linear forward selection
+ *
+ * @param cacheSize chacheSize (times number of instances) to store already evaluated sets
+ * @param startGroup start group for search (can be null)
+ * @param ranking ranking of attributes (as produced by rankAttributes), no ranking would be [0,1,2,3,4..]
+ * @param k number of top k attributes that are taken into account
+ * @param incrementK true -> fixed-set, false -> fixed-width
+ * @param maxStale number of times the search proceeds even though no improvement was found (1 = hill-climbing)
+ * @param forceResultSize stopping criteria changed from no-improvement (forceResultSize=-1) to subset-size
+ * @param data
+ * @param evaluator
+ * @param verbose
+ * @return BitSet, that cotains the best-group found
+ * @throws Exception
+ */
+ public BitSet forwardSearch(int cacheSize, BitSet startGroup, int[] ranking,
+ int k, boolean incrementK, int maxStale, int forceResultSize,
+ Instances data, SubsetEvaluator evaluator, boolean verbose)
+ throws Exception {
+ if ((forceResultSize > 0) && (maxStale > 1)) {
+ throw new Exception("Forcing result size only works for maxStale=1");
+ }
+
+ if (verbose) {
+ System.out.println("Starting forward selection");
+ }
+
+ BitSet bestGroup;
+ BitSet tempGroup;
+ int bestSize = 0;
+ int tempSize = 0;
+ double bestMerit;
+ double tempMerit = 0;
+ Link2 link;
+ LinkedList2 list = new LinkedList2(maxStale);
+ Hashtable alreadyExpanded = new Hashtable(cacheSize * data.numAttributes());
+ int insertCount = 0;
+ int stale = 0;
+ boolean improvement;
+ int thisK = k;
+ int evalsTotal = 0;
+ int evalsCached = 0;
+
+ bestGroup = (BitSet) startGroup.clone();
+
+ String hashKey = bestGroup.toString();
+ bestMerit = evaluator.evaluateSubset(bestGroup);
+
+ if (verbose) {
+ System.out.print("Group: ");
+ printGroup(bestGroup, data.numAttributes());
+ System.out.println("Merit: " + tempMerit);
+ System.out.println("----------");
+ }
+
+ alreadyExpanded.put(hashKey, new Double(bestMerit));
+ insertCount++;
+ bestSize = bestGroup.cardinality();
+
+ //the list is only used if best-first search is applied
+ if (maxStale > 1) {
+ Object[] best = new Object[1];
+ best[0] = bestGroup.clone();
+ list.addToList(best, bestMerit);
+ }
+
+ while (stale < maxStale) {
+ improvement = false;
+
+ //best-first: take first elem from list
+ if (maxStale > 1) {
+ if (list.size() == 0) {
+ stale = maxStale;
+
+ break;
+ }
+
+ link = list.getLinkAt(0);
+ tempGroup = (BitSet) (link.getData()[0]);
+ tempGroup = (BitSet) tempGroup.clone();
+ list.removeLinkAt(0);
+
+ tempSize = 0;
+
+ for (int i = 0; i < data.numAttributes(); i++) {
+ if (tempGroup.get(i)) {
+ tempSize++;
+ }
+ }
+ } else //hill-climbing
+ {
+ tempGroup = (BitSet) bestGroup.clone();
+ tempSize = bestSize;
+ }
+
+ //set number of top k attributes that are taken into account
+ if (incrementK) {
+ thisK = Math.min(Math.max(thisK, k + tempSize), data.numAttributes());
+ } else {
+ thisK = k;
+ }
+
+ //temporarilly add attributes to current set
+ for (int i = 0; i < thisK; i++) {
+ if ((ranking[i] == data.classIndex()) || tempGroup.get(ranking[i])) {
+ continue;
+ }
+
+ tempGroup.set(ranking[i]);
+ tempSize++;
+ hashKey = tempGroup.toString();
+
+ if (!alreadyExpanded.containsKey(hashKey)) {
+ evalsTotal++;
+ tempMerit = evaluator.evaluateSubset(tempGroup);
+
+ if (insertCount > (cacheSize * data.numAttributes())) {
+ alreadyExpanded = new Hashtable(cacheSize * data.numAttributes());
+ insertCount = 0;
+ }
+
+ alreadyExpanded.put(hashKey, new Double(tempMerit));
+ insertCount++;
+ } else {
+ evalsCached++;
+ tempMerit = ((Double) alreadyExpanded.get(hashKey)).doubleValue();
+ }
+
+ if (verbose) {
+ System.out.print("Group: ");
+ printGroup(tempGroup, data.numAttributes());
+ System.out.println("Merit: " + tempMerit);
+ }
+
+ if (((tempMerit - bestMerit) > 0.00001) ||
+ ((forceResultSize >= tempSize) && (tempSize > bestSize))) {
+ improvement = true;
+ stale = 0;
+ bestMerit = tempMerit;
+ bestSize = tempSize;
+ bestGroup = (BitSet) (tempGroup.clone());
+ m_bestGroupOfSize[bestSize] = (BitSet) (tempGroup.clone());
+ }
+
+ if (maxStale > 1) {
+ Object[] add = new Object[1];
+ add[0] = tempGroup.clone();
+ list.addToList(add, tempMerit);
+ }
+
+ tempGroup.clear(ranking[i]);
+ tempSize--;
+ }
+
+ if (verbose) {
+ System.out.println("----------");
+ }
+
+ //handle stopping criteria
+ if (!improvement || (forceResultSize == bestSize)) {
+ stale++;
+ }
+
+ if ((forceResultSize > 0) && (bestSize == forceResultSize)) {
+ break;
+ }
+ }
+
+ if (verbose) {
+ System.out.println("Best Group: ");
+ printGroup(bestGroup, data.numAttributes());
+ System.out.println();
+ }
+
+ m_bestGroup = bestGroup;
+ m_bestMerit = bestMerit;
+ m_evalsTotal += evalsTotal;
+ m_evalsCached += evalsCached;
+
+ return bestGroup;
+ }
+
+ /**
+ * Performs linear floating forward selection
+ * ( the stopping criteria cannot be changed to a specific size value )
+ *
+ *
+ * @param cacheSize chacheSize (times number of instances) to store already evaluated sets
+ * @param startGroup start group for search (can be null)
+ * @param ranking ranking of attributes (as produced by rankAttributes), no ranking would be [0,1,2,3,4..]
+ * @param k number of top k attributes that are taken into account
+ * @param incrementK true -> fixed-set, false -> fixed-width
+ * @param maxStale number of times the search proceeds even though no improvement was found (1 = hill-climbing)
+ * @param data
+ * @param evaluator
+ * @param verbose
+ * @return BitSet, that cotains the best-group found
+ * @throws Exception
+ */
+ public BitSet floatingForwardSearch(int cacheSize, BitSet startGroup,
+ int[] ranking, int k, boolean incrementK, int maxStale, Instances data,
+ SubsetEvaluator evaluator, boolean verbose) throws Exception {
+ if (verbose) {
+ System.out.println("Starting floating forward selection");
+ }
+
+ BitSet bestGroup;
+ BitSet tempGroup;
+ int bestSize = 0;
+ int tempSize = 0;
+ double bestMerit;
+ double tempMerit = 0;
+ Link2 link;
+ LinkedList2 list = new LinkedList2(maxStale);
+ Hashtable alreadyExpanded = new Hashtable(cacheSize * data.numAttributes());
+ int insertCount = 0;
+ int backtrackingSteps = 0;
+ boolean improvement;
+ boolean backward;
+ int thisK = k;
+ int evalsTotal = 0;
+ int evalsCached = 0;
+
+ bestGroup = (BitSet) startGroup.clone();
+
+ String hashKey = bestGroup.toString();
+ bestMerit = evaluator.evaluateSubset(bestGroup);
+
+ if (verbose) {
+ System.out.print("Group: ");
+ printGroup(bestGroup, data.numAttributes());
+ System.out.println("Merit: " + tempMerit);
+ System.out.println("----------");
+ }
+
+ alreadyExpanded.put(hashKey, new Double(bestMerit));
+ insertCount++;
+ bestSize = bestGroup.cardinality();
+
+ if (maxStale > 1) {
+ Object[] best = new Object[1];
+ best[0] = bestGroup.clone();
+ list.addToList(best, bestMerit);
+ }
+
+ backward = improvement = true;
+
+ while (true) {
+ // we are search in backward direction ->
+ // continue backward search as long as a new best set is found
+ if (backward) {
+ if (!improvement) {
+ backward = false;
+ }
+ }
+ // we are searching forward ->
+ // stop search or start backward step
+ else {
+ if (!improvement && (backtrackingSteps >= maxStale)) {
+ break;
+ }
+
+ backward = true;
+ }
+
+ improvement = false;
+
+ // best-first: take first elem from list
+ if (maxStale > 1) {
+ if (list.size() == 0) {
+ backtrackingSteps = maxStale;
+
+ break;
+ }
+
+ link = list.getLinkAt(0);
+ tempGroup = (BitSet) (link.getData()[0]);
+ tempGroup = (BitSet) tempGroup.clone();
+ list.removeLinkAt(0);
+
+ tempSize = 0;
+
+ for (int i = 0; i < data.numAttributes(); i++) {
+ if (tempGroup.get(i)) {
+ tempSize++;
+ }
+ }
+ } else //hill-climbing
+ {
+ tempGroup = (BitSet) bestGroup.clone();
+ tempSize = bestSize;
+ }
+
+ //backward search only makes sense for set-size bigger than 2
+ if (backward && (tempSize <= 2)) {
+ backward = false;
+ }
+
+ //set number of top k attributes that are taken into account
+ if (incrementK) {
+ thisK = Math.max(thisK,
+ Math.min(Math.max(thisK, k + tempSize), data.numAttributes()));
+ } else {
+ thisK = k;
+ }
+
+ //temporarilly add/remove attributes to/from current set
+ for (int i = 0; i < thisK; i++) {
+ if (ranking[i] == data.classIndex()) {
+ continue;
+ }
+
+ if (backward) {
+ if (!tempGroup.get(ranking[i])) {
+ continue;
+ }
+
+ tempGroup.clear(ranking[i]);
+ tempSize--;
+ } else {
+ if ((ranking[i] == data.classIndex()) || tempGroup.get(ranking[i])) {
+ continue;
+ }
+
+ tempGroup.set(ranking[i]);
+ tempSize++;
+ }
+
+ hashKey = tempGroup.toString();
+
+ if (!alreadyExpanded.containsKey(hashKey)) {
+ evalsTotal++;
+ tempMerit = evaluator.evaluateSubset(tempGroup);
+
+ if (insertCount > (cacheSize * data.numAttributes())) {
+ alreadyExpanded = new Hashtable(cacheSize * data.numAttributes());
+ insertCount = 0;
+ }
+
+ alreadyExpanded.put(hashKey, new Double(tempMerit));
+ insertCount++;
+ } else {
+ evalsCached++;
+ tempMerit = ((Double) alreadyExpanded.get(hashKey)).doubleValue();
+ }
+
+ if (verbose) {
+ System.out.print("Group: ");
+ printGroup(tempGroup, data.numAttributes());
+ System.out.println("Merit: " + tempMerit);
+ }
+
+ if ((tempMerit - bestMerit) > 0.00001) {
+ improvement = true;
+ backtrackingSteps = 0;
+ bestMerit = tempMerit;
+ bestSize = tempSize;
+ bestGroup = (BitSet) (tempGroup.clone());
+ }
+
+ if (maxStale > 1) {
+ Object[] add = new Object[1];
+ add[0] = tempGroup.clone();
+ list.addToList(add, tempMerit);
+ }
+
+ if (backward) {
+ tempGroup.set(ranking[i]);
+ tempSize++;
+ } else {
+ tempGroup.clear(ranking[i]);
+ tempSize--;
+ }
+ }
+
+ if (verbose) {
+ System.out.println("----------");
+ }
+
+ if ((maxStale > 1) && backward && !improvement) {
+ Object[] add = new Object[1];
+ add[0] = tempGroup.clone();
+ list.addToList(add, Double.MAX_VALUE);
+ }
+
+ if (!backward && !improvement) {
+ backtrackingSteps++;
+ }
+ }
+
+ if (verbose) {
+ System.out.println("Best Group: ");
+ printGroup(bestGroup, data.numAttributes());
+ System.out.println();
+ }
+
+ m_bestGroup = bestGroup;
+ m_bestMerit = bestMerit;
+ m_evalsTotal += evalsTotal;
+ m_evalsCached += evalsCached;
+
+ return bestGroup;
+ }
+
+ /**
+ * Debug-out
+ */
+ protected static void printGroup(BitSet tt, int numAttribs) {
+ System.out.print("{ ");
+
+ for (int i = 0; i < numAttribs; i++) {
+ if (tt.get(i) == true) {
+ System.out.print((i + 1) + " ");
+ }
+ }
+
+ System.out.println("}");
+ }
+
+ // Inner classes
+ /**
+ * Class for a node in a linked list. Used in best first search.
+ * Copied from BestFirstSearch
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ */
+ public class Link2
+ implements Serializable, RevisionHandler {
+
+ /** for serialization. */
+ private static final long serialVersionUID = -7422719407475185086L;
+
+ /* BitSet group; */
+ Object[] m_data;
+ double m_merit;
+
+ // Constructor
+ public Link2(Object[] data, double mer) {
+ // group = (BitSet)gr.clone();
+ m_data = data;
+ m_merit = mer;
+ }
+
+ /** Get a group */
+ public Object[] getData() {
+ return m_data;
+ }
+
+ public String toString() {
+ return ("Node: " + m_data.toString() + " " + m_merit);
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 4899 $");
+ }
+ }
+
+ /**
+ * Class for handling a linked list. Used in best first search. Extends the
+ * Vector class.
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ */
+ public class LinkedList2
+ extends FastVector {
+
+ /** for serialization. */
+ private static final long serialVersionUID = -7776010892419656105L;
+
+ // Max number of elements in the list
+ int m_MaxSize;
+
+ // ================
+ // Public methods
+ // ================
+ public LinkedList2(int sz) {
+ super();
+ m_MaxSize = sz;
+ }
+
+ /**
+ * removes an element (Link) at a specific index from the list.
+ *
+ * @param index
+ * the index of the element to be removed.
+ */
+ public void removeLinkAt(int index) throws Exception {
+ if ((index >= 0) && (index < size())) {
+ removeElementAt(index);
+ } else {
+ throw new Exception("index out of range (removeLinkAt)");
+ }
+ }
+
+ /**
+ * returns the element (Link) at a specific index from the list.
+ *
+ * @param index
+ * the index of the element to be returned.
+ */
+ public Link2 getLinkAt(int index) throws Exception {
+ if (size() == 0) {
+ throw new Exception("List is empty (getLinkAt)");
+ } else {
+ if ((index >= 0) && (index < size())) {
+ return ((Link2) (elementAt(index)));
+ } else {
+ throw new Exception("index out of range (getLinkAt)");
+ }
+ }
+ }
+
+ /**
+ * adds an element (Link) to the list.
+ *
+ * @param data
+ * the data to add
+ * @param mer
+ * the "merit" of this attribute set
+ */
+ public void addToList(Object[] data, double mer) throws Exception {
+ Link2 newL = new Link2(data, mer);
+
+ if (size() == 0) {
+ addElement(newL);
+ } else {
+ if (mer > ((Link2) (firstElement())).m_merit) {
+ if (size() == m_MaxSize) {
+ removeLinkAt(m_MaxSize - 1);
+ }
+
+ // ----------
+ insertElementAt(newL, 0);
+ } else {
+ int i = 0;
+ int size = size();
+ boolean done = false;
+
+ // ------------
+ // don't insert if list contains max elements an this
+ // is worst than the last
+ if ((size == m_MaxSize) &&
+ (mer <= ((Link2) (lastElement())).m_merit)) {
+ }
+ // ---------------
+ else {
+ while ((!done) && (i < size)) {
+ if (mer > ((Link2) (elementAt(i))).m_merit) {
+ if (size == m_MaxSize) {
+ removeLinkAt(m_MaxSize - 1);
+ }
+
+ // ---------------------
+ insertElementAt(newL, i);
+ done = true;
+ } else {
+ if (i == (size - 1)) {
+ addElement(newL);
+ done = true;
+ } else {
+ i++;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 4899 $");
+ }
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 4899 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/LatentSemanticAnalysis.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/LatentSemanticAnalysis.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/LatentSemanticAnalysis.java (revision 29)
@@ -0,0 +1,806 @@
+/*
+ * 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.
+ */
+
+/*
+ * LatentSemanticAnalysis.java
+ * Copyright (C) 2008 Amri Napolitano
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Attribute;
+import weka.core.Capabilities;
+import weka.core.Check;
+import weka.core.CheckOptionHandler;
+import weka.core.FastVector;
+import weka.core.Instance;
+import weka.core.DenseInstance;
+import weka.core.Instances;
+import weka.core.matrix.Matrix;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SparseInstance;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.core.matrix.SingularValueDecomposition;
+import weka.filters.Filter;
+import weka.filters.unsupervised.attribute.NominalToBinary;
+import weka.filters.unsupervised.attribute.Normalize;
+import weka.filters.unsupervised.attribute.Remove;
+import weka.filters.unsupervised.attribute.ReplaceMissingValues;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * Performs latent semantic analysis and transformation of the data.
+ * Use in conjunction with a Ranker search. A low-rank approximation
+ * of the full data is found by specifying the number of singular values
+ * to use. The dataset may be transformed to give the relation of either
+ * the attributes or the instances (default) to the concept space created
+ * by the transformation.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -N
+ * Normalize input data.
+ *
+ * -R
+ * Rank approximation used in LSA. May be actual number of
+ * LSA attributes to include (if greater than 1) or a proportion
+ * of total singular values to account for (if between 0 and 1).
+ * A value less than or equal to zero means use all latent variables.
+ * (default = 0.95)
+ *
+ * -A
+ * Maximum number of attributes to include in
+ * transformed attribute names. (-1 = include all)
+ *
+
+ *
+ * @author Amri Napolitano
+ * @version $Revision: 5987 $
+ */
+
+public class LatentSemanticAnalysis
+extends UnsupervisedAttributeEvaluator
+implements AttributeTransformer, OptionHandler {
+
+ /** For serialization */
+ static final long serialVersionUID = -8712112988018106198L;
+
+ /** The data to transform analyse/transform */
+ private Instances m_trainInstances;
+
+ /**
+ * Keep a copy for the class attribute (if set) and for
+ * checking for header compatibility
+ */
+ private Instances m_trainHeader;
+
+ /** The header for the transformed data format */
+ private Instances m_transformedFormat;
+
+ /** Data has a class set */
+ private boolean m_hasClass;
+
+ /** Class index */
+ private int m_classIndex;
+
+ /** Number of attributes */
+ private int m_numAttributes;
+
+ /** Number of instances */
+ private int m_numInstances;
+
+ /** Is transpose necessary because numAttributes < numInstances? */
+ private boolean m_transpose = false;
+
+ /** Will hold the left singular vectors */
+ private Matrix m_u = null;
+
+ /** Will hold the singular values */
+ private Matrix m_s = null;
+
+ /** Will hold the right singular values */
+ private Matrix m_v = null;
+
+ /** Will hold the matrix used to transform instances to the new feature space */
+ private Matrix m_transformationMatrix = null;
+
+ /** Filters for original data */
+ private ReplaceMissingValues m_replaceMissingFilter;
+ private Normalize m_normalizeFilter;
+ private NominalToBinary m_nominalToBinaryFilter;
+ private Remove m_attributeFilter;
+
+ /** The number of attributes in the LSA transformed data */
+ private int m_outputNumAttributes = -1;
+
+ /** Normalize the input data? */
+ private boolean m_normalize = false;
+
+ /** The approximation rank to use (between 0 and 1 means coverage proportion) */
+ private double m_rank = 0.95;
+
+ /** The sum of the squares of the singular values */
+ private double m_sumSquaredSingularValues = 0.0;
+
+ /** The actual rank number to use for computation */
+ private int m_actualRank = -1;
+
+ /** Maximum number of attributes in the transformed attribute name */
+ private int m_maxAttributesInName = 5;
+
+ /**
+ * Returns a string describing this attribute transformer
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Performs latent semantic analysis and transformation of the data. Use in " +
+ "conjunction with a Ranker search. A low-rank approximation of the full data is " +
+ "found by either specifying the number of singular values to use or specifying a " +
+ "proportion of the singular values to cover.";
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector options = new Vector(4);
+ options.addElement(new Option("\tNormalize input data.", "N", 0, "-N"));
+
+ options.addElement(new Option("\tRank approximation used in LSA. \n" +
+ "\tMay be actual number of LSA attributes \n" +
+ "\tto include (if greater than 1) or a \n" +
+ "\tproportion of total singular values to \n" +
+ "\taccount for (if between 0 and 1). \n" +
+ "\tA value less than or equal to zero means \n" +
+ "\tuse all latent variables.(default = 0.95)",
+ "R",1,"-R"));
+
+ options.addElement(new Option("\tMaximum number of attributes to include\n" +
+ "\tin transformed attribute names.\n" +
+ "\t(-1 = include all)"
+ , "A", 1, "-A"));
+ return options.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -N
+ * Normalize input data.
+ *
+ * -R
+ * Rank approximation used in LSA. May be actual number of
+ * LSA attributes to include (if greater than 1) or a proportion
+ * of total singular values to account for (if between 0 and 1).
+ * A value less than or equal to zero means use all latent variables.
+ * (default = 0.95)
+ *
+ * -A
+ * Maximum number of attributes to include in
+ * transformed attribute names. (-1 = include all)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ resetOptions();
+ String optionString;
+
+ //set approximation rank
+ optionString = Utils.getOption('R', options);
+ if (optionString.length() != 0) {
+ double temp;
+ temp = Double.valueOf(optionString).doubleValue();
+ setRank(temp);
+ }
+
+ //set number of attributes to use in transformed names
+ optionString = Utils.getOption('A', options);
+ if (optionString.length() != 0) {
+ setMaximumAttributeNames(Integer.parseInt(optionString));
+ }
+
+ //set normalize option
+ setNormalize(Utils.getFlag('N', options));
+ }
+
+ /**
+ * Reset to defaults
+ */
+ private void resetOptions() {
+ m_rank = 0.95;
+ m_normalize = true;
+ m_maxAttributesInName = 5;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String normalizeTipText() {
+ return "Normalize input data.";
+ }
+
+ /**
+ * Set whether input data will be normalized.
+ * @param newNormalize true if input data is to be normalized
+ */
+ public void setNormalize(boolean newNormalize) {
+ m_normalize = newNormalize;
+ }
+
+ /**
+ * Gets whether or not input data is to be normalized
+ * @return true if input data is to be normalized
+ */
+ public boolean getNormalize() {
+ return m_normalize;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String rankTipText() {
+ return "Matrix rank to use for data reduction. Can be a" +
+ " proportion to indicate desired coverage";
+ }
+
+ /**
+ * Sets the desired matrix rank (or coverage proportion) for feature-space reduction
+ * @param newRank the desired rank (or coverage) for feature-space reduction
+ */
+ public void setRank(double newRank) {
+ m_rank = newRank;
+ }
+
+ /**
+ * Gets the desired matrix rank (or coverage proportion) for feature-space reduction
+ * @return the rank (or coverage) for feature-space reduction
+ */
+ public double getRank() {
+ return m_rank;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String maximumAttributeNamesTipText() {
+ return "The maximum number of attributes to include in transformed attribute names.";
+ }
+
+ /**
+ * Sets maximum number of attributes to include in
+ * transformed attribute names.
+ * @param newMaxAttributes the maximum number of attributes
+ */
+ public void setMaximumAttributeNames(int newMaxAttributes) {
+ m_maxAttributesInName = newMaxAttributes;
+ }
+
+ /**
+ * Gets maximum number of attributes to include in
+ * transformed attribute names.
+ * @return the maximum number of attributes
+ */
+ public int getMaximumAttributeNames() {
+ return m_maxAttributesInName;
+ }
+
+ /**
+ * Gets the current settings of LatentSemanticAnalysis
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+
+ String[] options = new String[5];
+ int current = 0;
+
+ if (getNormalize()) {
+ options[current++] = "-N";
+ }
+
+ options[current++] = "-R";
+ options[current++] = "" + getRank();
+
+ options[current++] = "-A";
+ options[current++] = "" + getMaximumAttributeNames();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.NUMERIC_CLASS);
+ result.enable(Capability.DATE_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+ result.enable(Capability.NO_CLASS);
+
+ return result;
+ }
+
+ /**
+ * Initializes the singular values/vectors and performs the analysis
+ * @param data the instances to analyse/transform
+ * @throws Exception if analysis fails
+ */
+ public void buildEvaluator(Instances data) throws Exception {
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ buildAttributeConstructor(data);
+ }
+
+ /**
+ * Initializes the singular values/vectors and performs the analysis
+ * @param data the instances to analyse/transform
+ * @throws Exception if analysis fails
+ */
+ private void buildAttributeConstructor (Instances data) throws Exception {
+ // initialize attributes for performing analysis
+ m_transpose = false;
+ m_s = null;
+ m_u = null;
+ m_v = null;
+ m_outputNumAttributes = -1;
+ m_actualRank = -1;
+ m_sumSquaredSingularValues = 0.0;
+
+ m_trainInstances = new Instances(data);
+ m_trainHeader = null;
+
+ m_attributeFilter = null;
+ m_nominalToBinaryFilter = null;
+
+ m_replaceMissingFilter = new ReplaceMissingValues();
+ m_replaceMissingFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, m_replaceMissingFilter);
+
+ // vector to hold indices of attributes to delete (class attribute,
+ // attributes that are all missing, or attributes with one distinct value)
+ Vector attributesToRemove = new Vector();
+
+ // if data has a class attribute
+ if (m_trainInstances.classIndex() >= 0) {
+
+ m_hasClass = true;
+ m_classIndex = m_trainInstances.classIndex();
+
+ // set class attribute to be removed
+ attributesToRemove.addElement(new Integer(m_classIndex));
+ }
+ // make copy of training data so the class values (if set) can be appended to final
+ // transformed instances and so that we can check header compatibility
+ m_trainHeader = new Instances(m_trainInstances, 0);
+
+ // normalize data if desired
+ if (m_normalize) {
+ m_normalizeFilter = new Normalize();
+ m_normalizeFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, m_normalizeFilter);
+ }
+
+ // convert any nominal attributes to binary numeric attributes
+ m_nominalToBinaryFilter = new NominalToBinary();
+ m_nominalToBinaryFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, m_nominalToBinaryFilter);
+
+ // delete any attributes with only one distinct value or are all missing
+ for (int i = 0; i < m_trainInstances.numAttributes(); i++) {
+ if (m_trainInstances.numDistinctValues(i) <= 1) {
+ attributesToRemove.addElement(new Integer(i));
+ }
+ }
+
+ // remove columns from the data if necessary
+ if (attributesToRemove.size() > 0) {
+ m_attributeFilter = new Remove();
+ int [] todelete = new int[attributesToRemove.size()];
+ for (int i = 0; i < attributesToRemove.size(); i++) {
+ todelete[i] = ((Integer)(attributesToRemove.elementAt(i))).intValue();
+ }
+ m_attributeFilter.setAttributeIndicesArray(todelete);
+ m_attributeFilter.setInvertSelection(false);
+ m_attributeFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, m_attributeFilter);
+ }
+
+ // can evaluator handle the processed data ? e.g., enough attributes?
+ getCapabilities().testWithFail(m_trainInstances);
+
+ // record properties of final, ready-to-process data
+ m_numInstances = m_trainInstances.numInstances();
+ m_numAttributes = m_trainInstances.numAttributes();
+
+ // create matrix of attribute values and compute singular value decomposition
+ double [][] trainValues = new double[m_numAttributes][m_numInstances];
+ for (int i = 0; i < m_numAttributes; i++) {
+ trainValues[i] = m_trainInstances.attributeToDoubleArray(i);
+ }
+ Matrix trainMatrix = new Matrix(trainValues);
+ // svd requires rows >= columns, so transpose data if necessary
+ if (m_numAttributes < m_numInstances) {
+ m_transpose = true;
+ trainMatrix = trainMatrix.transpose();
+ }
+ SingularValueDecomposition trainSVD = trainMatrix.svd();
+ m_u = trainSVD.getU(); // left singular vectors
+ m_s = trainSVD.getS(); // singular values
+ m_v = trainSVD.getV(); // right singular vectors
+
+ // find actual rank to use
+ int maxSingularValues = trainSVD.rank();
+ for (int i = 0; i < m_s.getRowDimension(); i++) {
+ m_sumSquaredSingularValues += m_s.get(i, i) * m_s.get(i, i);
+ }
+ if (maxSingularValues == 0) { // no nonzero singular values (shouldn't happen)
+ // reset values from computation
+ m_s = null;
+ m_u = null;
+ m_v = null;
+ m_sumSquaredSingularValues = 0.0;
+
+ throw new Exception("SVD computation produced no non-zero singular values.");
+ }
+ if (m_rank > maxSingularValues || m_rank <= 0) { // adjust rank if too high or too low
+ m_actualRank = maxSingularValues;
+ } else if (m_rank < 1.0) { // determine how many singular values to include for desired coverage
+ double currentSumOfSquaredSingularValues = 0.0;
+ for (int i = 0; i < m_s.getRowDimension() && m_actualRank == -1; i++) {
+ currentSumOfSquaredSingularValues += m_s.get(i, i) * m_s.get(i, i);
+ if (currentSumOfSquaredSingularValues / m_sumSquaredSingularValues >= m_rank) {
+ m_actualRank = i + 1;
+ }
+ }
+ } else {
+ m_actualRank = (int) m_rank;
+ }
+
+ // lower matrix ranks, adjust for transposition (if necessary), and
+ // compute matrix for transforming future instances
+ if (m_transpose) {
+ Matrix tempMatrix = m_u;
+ m_u = m_v;
+ m_v = tempMatrix;
+ }
+ m_u = m_u.getMatrix(0, m_u.getRowDimension() - 1, 0, m_actualRank - 1);
+ m_s = m_s.getMatrix(0, m_actualRank - 1, 0, m_actualRank - 1);
+ m_v = m_v.getMatrix(0, m_v.getRowDimension() - 1, 0, m_actualRank - 1);
+ m_transformationMatrix = m_u.times(m_s.inverse());
+
+ //create dataset header for transformed instances
+ m_transformedFormat = setOutputFormat();
+ }
+
+ /**
+ * Set the format for the transformed data
+ * @return a set of empty Instances (header only) in the new format
+ */
+ private Instances setOutputFormat() {
+ // if analysis hasn't been performed (successfully) yet
+ if (m_s == null) {
+ return null;
+ }
+
+ // set up transformed attributes
+ if (m_hasClass) {
+ m_outputNumAttributes = m_actualRank + 1;
+ } else {
+ m_outputNumAttributes = m_actualRank;
+ }
+ int numAttributesInName = m_maxAttributesInName;
+ if (numAttributesInName <= 0 || numAttributesInName >= m_numAttributes) {
+ numAttributesInName = m_numAttributes;
+ }
+ FastVector attributes = new FastVector(m_outputNumAttributes);
+ for (int i = 0; i < m_actualRank; i++) {
+ // create attribute name
+ String attributeName = "";
+ double [] attributeCoefficients =
+ m_transformationMatrix.getMatrix(0, m_numAttributes - 1, i, i).getColumnPackedCopy();
+ for (int j = 0; j < numAttributesInName; j++) {
+ if (j > 0) {
+ attributeName += "+";
+ }
+ attributeName += Utils.doubleToString(attributeCoefficients[j], 5, 3);
+ attributeName += m_trainInstances.attribute(j).name();
+ }
+ if (numAttributesInName < m_numAttributes) {
+ attributeName += "...";
+ }
+ // add attribute
+ attributes.addElement(new Attribute(attributeName));
+ }
+ // add original class attribute if present
+ if (m_hasClass) {
+ attributes.addElement(m_trainHeader.classAttribute().copy());
+ }
+ // create blank header
+ Instances outputFormat = new Instances(m_trainInstances.relationName() + "_LSA",
+ attributes, 0);
+ m_outputNumAttributes = outputFormat.numAttributes();
+ // set class attribute if applicable
+ if (m_hasClass) {
+ outputFormat.setClassIndex(m_outputNumAttributes - 1);
+ }
+
+ return outputFormat;
+ }
+
+ /**
+ * Returns just the header for the transformed data (ie. an empty
+ * set of instances. This is so that AttributeSelection can
+ * determine the structure of the transformed data without actually
+ * having to get all the transformed data through getTransformedData().
+ * @return the header of the transformed data.
+ * @throws Exception if the header of the transformed data can't
+ * be determined.
+ */
+ public Instances transformedHeader() throws Exception {
+ if (m_s == null) {
+ throw new Exception("Latent Semantic Analysis hasn't been successfully performed.");
+ }
+ return m_transformedFormat;
+ }
+
+ /**
+ * Transform the supplied data set (assumed to be the same format
+ * as the training data)
+ * @return the transformed training data
+ * @throws Exception if transformed data can't be returned
+ */
+ public Instances transformedData(Instances data) throws Exception {
+ if (m_s == null) {
+ throw new Exception("Latent Semantic Analysis hasn't been built yet");
+ }
+
+ Instances output = new Instances(m_transformedFormat, m_numInstances);
+
+ // the transformed version of instance i from the training data
+ // is stored as the i'th row vector in v (the right singular vectors)
+ for (int i = 0; i < data.numInstances(); i++) {
+ Instance currentInstance = data.instance(i);
+ // record attribute values for converted instance
+ double [] newValues = new double[m_outputNumAttributes];
+ for (int j = 0; j < m_actualRank; j++) { // fill in values from v
+ newValues[j] = m_v.get(i, j);
+ }
+ if (m_hasClass) { // copy class value if applicable
+ newValues[m_outputNumAttributes - 1] = currentInstance.classValue();
+ }
+ //create new instance with recorded values and add to output dataset
+ Instance newInstance;
+ if (currentInstance instanceof SparseInstance) {
+ newInstance = new SparseInstance(currentInstance.weight(), newValues);
+ } else {
+ newInstance = new DenseInstance(currentInstance.weight(), newValues);
+ }
+ output.add(newInstance);
+ }
+
+ return output;
+ }
+
+ /**
+ * Evaluates the merit of a transformed attribute. This is defined
+ * to be the square of the singular value for the latent variable
+ * corresponding to the transformed attribute.
+ * @param att the attribute to be evaluated
+ * @return the merit of a transformed attribute
+ * @throws Exception if attribute can't be evaluated
+ */
+ public double evaluateAttribute(int att) throws Exception {
+ if (m_s == null) {
+ throw new Exception("Latent Semantic Analysis hasn't been successfully" +
+ " performed yet!");
+ }
+
+ //return the square of the corresponding singular value
+ return (m_s.get(att, att) * m_s.get(att, att)) / m_sumSquaredSingularValues;
+ }
+
+ /**
+ * Transform an instance in original (unnormalized) format
+ * @param instance an instance in the original (unnormalized) format
+ * @return a transformed instance
+ * @throws Exception if instance can't be transformed
+ */
+ public Instance convertInstance(Instance instance) throws Exception {
+ if (m_s == null) {
+ throw new Exception("convertInstance: Latent Semantic Analysis not " +
+ "performed yet.");
+ }
+
+ // array to hold new attribute values
+ double [] newValues = new double[m_outputNumAttributes];
+
+ // apply filters so new instance is in same format as training instances
+ Instance tempInstance = (Instance)instance.copy();
+ if (!instance.dataset().equalHeaders(m_trainHeader)) {
+ throw new Exception("Can't convert instance: headers don't match: " +
+ "LatentSemanticAnalysis\n" + instance.dataset().equalHeadersMsg(m_trainHeader));
+ }
+ // replace missing values
+ m_replaceMissingFilter.input(tempInstance);
+ m_replaceMissingFilter.batchFinished();
+ tempInstance = m_replaceMissingFilter.output();
+ // normalize
+ if (m_normalize) {
+ m_normalizeFilter.input(tempInstance);
+ m_normalizeFilter.batchFinished();
+ tempInstance = m_normalizeFilter.output();
+ }
+ // convert nominal attributes to binary
+ m_nominalToBinaryFilter.input(tempInstance);
+ m_nominalToBinaryFilter.batchFinished();
+ tempInstance = m_nominalToBinaryFilter.output();
+ // remove class/other attributes
+ if (m_attributeFilter != null) {
+ m_attributeFilter.input(tempInstance);
+ m_attributeFilter.batchFinished();
+ tempInstance = m_attributeFilter.output();
+ }
+
+ // record new attribute values
+ if (m_hasClass) { // copy class value
+ newValues[m_outputNumAttributes - 1] = instance.classValue();
+ }
+ double [][] oldInstanceValues = new double[1][m_numAttributes];
+ oldInstanceValues[0] = tempInstance.toDoubleArray();
+ Matrix instanceVector = new Matrix(oldInstanceValues); // old attribute values
+ instanceVector = instanceVector.times(m_transformationMatrix); // new attribute values
+ for (int i = 0; i < m_actualRank; i++) {
+ newValues[i] = instanceVector.get(0, i);
+ }
+
+ // return newly transformed instance
+ if (instance instanceof SparseInstance) {
+ return new SparseInstance(instance.weight(), newValues);
+ } else {
+ return new DenseInstance(instance.weight(), newValues);
+ }
+ }
+
+ /**
+ * Returns a description of this attribute transformer
+ * @return a String describing this attribute transformer
+ */
+ public String toString() {
+ if (m_s == null) {
+ return "Latent Semantic Analysis hasn't been built yet!";
+ } else {
+ return "\tLatent Semantic Analysis Attribute Transformer\n\n"
+ + lsaSummary();
+ }
+ }
+
+ /**
+ * Return a summary of the analysis
+ * @return a summary of the analysis.
+ */
+ private String lsaSummary() {
+ StringBuffer result = new StringBuffer();
+
+ // print number of latent variables used
+ result.append("Number of latent variables utilized: " + m_actualRank);
+
+ // print singular values
+ result.append("\n\nSingularValue\tLatentVariable#\n");
+ // create single array of singular values rather than diagonal matrix
+ for (int i = 0; i < m_actualRank; i++) {
+ result.append(Utils.doubleToString(m_s.get(i, i), 9, 5) + "\t" + (i + 1) + "\n");
+ }
+
+ // print attribute vectors
+ result.append("\nAttribute vectors (left singular vectors) -- row vectors show\n" +
+ "the relation between the original attributes and the latent \n" +
+ "variables computed by the singular value decomposition:\n");
+ for (int i = 0; i < m_actualRank; i++) {
+ result.append("LatentVariable#" + (i + 1) + "\t");
+ }
+ result.append("AttributeName\n");
+ for (int i = 0; i < m_u.getRowDimension(); i++) { // for each attribute
+ for (int j = 0; j < m_u.getColumnDimension(); j++) { // for each latent variable
+ result.append(Utils.doubleToString(m_u.get(i, j), 9, 5) + "\t\t");
+ }
+ result.append(m_trainInstances.attribute(i).name() + "\n");
+ }
+
+ // print instance vectors
+ result.append("\n\nInstance vectors (right singular vectors) -- column\n" +
+ "vectors show the relation between the original instances and the\n" +
+ "latent variables computed by the singular value decomposition:\n");
+ for (int i = 0; i < m_numInstances; i++) {
+ result.append("Instance#" + (i + 1) + "\t");
+ }
+ result.append("LatentVariable#\n");
+ for (int i = 0; i < m_v.getColumnDimension(); i++) { // for each instance
+ for (int j = 0; j < m_v.getRowDimension(); j++) { // for each latent variable
+ // going down columns instead of across rows because we're
+ // printing v' but have v stored
+ result.append(Utils.doubleToString(m_v.get(j, i), 9, 5) + "\t");
+ }
+ result.append((i + 1) + "\n");
+ }
+
+ return result.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5987 $");
+ }
+
+ /**
+ * Main method for testing this class
+ * @param argv should contain the command line arguments to the
+ * evaluator/transformer (see AttributeSelection)
+ */
+ public static void main(String [] argv) {
+ runEvaluator(new LatentSemanticAnalysis(), argv);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/LinearForwardSelection.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/LinearForwardSelection.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/LinearForwardSelection.java (revision 29)
@@ -0,0 +1,875 @@
+/*
+ * 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.
+ */
+
+/*
+ * LinearForwardSelection.java
+ * Copyright (C) 2007 Martin Guetlein
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Range;
+import weka.core.RevisionUtils;
+import weka.core.SelectedTag;
+import weka.core.Tag;
+import weka.core.Utils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Vector;
+
+
+/**
+
+ * LinearForwardSelection:
+ *
+ * Extension of BestFirst. Takes a restricted number of k attributes into account. Fixed-set selects a fixed number k of attributes, whereas k is increased in each step when fixed-width is selected. The search uses either the initial ordering to select the top k attributes, or performs a ranking (with the same evalutator the search uses later on). The search direction can be forward, or floating forward selection (with opitional backward search steps).
+ *
+ * For more information see:
+ *
+ * Martin Guetlein, Eibe Frank, Mark Hall, Andreas Karwath: Large Scale Attribute Selection Using Wrappers. In: Proc IEEE Symposium on Computational Intelligence and Data Mining, 332-339, 2009.
+ *
+ * Martin Guetlein (2006). Large Scale Attribute Selection Using Wrappers. Freiburg, Germany.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ *
+ * -D <0 = forward selection | 1 = floating forward selection>
+ * Forward selection method. (default = 0).
+ *
+ * -N <num>
+ * Number of non-improving nodes to
+ * consider before terminating search.
+ *
+ * -I
+ * Perform initial ranking to select the
+ * top-ranked attributes.
+ *
+ * -K <num>
+ * Number of top-ranked attributes that are
+ * taken into account by the search.
+ *
+ * -T <0 = fixed-set | 1 = fixed-width>
+ * Type of Linear Forward Selection (default = 0).
+ *
+ * -S <num>
+ * Size of lookup cache for evaluated subsets.
+ * Expressed as a multiple of the number of
+ * attributes in the data set. (default = 1)
+ *
+ * -Z
+ * verbose on/off
+ *
+
+ *
+ * @author Martin Guetlein (martin.guetlein@gmail.com)
+ * @version $Revision: 6160 $
+ */
+public class LinearForwardSelection
+ extends ASSearch
+ implements OptionHandler,
+ StartSetHandler,
+ TechnicalInformationHandler {
+ /** search directions */
+ protected static final int SEARCH_METHOD_FORWARD = 0;
+ protected static final int SEARCH_METHOD_FLOATING = 1;
+ public static final Tag[] TAGS_SEARCH_METHOD = {
+ new Tag(SEARCH_METHOD_FORWARD, "Forward selection"),
+ new Tag(SEARCH_METHOD_FLOATING, "Floating forward selection"),
+ };
+
+ /** search directions */
+ protected static final int TYPE_FIXED_SET = 0;
+ protected static final int TYPE_FIXED_WIDTH = 1;
+ public static final Tag[] TAGS_TYPE = {
+ new Tag(TYPE_FIXED_SET, "Fixed-set"),
+ new Tag(TYPE_FIXED_WIDTH, "Fixed-width"),
+ };
+
+ // member variables
+ /** maximum number of stale nodes before terminating search */
+ protected int m_maxStale;
+
+ /** 0 == forward selection, 1 == floating forward search */
+ protected int m_forwardSearchMethod;
+
+ /** perform initial ranking to select top-ranked attributes */
+ protected boolean m_performRanking;
+
+ /**
+ * number of top-ranked attributes that are taken into account for the
+ * search
+ */
+ protected int m_numUsedAttributes;
+
+ /** 0 == fixed-set, 1 == fixed-width */
+ protected int m_linearSelectionType;
+
+ /** holds an array of starting attributes */
+ protected int[] m_starting;
+
+ /** holds the start set for the search as a Range */
+ protected Range m_startRange;
+
+ /** does the data have a class */
+ protected boolean m_hasClass;
+
+ /** holds the class index */
+ protected int m_classIndex;
+
+ /** number of attributes in the data */
+ protected int m_numAttribs;
+
+ /** total number of subsets evaluated during a search */
+ protected int m_totalEvals;
+
+ /** for debugging */
+ protected boolean m_verbose;
+
+ /** holds the merit of the best subset found */
+ protected double m_bestMerit;
+
+ /** holds the maximum size of the lookup cache for evaluated subsets */
+ protected int m_cacheSize;
+
+ /**
+ * Constructor
+ */
+ public LinearForwardSelection() {
+ resetOptions();
+ }
+
+ /**
+ * Returns a string describing this search method
+ *
+ * @return a description of the search method suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "LinearForwardSelection:\n\n" +
+ "Extension of BestFirst. Takes a restricted number of k attributes " +
+ "into account. Fixed-set selects a fixed number k of attributes, " +
+ "whereas k is increased in each step when fixed-width is selected. " +
+ "The search uses either the initial ordering to select the " +
+ "top k attributes, or performs a ranking (with the same evalutator the " +
+ "search uses later on). The search direction can be forward, " +
+ "or floating forward selection (with opitional backward search steps).\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+ TechnicalInformation additional;
+
+ result = new TechnicalInformation(Type.INPROCEEDINGS);
+ result.setValue(Field.AUTHOR, "Martin Guetlein and Eibe Frank and Mark Hall and Andreas Karwath");
+ result.setValue(Field.YEAR, "2009");
+ result.setValue(Field.TITLE, "Large Scale Attribute Selection Using Wrappers");
+ result.setValue(Field.BOOKTITLE, "Proc IEEE Symposium on Computational Intelligence and Data Mining");
+ result.setValue(Field.PAGES, "332-339");
+ result.setValue(Field.PUBLISHER, "IEEE");
+
+ additional = result.add(Type.MASTERSTHESIS);
+ additional.setValue(Field.AUTHOR, "Martin Guetlein");
+ additional.setValue(Field.YEAR, "2006");
+ additional.setValue(Field.TITLE, "Large Scale Attribute Selection Using Wrappers");
+ additional.setValue(Field.SCHOOL, "Albert-Ludwigs-Universitaet");
+ additional.setValue(Field.ADDRESS, "Freiburg, Germany");
+
+ return result;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ *
+ */
+ public Enumeration listOptions() {
+ Vector newVector = new Vector(8);
+
+ newVector.addElement(new Option("\tSpecify a starting set of attributes." +
+ "\n\tEg. 1,3,5-7.", "P", 1, "-P "));
+ newVector.addElement(new Option(
+ "\tForward selection method. (default = 0).", "D", 1,
+ "-D <0 = forward selection | 1 = floating forward selection>"));
+ newVector.addElement(new Option("\tNumber of non-improving nodes to" +
+ "\n\tconsider before terminating search.", "N", 1, "-N "));
+ newVector.addElement(new Option("\tPerform initial ranking to select the" +
+ "\n\ttop-ranked attributes.", "I", 0, "-I"));
+ newVector.addElement(new Option(
+ "\tNumber of top-ranked attributes that are " +
+ "\n\ttaken into account by the search.", "K", 1, "-K "));
+ newVector.addElement(new Option(
+ "\tType of Linear Forward Selection (default = 0).", "T", 1,
+ "-T <0 = fixed-set | 1 = fixed-width>"));
+ newVector.addElement(new Option(
+ "\tSize of lookup cache for evaluated subsets." +
+ "\n\tExpressed as a multiple of the number of" +
+ "\n\tattributes in the data set. (default = 1)", "S", 1, "-S "));
+ newVector.addElement(new Option("\tverbose on/off", "Z", 0, "-Z"));
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+ * Valid options are:
+ *
+ *
+ * -P
+ * Specify a starting set of attributes. Eg 1,4,7-9.
+ *
+ *
+ * -D <0 = forward selection | 1 = floating forward selection>
+ * Forward selection method of the search. (default = 0).
+ *
+ *
+ * -N
+ * Number of non improving nodes to consider before terminating search.
+ * (default = 5).
+ *
+ *
+ * -I
+ * Perform initial ranking to select top-ranked attributes.
+ *
+ *
+ * -K
+ * Number of top-ranked attributes that are taken into account.
+ *
+ *
+ * -T <0 = fixed-set | 1 = fixed-width>
+ * Typ of Linear Forward Selection (default = 0).
+ *
+ *
+ * -S
+ * Size of lookup cache for evaluated subsets. Expressed as a multiple of
+ * the number of attributes in the data set. (default = 1).
+ *
+ *
+ * -Z
+ * verbose on/off.
+ *
+ *
+ * @param options
+ * the list of options as an array of strings
+ * @exception Exception
+ * if an option is not supported
+ *
+ */
+ public void setOptions(String[] options) throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('P', options);
+
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ optionString = Utils.getOption('D', options);
+
+ if (optionString.length() != 0) {
+ setForwardSelectionMethod(new SelectedTag(Integer.parseInt(optionString),
+ TAGS_SEARCH_METHOD));
+ } else {
+ setForwardSelectionMethod(new SelectedTag(SEARCH_METHOD_FORWARD,
+ TAGS_SEARCH_METHOD));
+ }
+
+ optionString = Utils.getOption('N', options);
+
+ if (optionString.length() != 0) {
+ setSearchTermination(Integer.parseInt(optionString));
+ }
+
+ setPerformRanking(Utils.getFlag('I', options));
+
+ optionString = Utils.getOption('K', options);
+
+ if (optionString.length() != 0) {
+ setNumUsedAttributes(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('T', options);
+
+ if (optionString.length() != 0) {
+ setType(new SelectedTag(Integer.parseInt(optionString), TAGS_TYPE));
+ } else {
+ setType(new SelectedTag(TYPE_FIXED_SET, TAGS_TYPE));
+ }
+
+ optionString = Utils.getOption('S', options);
+
+ if (optionString.length() != 0) {
+ setLookupCacheSize(Integer.parseInt(optionString));
+ }
+
+ m_verbose = Utils.getFlag('Z', options);
+ }
+
+ /**
+ * Set the maximum size of the evaluated subset cache (hashtable). This is
+ * expressed as a multiplier for the number of attributes in the data set.
+ * (default = 1).
+ *
+ * @param size
+ * the maximum size of the hashtable
+ */
+ public void setLookupCacheSize(int size) {
+ if (size >= 0) {
+ m_cacheSize = size;
+ }
+ }
+
+ /**
+ * Return the maximum size of the evaluated subset cache (expressed as a
+ * multiplier for the number of attributes in a data set.
+ *
+ * @return the maximum size of the hashtable.
+ */
+ public int getLookupCacheSize() {
+ return m_cacheSize;
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String lookupCacheSizeTipText() {
+ return "Set the maximum size of the lookup cache of evaluated subsets. This is " +
+ "expressed as a multiplier of the number of attributes in the data set. " +
+ "(default = 1).";
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String startSetTipText() {
+ return "Set the start point for the search. This is specified as a comma " +
+ "seperated list off attribute indexes starting at 1. It can include " +
+ "ranges. Eg. 1,2,5-9,17.";
+ }
+
+ /**
+ * Sets a starting set of attributes for the search. It is the search
+ * method's responsibility to report this start set (if any) in its
+ * toString() method.
+ *
+ * @param startSet
+ * a string containing a list of attributes (and or ranges), eg.
+ * 1,2,6,10-15.
+ * @exception Exception
+ * if start set can't be set.
+ */
+ public void setStartSet(String startSet) throws Exception {
+ m_startRange.setRanges(startSet);
+ }
+
+ /**
+ * Returns a list of attributes (and or attribute ranges) as a String
+ *
+ * @return a list of attributes (and or attribute ranges)
+ */
+ public String getStartSet() {
+ return m_startRange.getRanges();
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String searchTerminationTipText() {
+ return "Set the amount of backtracking. Specify the number of ";
+ }
+
+ /**
+ * Set the numnber of non-improving nodes to consider before terminating
+ * search.
+ *
+ * @param t
+ * the number of non-improving nodes
+ * @exception Exception
+ * if t is less than 1
+ */
+ public void setSearchTermination(int t) throws Exception {
+ if (t < 1) {
+ throw new Exception("Value of -N must be > 0.");
+ }
+
+ m_maxStale = t;
+ }
+
+ /**
+ * Get the termination criterion (number of non-improving nodes).
+ *
+ * @return the number of non-improving nodes
+ */
+ public int getSearchTermination() {
+ return m_maxStale;
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String performRankingTipText() {
+ return "Perform initial ranking to select top-ranked attributes.";
+ }
+
+ /**
+ * Perform initial ranking to select top-ranked attributes.
+ *
+ * @param b
+ * true if initial ranking should be performed
+ */
+ public void setPerformRanking(boolean b) {
+ m_performRanking = b;
+ }
+
+ /**
+ * Get boolean if initial ranking should be performed to select the
+ * top-ranked attributes
+ *
+ * @return true if initial ranking should be performed
+ */
+ public boolean getPerformRanking() {
+ return m_performRanking;
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String numUsedAttributesTipText() {
+ return "Set the amount of top-ranked attributes that are taken into account by the search process.";
+ }
+
+ /**
+ * Set the number of top-ranked attributes that taken into account by the
+ * search process.
+ *
+ * @param k
+ * the number of attributes
+ * @exception Exception
+ * if k is less than 2
+ */
+ public void setNumUsedAttributes(int k) throws Exception {
+ if (k < 2) {
+ throw new Exception("Value of -K must be >= 2.");
+ }
+
+ m_numUsedAttributes = k;
+ }
+
+ /**
+ * Get the number of top-ranked attributes that taken into account by the
+ * search process.
+ *
+ * @return the number of top-ranked attributes that taken into account
+ */
+ public int getNumUsedAttributes() {
+ return m_numUsedAttributes;
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String forwardSelectionMethodTipText() {
+ return "Set the direction of the search.";
+ }
+
+ /**
+ * Set the search direction
+ *
+ * @param d
+ * the direction of the search
+ */
+ public void setForwardSelectionMethod(SelectedTag d) {
+ if (d.getTags() == TAGS_SEARCH_METHOD) {
+ m_forwardSearchMethod = d.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Get the search direction
+ *
+ * @return the direction of the search
+ */
+ public SelectedTag getForwardSelectionMethod() {
+ return new SelectedTag(m_forwardSearchMethod, TAGS_SEARCH_METHOD);
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String typeTipText() {
+ return "Set the type of the search.";
+ }
+
+ /**
+ * Set the type
+ *
+ * @param t
+ * the Linear Forward Selection type
+ */
+ public void setType(SelectedTag t) {
+ if (t.getTags() == TAGS_TYPE) {
+ m_linearSelectionType = t.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Get the type
+ *
+ * @return the Linear Forward Selection type
+ */
+ public SelectedTag getType() {
+ return new SelectedTag(m_linearSelectionType, TAGS_TYPE);
+ }
+
+ /**
+ * Returns the tip text for this property
+ *
+ * @return tip text for this property suitable for displaying in the
+ * explorer/experimenter gui
+ */
+ public String verboseTipText() {
+ return "Turn on verbose output for monitoring the search's progress.";
+ }
+
+ /**
+ * Set whether verbose output should be generated.
+ *
+ * @param b
+ * true if output is to be verbose.
+ */
+ public void setVerbose(boolean b) {
+ m_verbose = b;
+ }
+
+ /**
+ * Get whether output is to be verbose
+ *
+ * @return true if output will be verbose
+ */
+ public boolean getVerbose() {
+ return m_verbose;
+ }
+
+ /**
+ * Gets the current settings of LinearForwardSelection.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions() {
+ String[] options = new String[13];
+ int current = 0;
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = "" + startSetToString();
+ }
+
+ options[current++] = "-D";
+ options[current++] = "" + m_forwardSearchMethod;
+ options[current++] = "-N";
+ options[current++] = "" + m_maxStale;
+
+ if (m_performRanking) {
+ options[current++] = "-I";
+ }
+
+ options[current++] = "-K";
+ options[current++] = "" + m_numUsedAttributes;
+ options[current++] = "-T";
+ options[current++] = "" + m_linearSelectionType;
+
+ if (m_verbose)
+ options[current++] = "-Z";
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is used by
+ * getOptions to return the actual attributes specified as the starting set.
+ * This is better than using m_startRanges.getRanges() as the same start set
+ * can be specified in different ways from the command line---eg 1,2,3 ==
+ * 1-3. This is to ensure that stuff that is stored in a database is
+ * comparable.
+ *
+ * @return a comma seperated list of individual attribute numbers as a
+ * String
+ */
+ private String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ ((m_hasClass == true) && (i != m_classIndex))) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ } else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * returns a description of the search as a String
+ *
+ * @return a description of the search
+ */
+ public String toString() {
+ StringBuffer LFSString = new StringBuffer();
+
+ LFSString.append("\tLinear Forward Selection.\n\tStart set: ");
+
+ if (m_starting == null) {
+ LFSString.append("no attributes\n");
+ } else {
+ LFSString.append(startSetToString() + "\n");
+ }
+
+ LFSString.append("\tForward selection method: ");
+
+ if (m_forwardSearchMethod == SEARCH_METHOD_FORWARD) {
+ LFSString.append("forward selection\n");
+ } else {
+ LFSString.append("floating forward selection\n");
+ }
+
+ LFSString.append("\tStale search after " + m_maxStale +
+ " node expansions\n");
+
+ LFSString.append("\tLinear Forward Selection Type: ");
+
+ if (m_linearSelectionType == TYPE_FIXED_SET) {
+ LFSString.append("fixed-set\n");
+ } else {
+ LFSString.append("fixed-width\n");
+ }
+
+ LFSString.append("\tNumber of top-ranked attributes that are used: " +
+ m_numUsedAttributes + "\n");
+
+ LFSString.append("\tTotal number of subsets evaluated: " + m_totalEvals +
+ "\n");
+ LFSString.append("\tMerit of best subset found: " +
+ Utils.doubleToString(Math.abs(m_bestMerit), 8, 3) + "\n");
+
+ return LFSString.toString();
+ }
+
+ /**
+ * Searches the attribute subset space by linear forward selection
+ *
+ * @param ASEval
+ * the attribute evaluator to guide the search
+ * @param data
+ * the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @exception Exception
+ * if the search can't be completed
+ */
+ public int[] search(ASEvaluation ASEval, Instances data)
+ throws Exception {
+ m_totalEvals = 0;
+
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName() + " is not a " +
+ "Subset evaluator!");
+ }
+
+ if (ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ } else {
+ m_hasClass = true;
+ m_classIndex = data.classIndex();
+ }
+
+ ((ASEvaluation) ASEval).buildEvaluator(data);
+
+ m_numAttribs = data.numAttributes();
+
+ if (m_numUsedAttributes > m_numAttribs) {
+ System.out.println(
+ "Decreasing number of top-ranked attributes to total number of attributes: " +
+ data.numAttributes());
+ m_numUsedAttributes = m_numAttribs;
+ }
+
+ BitSet start_group = new BitSet(m_numAttribs);
+ m_startRange.setUpper(m_numAttribs - 1);
+
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+
+ // If a starting subset has been supplied, then initialise the bitset
+ if (m_starting != null) {
+ for (int i = 0; i < m_starting.length; i++) {
+ if ((m_starting[i]) != m_classIndex) {
+ start_group.set(m_starting[i]);
+ }
+ }
+ }
+
+ LFSMethods LFS = new LFSMethods();
+
+ int[] ranking;
+
+ if (m_performRanking) {
+ ranking = LFS.rankAttributes(data, (SubsetEvaluator) ASEval, m_verbose);
+ } else {
+ ranking = new int[m_numAttribs];
+
+ for (int i = 0; i < ranking.length; i++) {
+ ranking[i] = i;
+ }
+ }
+
+ if (m_forwardSearchMethod == SEARCH_METHOD_FORWARD) {
+ LFS.forwardSearch(m_cacheSize, start_group, ranking, m_numUsedAttributes,
+ m_linearSelectionType == TYPE_FIXED_WIDTH, m_maxStale, -1, data,
+ (SubsetEvaluator) ASEval, m_verbose);
+ } else if (m_forwardSearchMethod == SEARCH_METHOD_FLOATING) {
+ LFS.floatingForwardSearch(m_cacheSize, start_group, ranking,
+ m_numUsedAttributes, m_linearSelectionType == TYPE_FIXED_WIDTH,
+ m_maxStale, data, (SubsetEvaluator) ASEval, m_verbose);
+ }
+
+ m_totalEvals = LFS.getNumEvalsTotal();
+ m_bestMerit = LFS.getBestMerit();
+
+ return attributeList(LFS.getBestGroup());
+ }
+
+ /**
+ * Reset options to default values
+ */
+ protected void resetOptions() {
+ m_maxStale = 5;
+ m_forwardSearchMethod = SEARCH_METHOD_FORWARD;
+ m_performRanking = true;
+ m_numUsedAttributes = 50;
+ m_linearSelectionType = TYPE_FIXED_SET;
+ m_starting = null;
+ m_startRange = new Range();
+ m_classIndex = -1;
+ m_totalEvals = 0;
+ m_cacheSize = 1;
+ m_verbose = false;
+ }
+
+ /**
+ * converts a BitSet into a list of attribute indexes
+ *
+ * @param group
+ * the BitSet to convert
+ * @return an array of attribute indexes
+ */
+ protected int[] attributeList(BitSet group) {
+ int count = 0;
+
+ // count how many were selected
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ count++;
+ }
+ }
+
+ int[] list = new int[count];
+ count = 0;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ list[count++] = i;
+ }
+ }
+
+ return list;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 6160 $");
+ }
+}
+
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/OneRAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/OneRAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/OneRAttributeEval.java (revision 29)
@@ -0,0 +1,485 @@
+/*
+ * 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.
+ */
+
+/*
+ * OneRAttributeEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.classifiers.Classifier;
+import weka.classifiers.AbstractClassifier;
+import weka.classifiers.Evaluation;
+import weka.core.Capabilities;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.filters.Filter;
+import weka.filters.unsupervised.attribute.Remove;
+
+import java.util.Enumeration;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+
+ * OneRAttributeEval :
+ *
+ * Evaluates the worth of an attribute by using the OneR classifier.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -S <seed>
+ * Random number seed for cross validation
+ * (default = 1)
+ *
+ * -F <folds>
+ * Number of folds for cross validation
+ * (default = 10)
+ *
+ * -D
+ * Use training data for evaluation rather than cross validaton
+ *
+ * -B <minimum bucket size>
+ * Minimum number of objects in a bucket
+ * (passed on to OneR, default = 6)
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5928 $
+ */
+public class OneRAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 4386514823886856980L;
+
+ /** The training instances */
+ private Instances m_trainInstances;
+
+ /** The class index */
+ private int m_classIndex;
+
+ /** The number of attributes */
+ private int m_numAttribs;
+
+ /** The number of instances */
+ private int m_numInstances;
+
+ /** Random number seed */
+ private int m_randomSeed;
+
+ /** Number of folds for cross validation */
+ private int m_folds;
+
+ /** Use training data to evaluate merit rather than x-val */
+ private boolean m_evalUsingTrainingData;
+
+ /** Passed on to OneR */
+ private int m_minBucketSize;
+
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "OneRAttributeEval :\n\nEvaluates the worth of an attribute by "
+ +"using the OneR classifier.\n";
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text
+ *
+ * @return a string describing this option
+ */
+ public String seedTipText() {
+ return "Set the seed for use in cross validation.";
+ }
+
+ /**
+ * Set the random number seed for cross validation
+ *
+ * @param seed the seed to use
+ */
+ public void setSeed(int seed) {
+ m_randomSeed = seed;
+ }
+
+ /**
+ * Get the random number seed
+ *
+ * @return an int value
+ */
+ public int getSeed() {
+ return m_randomSeed;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text
+ *
+ * @return a string describing this option
+ */
+ public String foldsTipText() {
+ return "Set the number of folds for cross validation.";
+ }
+
+ /**
+ * Set the number of folds to use for cross validation
+ *
+ * @param folds the number of folds
+ */
+ public void setFolds(int folds) {
+ m_folds = folds;
+ if (m_folds < 2) {
+ m_folds = 2;
+ }
+ }
+
+ /**
+ * Get the number of folds used for cross validation
+ *
+ * @return the number of folds
+ */
+ public int getFolds() {
+ return m_folds;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text
+ *
+ * @return a string describing this option
+ */
+ public String evalUsingTrainingDataTipText() {
+ return "Use the training data to evaluate attributes rather than "
+ + "cross validation.";
+ }
+
+ /**
+ * Use the training data to evaluate attributes rather than cross validation
+ *
+ * @param e true if training data is to be used for evaluation
+ */
+ public void setEvalUsingTrainingData(boolean e) {
+ m_evalUsingTrainingData = e;
+ }
+
+ /**
+ * Returns a string for this option suitable for display in the gui
+ * as a tip text
+ *
+ * @return a string describing this option
+ */
+ public String minimumBucketSizeTipText() {
+ return "The minimum number of objects in a bucket "
+ + "(passed to OneR).";
+ }
+
+ /**
+ * Set the minumum bucket size used by OneR
+ *
+ * @param minB the minimum bucket size to use
+ */
+ public void setMinimumBucketSize(int minB) {
+ m_minBucketSize = minB;
+ }
+
+ /**
+ * Get the minimum bucket size used by oneR
+ *
+ * @return the minimum bucket size used
+ */
+ public int getMinimumBucketSize() {
+ return m_minBucketSize;
+ }
+
+ /**
+ * Returns true if the training data is to be used for evaluation
+ *
+ * @return true if training data is to be used for evaluation
+ */
+ public boolean getEvalUsingTrainingData() {
+ return m_evalUsingTrainingData;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ */
+ public Enumeration listOptions() {
+
+ Vector newVector = new Vector(4);
+
+ newVector.addElement(new Option(
+ "\tRandom number seed for cross validation\n"
+ + "\t(default = 1)",
+ "S", 1, "-S "));
+
+ newVector.addElement(new Option(
+ "\tNumber of folds for cross validation\n"
+ + "\t(default = 10)",
+ "F", 1, "-F "));
+
+ newVector.addElement(new Option(
+ "\tUse training data for evaluation rather than cross validaton",
+ "D", 0, "-D"));
+
+ newVector.addElement(new Option(
+ "\tMinimum number of objects in a bucket\n"
+ + "\t(passed on to "
+ +"OneR, default = 6)",
+ "B", 1, "-B "));
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -S <seed>
+ * Random number seed for cross validation
+ * (default = 1)
+ *
+ * -F <folds>
+ * Number of folds for cross validation
+ * (default = 10)
+ *
+ * -D
+ * Use training data for evaluation rather than cross validaton
+ *
+ * -B <minimum bucket size>
+ * Minimum number of objects in a bucket
+ * (passed on to OneR, default = 6)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions(String [] options) throws Exception {
+ String temp = Utils.getOption('S', options);
+
+ if (temp.length() != 0) {
+ setSeed(Integer.parseInt(temp));
+ }
+
+ temp = Utils.getOption('F', options);
+ if (temp.length() != 0) {
+ setFolds(Integer.parseInt(temp));
+ }
+
+ temp = Utils.getOption('B', options);
+ if (temp.length() != 0) {
+ setMinimumBucketSize(Integer.parseInt(temp));
+ }
+
+ setEvalUsingTrainingData(Utils.getFlag('D', options));
+ Utils.checkForRemainingOptions(options);
+ }
+
+ /**
+ * returns the current setup.
+ *
+ * @return the options of the current setup
+ */
+ public String[] getOptions() {
+ String [] options = new String [7];
+ int current = 0;
+
+ if (getEvalUsingTrainingData()) {
+ options[current++] = "-D";
+ }
+
+ options[current++] = "-S";
+ options[current++] = "" + getSeed();
+ options[current++] = "-F";
+ options[current++] = "" + getFolds();
+ options[current++] = "-B";
+ options[current++] = "" + getMinimumBucketSize();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+ return options;
+ }
+
+ /**
+ * Constructor
+ */
+ public OneRAttributeEval () {
+ resetOptions();
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Initializes a OneRAttribute attribute evaluator.
+ * Discretizes all attributes that are numeric.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ m_trainInstances = data;
+ m_classIndex = m_trainInstances.classIndex();
+ m_numAttribs = m_trainInstances.numAttributes();
+ m_numInstances = m_trainInstances.numInstances();
+ }
+
+
+ /**
+ * rests to defaults.
+ */
+ protected void resetOptions () {
+ m_trainInstances = null;
+ m_randomSeed = 1;
+ m_folds = 10;
+ m_evalUsingTrainingData = false;
+ m_minBucketSize = 6; // default used by OneR
+ }
+
+
+ /**
+ * evaluates an individual attribute by measuring the amount
+ * of information gained about the class given the attribute.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute (int attribute)
+ throws Exception {
+ int[] featArray = new int[2]; // feat + class
+ double errorRate;
+ Evaluation o_Evaluation;
+ Remove delTransform = new Remove();
+ delTransform.setInvertSelection(true);
+ // copy the instances
+ Instances trainCopy = new Instances(m_trainInstances);
+ featArray[0] = attribute;
+ featArray[1] = trainCopy.classIndex();
+ delTransform.setAttributeIndicesArray(featArray);
+ delTransform.setInputFormat(trainCopy);
+ trainCopy = Filter.useFilter(trainCopy, delTransform);
+ o_Evaluation = new Evaluation(trainCopy);
+ String [] oneROpts = { "-B", ""+getMinimumBucketSize()};
+ Classifier oneR = AbstractClassifier.forName("weka.classifiers.rules.OneR", oneROpts);
+ if (m_evalUsingTrainingData) {
+ oneR.buildClassifier(trainCopy);
+ o_Evaluation.evaluateModel(oneR, trainCopy);
+ } else {
+ /* o_Evaluation.crossValidateModel("weka.classifiers.rules.OneR",
+ trainCopy, 10,
+ null, new Random(m_randomSeed)); */
+ o_Evaluation.crossValidateModel(oneR, trainCopy, m_folds, new Random(m_randomSeed));
+ }
+ errorRate = o_Evaluation.errorRate();
+ return (1 - errorRate)*100.0;
+ }
+
+
+ /**
+ * Return a description of the evaluator
+ * @return description as a string
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_trainInstances == null) {
+ text.append("\tOneR feature evaluator has not been built yet");
+ }
+ else {
+ text.append("\tOneR feature evaluator.\n\n");
+ text.append("\tUsing ");
+ if (m_evalUsingTrainingData) {
+ text.append("training data for evaluation of attributes.");
+ } else {
+ text.append(""+getFolds()+" fold cross validation for evaluating "
+ +"attributes.");
+ }
+ text.append("\n\tMinimum bucket size for OneR: "
+ +getMinimumBucketSize());
+ }
+
+ text.append("\n");
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5928 $");
+ }
+
+ // ============
+ // Test method.
+ // ============
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new OneRAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/PrincipalComponents.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/PrincipalComponents.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/PrincipalComponents.java (revision 29)
@@ -0,0 +1,962 @@
+/*
+ * 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.
+ */
+
+/*
+ * PrincipalComponents.java
+ * Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+import weka.core.Attribute;
+import weka.core.Capabilities;
+import weka.core.FastVector;
+import weka.core.Instance;
+import weka.core.DenseInstance;
+import weka.core.Instances;
+import weka.core.Matrix;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SparseInstance;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.filters.Filter;
+import weka.filters.unsupervised.attribute.NominalToBinary;
+import weka.filters.unsupervised.attribute.Normalize;
+import weka.filters.unsupervised.attribute.Remove;
+import weka.filters.unsupervised.attribute.ReplaceMissingValues;
+
+/**
+
+ * Performs a principal components analysis and transformation of the data. Use in conjunction with a Ranker search. Dimensionality reduction is accomplished by choosing enough eigenvectors to account for some percentage of the variance in the original data---default 0.95 (95%). Attribute noise can be filtered by transforming to the PC space, eliminating some of the worst eigenvectors, and then transforming back to the original space.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -D
+ * Don't normalize input data.
+ *
+ * -R
+ * Retain enough PC attributes to account
+ * for this proportion of variance in the original data.
+ * (default = 0.95)
+ *
+ * -O
+ * Transform through the PC space and
+ * back to the original space.
+ *
+ * -A
+ * Maximum number of attributes to include in
+ * transformed attribute names. (-1 = include all)
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @author Gabi Schmidberger (gabi@cs.waikato.ac.nz)
+ * @version $Revision: 5987 $
+ */
+public class PrincipalComponents
+ extends UnsupervisedAttributeEvaluator
+ implements AttributeTransformer, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 3310137541055815078L;
+
+ /** The data to transform analyse/transform */
+ private Instances m_trainInstances;
+
+ /** Keep a copy for the class attribute (if set) */
+ private Instances m_trainHeader;
+
+ /** The header for the transformed data format */
+ private Instances m_transformedFormat;
+
+ /** The header for data transformed back to the original space */
+ private Instances m_originalSpaceFormat;
+
+ /** Data has a class set */
+ private boolean m_hasClass;
+
+ /** Class index */
+ private int m_classIndex;
+
+ /** Number of attributes */
+ private int m_numAttribs;
+
+ /** Number of instances */
+ private int m_numInstances;
+
+ /** Correlation matrix for the original data */
+ private double [][] m_correlation;
+
+ /** Will hold the unordered linear transformations of the (normalized)
+ original data */
+ private double [][] m_eigenvectors;
+
+ /** Eigenvalues for the corresponding eigenvectors */
+ private double [] m_eigenvalues = null;
+
+ /** Sorted eigenvalues */
+ private int [] m_sortedEigens;
+
+ /** sum of the eigenvalues */
+ private double m_sumOfEigenValues = 0.0;
+
+ /** Filters for original data */
+ private ReplaceMissingValues m_replaceMissingFilter;
+ private Normalize m_normalizeFilter;
+ private NominalToBinary m_nominalToBinFilter;
+ private Remove m_attributeFilter;
+
+ /** used to remove the class column if a class column is set */
+ private Remove m_attribFilter;
+
+ /** The number of attributes in the pc transformed data */
+ private int m_outputNumAtts = -1;
+
+ /** normalize the input data? */
+ private boolean m_normalize = true;
+
+ /** the amount of varaince to cover in the original data when
+ retaining the best n PC's */
+ private double m_coverVariance = 0.95;
+
+ /** transform the data through the pc space and back to the original
+ space ? */
+ private boolean m_transBackToOriginal = false;
+
+ /** maximum number of attributes in the transformed attribute name */
+ private int m_maxAttrsInName = 5;
+
+ /** holds the transposed eigenvectors for converting back to the
+ original space */
+ private double [][] m_eTranspose;
+
+ /**
+ * Returns a string describing this attribute transformer
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Performs a principal components analysis and transformation of "
+ +"the data. Use in conjunction with a Ranker search. Dimensionality "
+ +"reduction is accomplished by choosing enough eigenvectors to "
+ +"account for some percentage of the variance in the original data---"
+ +"default 0.95 (95%). Attribute noise can be filtered by transforming "
+ +"to the PC space, eliminating some of the worst eigenvectors, and "
+ +"then transforming back to the original space.";
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ *
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(3);
+ newVector.addElement(new Option("\tDon't normalize input data."
+ , "D", 0, "-D"));
+
+ newVector.addElement(new Option("\tRetain enough PC attributes to account "
+ +"\n\tfor this proportion of variance in "
+ +"the original data.\n"
+ + "\t(default = 0.95)",
+ "R",1,"-R"));
+
+ newVector.addElement(new Option("\tTransform through the PC space and "
+ +"\n\tback to the original space."
+ , "O", 0, "-O"));
+
+ newVector.addElement(new Option("\tMaximum number of attributes to include in "
+ + "\n\ttransformed attribute names. (-1 = include all)"
+ , "A", 1, "-A"));
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -D
+ * Don't normalize input data.
+ *
+ * -R
+ * Retain enough PC attributes to account
+ * for this proportion of variance in the original data.
+ * (default = 0.95)
+ *
+ * -O
+ * Transform through the PC space and
+ * back to the original space.
+ *
+ * -A
+ * Maximum number of attributes to include in
+ * transformed attribute names. (-1 = include all)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ resetOptions();
+ String optionString;
+
+ optionString = Utils.getOption('R', options);
+ if (optionString.length() != 0) {
+ Double temp;
+ temp = Double.valueOf(optionString);
+ setVarianceCovered(temp.doubleValue());
+ }
+ optionString = Utils.getOption('A', options);
+ if (optionString.length() != 0) {
+ setMaximumAttributeNames(Integer.parseInt(optionString));
+ }
+ setNormalize(!Utils.getFlag('D', options));
+
+ setTransformBackToOriginal(Utils.getFlag('O', options));
+ }
+
+ /**
+ * Reset to defaults
+ */
+ private void resetOptions() {
+ m_coverVariance = 0.95;
+ m_normalize = true;
+ m_sumOfEigenValues = 0.0;
+ m_transBackToOriginal = false;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String normalizeTipText() {
+ return "Normalize input data.";
+ }
+
+ /**
+ * Set whether input data will be normalized.
+ * @param n true if input data is to be normalized
+ */
+ public void setNormalize(boolean n) {
+ m_normalize = n;
+ }
+
+ /**
+ * Gets whether or not input data is to be normalized
+ * @return true if input data is to be normalized
+ */
+ public boolean getNormalize() {
+ return m_normalize;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String varianceCoveredTipText() {
+ return "Retain enough PC attributes to account for this proportion of "
+ +"variance.";
+ }
+
+ /**
+ * Sets the amount of variance to account for when retaining
+ * principal components
+ * @param vc the proportion of total variance to account for
+ */
+ public void setVarianceCovered(double vc) {
+ m_coverVariance = vc;
+ }
+
+ /**
+ * Gets the proportion of total variance to account for when
+ * retaining principal components
+ * @return the proportion of variance to account for
+ */
+ public double getVarianceCovered() {
+ return m_coverVariance;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String maximumAttributeNamesTipText() {
+ return "The maximum number of attributes to include in transformed attribute names.";
+ }
+
+ /**
+ * Sets maximum number of attributes to include in
+ * transformed attribute names.
+ * @param m the maximum number of attributes
+ */
+ public void setMaximumAttributeNames(int m) {
+ m_maxAttrsInName = m;
+ }
+
+ /**
+ * Gets maximum number of attributes to include in
+ * transformed attribute names.
+ * @return the maximum number of attributes
+ */
+ public int getMaximumAttributeNames() {
+ return m_maxAttrsInName;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String transformBackToOriginalTipText() {
+ return "Transform through the PC space and back to the original space. "
+ +"If only the best n PCs are retained (by setting varianceCovered < 1) "
+ +"then this option will give a dataset in the original space but with "
+ +"less attribute noise.";
+ }
+
+ /**
+ * Sets whether the data should be transformed back to the original
+ * space
+ * @param b true if the data should be transformed back to the
+ * original space
+ */
+ public void setTransformBackToOriginal(boolean b) {
+ m_transBackToOriginal = b;
+ }
+
+ /**
+ * Gets whether the data is to be transformed back to the original
+ * space.
+ * @return true if the data is to be transformed back to the original space
+ */
+ public boolean getTransformBackToOriginal() {
+ return m_transBackToOriginal;
+ }
+
+ /**
+ * Gets the current settings of PrincipalComponents
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+
+ String[] options = new String[6];
+ int current = 0;
+
+ if (!getNormalize()) {
+ options[current++] = "-D";
+ }
+
+ options[current++] = "-R";
+ options[current++] = ""+getVarianceCovered();
+
+ options[current++] = "-A";
+ options[current++] = ""+getMaximumAttributeNames();
+
+ if (getTransformBackToOriginal()) {
+ options[current++] = "-O";
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.NUMERIC_CLASS);
+ result.enable(Capability.DATE_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+ result.enable(Capability.NO_CLASS);
+
+ return result;
+ }
+
+ /**
+ * Initializes principal components and performs the analysis
+ * @param data the instances to analyse/transform
+ * @throws Exception if analysis fails
+ */
+ public void buildEvaluator(Instances data) throws Exception {
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ buildAttributeConstructor(data);
+ }
+
+ private void buildAttributeConstructor (Instances data) throws Exception {
+ m_eigenvalues = null;
+ m_outputNumAtts = -1;
+ m_attributeFilter = null;
+ m_nominalToBinFilter = null;
+ m_sumOfEigenValues = 0.0;
+ m_trainInstances = new Instances(data);
+
+ // make a copy of the training data so that we can get the class
+ // column to append to the transformed data (if necessary)
+ m_trainHeader = new Instances(m_trainInstances, 0);
+
+ m_replaceMissingFilter = new ReplaceMissingValues();
+ m_replaceMissingFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances,
+ m_replaceMissingFilter);
+
+ if (m_normalize) {
+ m_normalizeFilter = new Normalize();
+ m_normalizeFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances, m_normalizeFilter);
+ }
+
+ m_nominalToBinFilter = new NominalToBinary();
+ m_nominalToBinFilter.setInputFormat(m_trainInstances);
+ m_trainInstances = Filter.useFilter(m_trainInstances,
+ m_nominalToBinFilter);
+
+ // delete any attributes with only one distinct value or are all missing
+ Vector deleteCols = new Vector();
+ for (int i=0;i=0) {
+ // get rid of the class column
+ m_hasClass = true;
+ m_classIndex = m_trainInstances.classIndex();
+ deleteCols.addElement(new Integer(m_classIndex));
+ }
+
+ // remove columns from the data if necessary
+ if (deleteCols.size() > 0) {
+ m_attributeFilter = new Remove();
+ int [] todelete = new int [deleteCols.size()];
+ for (int i=0;i (m_numAttribs - numVectors - 1); i--) {
+ for (int j = 0; j < m_numAttribs; j++) {
+ orderedVectors[j][m_numAttribs - i] =
+ m_eigenvectors[j][m_sortedEigens[i]];
+ }
+ }
+
+ // transpose the matrix
+ int nr = orderedVectors.length;
+ int nc = orderedVectors[0].length;
+ m_eTranspose =
+ new double [nc][nr];
+ for (int i = 0; i < nc; i++) {
+ for (int j = 0; j < nr; j++) {
+ m_eTranspose[i][j] = orderedVectors[j][i];
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns just the header for the transformed data (ie. an empty
+ * set of instances. This is so that AttributeSelection can
+ * determine the structure of the transformed data without actually
+ * having to get all the transformed data through transformedData().
+ * @return the header of the transformed data.
+ * @throws Exception if the header of the transformed data can't
+ * be determined.
+ */
+ public Instances transformedHeader() throws Exception {
+ if (m_eigenvalues == null) {
+ throw new Exception("Principal components hasn't been built yet");
+ }
+ if (m_transBackToOriginal) {
+ return m_originalSpaceFormat;
+ } else {
+ return m_transformedFormat;
+ }
+ }
+
+ /**
+ * Gets the transformed training data.
+ * @return the transformed training data
+ * @throws Exception if transformed data can't be returned
+ */
+ public Instances transformedData(Instances data) throws Exception {
+ if (m_eigenvalues == null) {
+ throw new Exception("Principal components hasn't been built yet");
+ }
+
+ Instances output = null;
+
+ if (m_transBackToOriginal) {
+ output = new Instances(m_originalSpaceFormat);
+ } else {
+ output = new Instances(m_transformedFormat);
+ }
+ for (int i = 0; i < data.numInstances(); i++) {
+ Instance converted = convertInstance(data.instance(i));
+ output.add(converted);
+ }
+
+ return output;
+ }
+
+ /**
+ * Evaluates the merit of a transformed attribute. This is defined
+ * to be 1 minus the cumulative variance explained. Merit can't
+ * be meaningfully evaluated if the data is to be transformed back
+ * to the original space.
+ * @param att the attribute to be evaluated
+ * @return the merit of a transformed attribute
+ * @throws Exception if attribute can't be evaluated
+ */
+ public double evaluateAttribute(int att) throws Exception {
+ if (m_eigenvalues == null) {
+ throw new Exception("Principal components hasn't been built yet!");
+ }
+
+ if (m_transBackToOriginal) {
+ return 1.0; // can't evaluate back in the original space!
+ }
+
+ // return 1-cumulative variance explained for this transformed att
+ double cumulative = 0.0;
+ for (int i = m_numAttribs - 1; i >= m_numAttribs - att - 1; i--) {
+ cumulative += m_eigenvalues[m_sortedEigens[i]];
+ }
+
+ return 1.0 - cumulative / m_sumOfEigenValues;
+ }
+
+ /**
+ * Fill the correlation matrix
+ */
+ private void fillCorrelation() {
+ m_correlation = new double[m_numAttribs][m_numAttribs];
+ double [] att1 = new double [m_numInstances];
+ double [] att2 = new double [m_numInstances];
+ double corr;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ for (int j = 0; j < m_numAttribs; j++) {
+ if (i == j) {
+ m_correlation[i][j] = 1.0;
+ } else {
+ for (int k = 0; k < m_numInstances; k++) {
+ att1[k] = m_trainInstances.instance(k).value(i);
+ att2[k] = m_trainInstances.instance(k).value(j);
+ }
+ corr = Utils.correlation(att1,att2,m_numInstances);
+ m_correlation[i][j] = corr;
+ m_correlation[j][i] = corr;
+ }
+ }
+ }
+ }
+
+ /**
+ * Return a summary of the analysis
+ * @return a summary of the analysis.
+ */
+ private String principalComponentsSummary() {
+ StringBuffer result = new StringBuffer();
+ double cumulative = 0.0;
+ Instances output = null;
+ int numVectors=0;
+
+ try {
+ output = setOutputFormat();
+ numVectors = (output.classIndex() < 0)
+ ? output.numAttributes()
+ : output.numAttributes()-1;
+ } catch (Exception ex) {
+ }
+ //tomorrow
+ result.append("Correlation matrix\n"+matrixToString(m_correlation)
+ +"\n\n");
+ result.append("eigenvalue\tproportion\tcumulative\n");
+ for (int i = m_numAttribs - 1; i > (m_numAttribs - numVectors - 1); i--) {
+ cumulative+=m_eigenvalues[m_sortedEigens[i]];
+ result.append(Utils.doubleToString(m_eigenvalues[m_sortedEigens[i]],9,5)
+ +"\t"+Utils.
+ doubleToString((m_eigenvalues[m_sortedEigens[i]] /
+ m_sumOfEigenValues),
+ 9,5)
+ +"\t"+Utils.doubleToString((cumulative /
+ m_sumOfEigenValues),9,5)
+ +"\t"+output.attribute(m_numAttribs - i - 1).name()+"\n");
+ }
+
+ result.append("\nEigenvectors\n");
+ for (int j = 1;j <= numVectors;j++) {
+ result.append(" V"+j+'\t');
+ }
+ result.append("\n");
+ for (int j = 0; j < m_numAttribs; j++) {
+
+ for (int i = m_numAttribs - 1; i > (m_numAttribs - numVectors - 1); i--) {
+ result.append(Utils.
+ doubleToString(m_eigenvectors[j][m_sortedEigens[i]],7,4)
+ +"\t");
+ }
+ result.append(m_trainInstances.attribute(j).name()+'\n');
+ }
+
+ if (m_transBackToOriginal) {
+ result.append("\nPC space transformed back to original space.\n"
+ +"(Note: can't evaluate attributes in the original "
+ +"space)\n");
+ }
+ return result.toString();
+ }
+
+ /**
+ * Returns a description of this attribute transformer
+ * @return a String describing this attribute transformer
+ */
+ public String toString() {
+ if (m_eigenvalues == null) {
+ return "Principal components hasn't been built yet!";
+ } else {
+ return "\tPrincipal Components Attribute Transformer\n\n"
+ +principalComponentsSummary();
+ }
+ }
+
+ /**
+ * Return a matrix as a String
+ * @param matrix that is decribed as a string
+ * @return a String describing a matrix
+ */
+ private String matrixToString(double [][] matrix) {
+ StringBuffer result = new StringBuffer();
+ int last = matrix.length - 1;
+
+ for (int i = 0; i <= last; i++) {
+ for (int j = 0; j <= last; j++) {
+ result.append(Utils.doubleToString(matrix[i][j],6,2)+" ");
+ if (j == last) {
+ result.append('\n');
+ }
+ }
+ }
+ return result.toString();
+ }
+
+ /**
+ * Convert a pc transformed instance back to the original space
+ *
+ * @param inst the instance to convert
+ * @return the processed instance
+ * @throws Exception if something goes wrong
+ */
+ private Instance convertInstanceToOriginal(Instance inst)
+ throws Exception {
+ double[] newVals = null;
+
+ if (m_hasClass) {
+ newVals = new double[m_numAttribs+1];
+ } else {
+ newVals = new double[m_numAttribs];
+ }
+
+ if (m_hasClass) {
+ // class is always appended as the last attribute
+ newVals[m_numAttribs] = inst.value(inst.numAttributes() - 1);
+ }
+
+ for (int i = 0; i < m_eTranspose[0].length; i++) {
+ double tempval = 0.0;
+ for (int j = 1; j < m_eTranspose.length; j++) {
+ tempval += (m_eTranspose[j][i] *
+ inst.value(j - 1));
+ }
+ newVals[i] = tempval;
+ }
+
+ if (inst instanceof SparseInstance) {
+ return new SparseInstance(inst.weight(), newVals);
+ } else {
+ return new DenseInstance(inst.weight(), newVals);
+ }
+ }
+
+ /**
+ * Transform an instance in original (unormalized) format. Convert back
+ * to the original space if requested.
+ * @param instance an instance in the original (unormalized) format
+ * @return a transformed instance
+ * @throws Exception if instance cant be transformed
+ */
+ public Instance convertInstance(Instance instance) throws Exception {
+
+ if (m_eigenvalues == null) {
+ throw new Exception("convertInstance: Principal components not "
+ +"built yet");
+ }
+
+ double[] newVals = new double[m_outputNumAtts];
+ Instance tempInst = (Instance)instance.copy();
+ if (!instance.dataset().equalHeaders(m_trainHeader)) {
+ throw new Exception("Can't convert instance: header's don't match: "
+ +"PrincipalComponents\n"
+ + instance.dataset().equalHeadersMsg(m_trainHeader));
+ }
+
+ m_replaceMissingFilter.input(tempInst);
+ m_replaceMissingFilter.batchFinished();
+ tempInst = m_replaceMissingFilter.output();
+
+ if (m_normalize) {
+ m_normalizeFilter.input(tempInst);
+ m_normalizeFilter.batchFinished();
+ tempInst = m_normalizeFilter.output();
+ }
+
+ m_nominalToBinFilter.input(tempInst);
+ m_nominalToBinFilter.batchFinished();
+ tempInst = m_nominalToBinFilter.output();
+
+ if (m_attributeFilter != null) {
+ m_attributeFilter.input(tempInst);
+ m_attributeFilter.batchFinished();
+ tempInst = m_attributeFilter.output();
+ }
+
+ if (m_hasClass) {
+ newVals[m_outputNumAtts - 1] = instance.value(instance.classIndex());
+ }
+
+ double cumulative = 0;
+ for (int i = m_numAttribs - 1; i >= 0; i--) {
+ double tempval = 0.0;
+ for (int j = 0; j < m_numAttribs; j++) {
+ tempval += (m_eigenvectors[j][m_sortedEigens[i]] *
+ tempInst.value(j));
+ }
+ newVals[m_numAttribs - i - 1] = tempval;
+ cumulative+=m_eigenvalues[m_sortedEigens[i]];
+ if ((cumulative / m_sumOfEigenValues) >= m_coverVariance) {
+ break;
+ }
+ }
+
+ if (!m_transBackToOriginal) {
+ if (instance instanceof SparseInstance) {
+ return new SparseInstance(instance.weight(), newVals);
+ } else {
+ return new DenseInstance(instance.weight(), newVals);
+ }
+ } else {
+ if (instance instanceof SparseInstance) {
+ return convertInstanceToOriginal(new SparseInstance(instance.weight(),
+ newVals));
+ } else {
+ return convertInstanceToOriginal(new DenseInstance(instance.weight(),
+ newVals));
+ }
+ }
+ }
+
+ /**
+ * Set up the header for the PC->original space dataset
+ *
+ * @return the output format
+ * @throws Exception if something goes wrong
+ */
+ private Instances setOutputFormatOriginal() throws Exception {
+ FastVector attributes = new FastVector();
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ String att = m_trainInstances.attribute(i).name();
+ attributes.addElement(new Attribute(att));
+ }
+
+ if (m_hasClass) {
+ attributes.addElement(m_trainHeader.classAttribute().copy());
+ }
+
+ Instances outputFormat =
+ new Instances(m_trainHeader.relationName()+"->PC->original space",
+ attributes, 0);
+
+ // set the class to be the last attribute if necessary
+ if (m_hasClass) {
+ outputFormat.setClassIndex(outputFormat.numAttributes()-1);
+ }
+
+ return outputFormat;
+ }
+
+ /**
+ * Set the format for the transformed data
+ * @return a set of empty Instances (header only) in the new format
+ * @throws Exception if the output format can't be set
+ */
+ private Instances setOutputFormat() throws Exception {
+ if (m_eigenvalues == null) {
+ return null;
+ }
+
+ double cumulative = 0.0;
+ FastVector attributes = new FastVector();
+ for (int i = m_numAttribs - 1; i >= 0; i--) {
+ StringBuffer attName = new StringBuffer();
+ // build array of coefficients
+ double[] coeff_mags = new double[m_numAttribs];
+ for (int j = 0; j < m_numAttribs; j++)
+ coeff_mags[j] = -Math.abs(m_eigenvectors[j][m_sortedEigens[i]]);
+ int num_attrs = (m_maxAttrsInName > 0) ? Math.min(m_numAttribs, m_maxAttrsInName) : m_numAttribs;
+ // this array contains the sorted indices of the coefficients
+ int[] coeff_inds;
+ if (m_numAttribs > 0) {
+ // if m_maxAttrsInName > 0, sort coefficients by decreasing magnitude
+ coeff_inds = Utils.sort(coeff_mags);
+ } else {
+ // if m_maxAttrsInName <= 0, use all coeffs in original order
+ coeff_inds = new int[m_numAttribs];
+ for (int j=0; j 0 && coeff_value >= 0)
+ attName.append("+");
+ attName.append(Utils.doubleToString(coeff_value,5,3)
+ +m_trainInstances.attribute(coeff_inds[j]).name());
+ }
+ if (num_attrs < m_numAttribs)
+ attName.append("...");
+
+ attributes.addElement(new Attribute(attName.toString()));
+ cumulative+=m_eigenvalues[m_sortedEigens[i]];
+
+ if ((cumulative / m_sumOfEigenValues) >= m_coverVariance) {
+ break;
+ }
+ }
+
+ if (m_hasClass) {
+ attributes.addElement(m_trainHeader.classAttribute().copy());
+ }
+
+ Instances outputFormat =
+ new Instances(m_trainInstances.relationName()+"_principal components",
+ attributes, 0);
+
+ // set the class to be the last attribute if necessary
+ if (m_hasClass) {
+ outputFormat.setClassIndex(outputFormat.numAttributes()-1);
+ }
+
+ m_outputNumAtts = outputFormat.numAttributes();
+ return outputFormat;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5987 $");
+ }
+
+ /**
+ * Main method for testing this class
+ * @param argv should contain the command line arguments to the
+ * evaluator/transformer (see AttributeSelection)
+ */
+ public static void main(String [] argv) {
+ runEvaluator(new PrincipalComponents(), argv);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/RaceSearch.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/RaceSearch.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/RaceSearch.java (revision 29)
@@ -0,0 +1,1779 @@
+/*
+ * 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.
+ */
+
+/*
+ * RaceSearch.java
+ * Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SelectedTag;
+import weka.core.Statistics;
+import weka.core.Tag;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformation.Type;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.experiment.PairedStats;
+import weka.experiment.Stats;
+
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+
+ * Races the cross validation error of competing attribute subsets. Use in conjuction with a ClassifierSubsetEval. RaceSearch has four modes:
+ *
+ * forward selection races all single attribute additions to a base set (initially no attributes), selects the winner to become the new base set and then iterates until there is no improvement over the base set.
+ *
+ * Backward elimination is similar but the initial base set has all attributes included and races all single attribute deletions.
+ *
+ * Schemata search is a bit different. Each iteration a series of races are run in parallel. Each race in a set determines whether a particular attribute should be included or not---ie the race is between the attribute being "in" or "out". The other attributes for this race are included or excluded randomly at each point in the evaluation. As soon as one race has a clear winner (ie it has been decided whether a particular attribute should be inor not) then the next set of races begins, using the result of the winning race from the previous iteration as new base set.
+ *
+ * Rank race first ranks the attributes using an attribute evaluator and then races the ranking. The race includes no attributes, the top ranked attribute, the top two attributes, the top three attributes, etc.
+ *
+ * It is also possible to generate a raked list of attributes through the forward racing process. If generateRanking is set to true then a complete forward race will be run---that is, racing continues until all attributes have been selected. The order that they are added in determines a complete ranking of all the attributes.
+ *
+ * Racing uses paired and unpaired t-tests on cross-validation errors of competing subsets. When there is a significant difference between the means of the errors of two competing subsets then the poorer of the two can be eliminated from the race. Similarly, if there is no significant difference between the mean errors of two competing subsets and they are within some threshold of each other, then one can be eliminated from the race.
+ *
+ * For more information see:
+ *
+ * Andrew W. Moore, Mary S. Lee: Efficient Algorithms for Minimizing Cross Validation Error. In: Eleventh International Conference on Machine Learning, 190-198, 1994.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @inproceedings{Moore1994,
+ * author = {Andrew W. Moore and Mary S. Lee},
+ * booktitle = {Eleventh International Conference on Machine Learning},
+ * pages = {190-198},
+ * publisher = {Morgan Kaufmann},
+ * title = {Efficient Algorithms for Minimizing Cross Validation Error},
+ * year = {1994}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -R <0 = forward | 1 = backward race | 2 = schemata | 3 = rank>
+ * Type of race to perform.
+ * (default = 0).
+ *
+ * -L <significance>
+ * Significance level for comaparisons
+ * (default = 0.001(forward/backward/rank)/0.01(schemata)).
+ *
+ * -T <threshold>
+ * Threshold for error comparison.
+ * (default = 0.001).
+ *
+ * -A <attribute evaluator>
+ * Attribute ranker to use if doing a
+ * rank search. Place any
+ * evaluator options LAST on
+ * the command line following a "--".
+ * eg. -A weka.attributeSelection.GainRatioAttributeEval ... -- -M.
+ * (default = GainRatioAttributeEval)
+ *
+ * -F <0 = 10 fold | 1 = leave-one-out>
+ * Folds for cross validation
+ * (default = 0 (1 if schemata race)
+ *
+ * -Q
+ * Generate a ranked list of attributes.
+ * Forces the search to be forward
+ * and races until all attributes have
+ * selected, thus producing a ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to retain from
+ * the ranking. Overides -T. Use in conjunction with -Q
+ *
+ * -J <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ * Use in conjuction with -Q
+ *
+ * -Z
+ * Verbose output for monitoring the search.
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.GainRatioAttributeEval:
+ *
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.26 $
+ */
+public class RaceSearch
+ extends ASSearch
+ implements RankedOutputSearch, OptionHandler, TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 4015453851212985720L;
+
+ /** the training instances */
+ private Instances m_Instances = null;
+
+ /** search types */
+ private static final int FORWARD_RACE = 0;
+ private static final int BACKWARD_RACE = 1;
+ private static final int SCHEMATA_RACE = 2;
+ private static final int RANK_RACE = 3;
+ public static final Tag [] TAGS_SELECTION = {
+ new Tag(FORWARD_RACE, "Forward selection race"),
+ new Tag(BACKWARD_RACE, "Backward elimination race"),
+ new Tag(SCHEMATA_RACE, "Schemata race"),
+ new Tag(RANK_RACE, "Rank race")
+ };
+
+ /** the selected search type */
+ private int m_raceType = FORWARD_RACE;
+
+ /** xval types */
+ private static final int TEN_FOLD = 0;
+ private static final int LEAVE_ONE_OUT = 1;
+ public static final Tag [] XVALTAGS_SELECTION = {
+ new Tag(TEN_FOLD, "10 Fold"),
+ new Tag(LEAVE_ONE_OUT, "Leave-one-out"),
+ };
+
+ /** the selected xval type */
+ private int m_xvalType = TEN_FOLD;
+
+ /** the class index */
+ private int m_classIndex;
+
+ /** the number of attributes in the data */
+ private int m_numAttribs;
+
+ /** the total number of partially/fully evaluated subsets */
+ private int m_totalEvals;
+
+ /** holds the merit of the best subset found */
+ private double m_bestMerit = -Double.MAX_VALUE;
+
+ /** the subset evaluator to use */
+ private HoldOutSubsetEvaluator m_theEvaluator = null;
+
+ /** the significance level for comparisons */
+ private double m_sigLevel = 0.001;
+
+ /** threshold for comparisons */
+ private double m_delta = 0.001;
+
+ /** the number of samples above which to begin testing for similarity
+ between competing subsets */
+ private int m_samples = 20;
+
+ /** number of cross validation folds---equal to the number of instances
+ for leave-one-out cv */
+ private int m_numFolds = 10;
+
+ /** the attribute evaluator to generate the initial ranking when
+ doing a rank race */
+ private ASEvaluation m_ASEval = new GainRatioAttributeEval();
+
+ /** will hold the attribute ranking produced by the above attribute
+ evaluator if doing a rank search */
+ private int [] m_Ranking;
+
+ /** verbose output for monitoring the search and debugging */
+ private boolean m_debug = false;
+
+ /** If true then produce a ranked list of attributes by fully traversing
+ a forward hillclimb race */
+ private boolean m_rankingRequested = false;
+
+ /** The ranked list of attributes produced if m_rankingRequested is true */
+ private double [][] m_rankedAtts;
+
+ /** The number of attributes ranked so far (if ranking is requested) */
+ private int m_rankedSoFar;
+
+ /** The number of attributes to retain if a ranking is requested. -1
+ indicates that all attributes are to be retained. Has precedence over
+ m_threshold */
+ private int m_numToSelect = -1;
+
+ private int m_calculatedNumToSelect = -1;
+
+ /** the threshold for removing attributes if ranking is requested */
+ private double m_threshold = -Double.MAX_VALUE;
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search method suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Races the cross validation error of competing "
+ +"attribute subsets. Use in conjuction with a ClassifierSubsetEval. "
+ +"RaceSearch has four modes:\n\nforward selection "
+ +"races all single attribute additions to a base set (initially "
+ +" no attributes), selects the winner to become the new base set "
+ +"and then iterates until there is no improvement over the base set. "
+ +"\n\nBackward elimination is similar but the initial base set has all "
+ +"attributes included and races all single attribute deletions. "
+ +"\n\nSchemata search is a bit different. Each iteration a series of "
+ +"races are run in parallel. Each race in a set determines whether "
+ +"a particular attribute should be included or not---ie the race is "
+ +"between the attribute being \"in\" or \"out\". The other attributes "
+ +"for this race are included or excluded randomly at each point in the "
+ +"evaluation. As soon as one race "
+ +"has a clear winner (ie it has been decided whether a particular "
+ +"attribute should be inor not) then the next set of races begins, "
+ +"using the result of the winning race from the previous iteration as "
+ +"new base set.\n\nRank race first ranks the attributes using an "
+ +"attribute evaluator and then races the ranking. The race includes "
+ +"no attributes, the top ranked attribute, the top two attributes, the "
+ +"top three attributes, etc.\n\nIt is also possible to generate a "
+ +"raked list of attributes through the forward racing process. "
+ +"If generateRanking is set to true then a complete forward race will "
+ +"be run---that is, racing continues until all attributes have been "
+ +"selected. The order that they are added in determines a complete "
+ +"ranking of all the attributes.\n\nRacing uses paired and unpaired "
+ +"t-tests on cross-validation errors of competing subsets. When there "
+ +"is a significant difference between the means of the errors of two "
+ +"competing subsets then the poorer of the two can be eliminated from "
+ +"the race. Similarly, if there is no significant difference between "
+ +"the mean errors of two competing subsets and they are within some "
+ +"threshold of each other, then one can be eliminated from the race.\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.INPROCEEDINGS);
+ result.setValue(Field.AUTHOR, "Andrew W. Moore and Mary S. Lee");
+ result.setValue(Field.TITLE, "Efficient Algorithms for Minimizing Cross Validation Error");
+ result.setValue(Field.BOOKTITLE, "Eleventh International Conference on Machine Learning");
+ result.setValue(Field.YEAR, "1994");
+ result.setValue(Field.PAGES, "190-198");
+ result.setValue(Field.PUBLISHER, "Morgan Kaufmann");
+
+ return result;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String raceTypeTipText() {
+ return "Set the type of search.";
+ }
+
+ /**
+ * Set the race type
+ *
+ * @param d the type of race
+ */
+ public void setRaceType (SelectedTag d) {
+
+ if (d.getTags() == TAGS_SELECTION) {
+ m_raceType = d.getSelectedTag().getID();
+ }
+ if (m_raceType == SCHEMATA_RACE && !m_rankingRequested) {
+ try {
+ setFoldsType(new SelectedTag(LEAVE_ONE_OUT,
+ XVALTAGS_SELECTION));
+ setSignificanceLevel(0.01);
+ } catch (Exception ex) {
+ }
+ } else {
+ try {
+ setFoldsType(new SelectedTag(TEN_FOLD,
+ XVALTAGS_SELECTION));
+ setSignificanceLevel(0.001);
+ } catch (Exception ex) {
+ }
+ }
+ }
+
+ /**
+ * Get the race type
+ *
+ * @return the type of race
+ */
+ public SelectedTag getRaceType() {
+ return new SelectedTag(m_raceType, TAGS_SELECTION);
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String significanceLevelTipText() {
+ return "Set the significance level to use for t-test comparisons.";
+ }
+
+ /**
+ * Sets the significance level to use
+ * @param sig the significance level
+ */
+ public void setSignificanceLevel(double sig) {
+ m_sigLevel = sig;
+ }
+
+ /**
+ * Get the significance level
+ * @return the current significance level
+ */
+ public double getSignificanceLevel() {
+ return m_sigLevel;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String thresholdTipText() {
+ return "Set the error threshold by which to consider two subsets "
+ +"equivalent.";
+ }
+
+ /**
+ * Sets the threshold for comparisons
+ * @param t the threshold to use
+ */
+ public void setThreshold(double t) {
+ m_delta = t;
+ }
+
+ /**
+ * Get the threshold
+ * @return the current threshold
+ */
+ public double getThreshold() {
+ return m_delta;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String foldsTypeTipText() {
+ return "Set the number of folds to use for x-val error estimation; "
+ +"leave-one-out is selected automatically for schemata search.";
+ }
+
+ /**
+ * Set the xfold type
+ *
+ * @param d the type of xval
+ */
+ public void setFoldsType (SelectedTag d) {
+
+ if (d.getTags() == XVALTAGS_SELECTION) {
+ m_xvalType = d.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Get the xfold type
+ *
+ * @return the type of xval
+ */
+ public SelectedTag getFoldsType () {
+ return new SelectedTag(m_xvalType, XVALTAGS_SELECTION);
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String debugTipText() {
+ return "Turn on verbose output for monitoring the search's progress.";
+ }
+
+ /**
+ * Set whether verbose output should be generated.
+ * @param d true if output is to be verbose.
+ */
+ public void setDebug(boolean d) {
+ m_debug = d;
+ }
+
+ /**
+ * Get whether output is to be verbose
+ * @return true if output will be verbose
+ */
+ public boolean getDebug() {
+ return m_debug;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String attributeEvaluatorTipText() {
+ return "Attribute evaluator to use for generating an initial ranking. "
+ +"Use in conjunction with a rank race";
+ }
+
+ /**
+ * Set the attribute evaluator to use for generating the ranking.
+ * @param newEvaluator the attribute evaluator to use.
+ */
+ public void setAttributeEvaluator(ASEvaluation newEvaluator) {
+ m_ASEval = newEvaluator;
+ }
+
+ /**
+ * Get the attribute evaluator used to generate the ranking.
+ * @return the evaluator used to generate the ranking.
+ */
+ public ASEvaluation getAttributeEvaluator() {
+ return m_ASEval;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String generateRankingTipText() {
+ return "Use the racing process to generate a ranked list of attributes. "
+ +"Using this mode forces the race to be a forward type and then races "
+ +"until all attributes have been added, thus giving a ranked list";
+ }
+
+ /**
+ * Records whether the user has requested a ranked list of attributes.
+ * @param doRank true if ranking is requested
+ */
+ public void setGenerateRanking(boolean doRank) {
+ m_rankingRequested = doRank;
+ if (m_rankingRequested) {
+ try {
+ setRaceType(new SelectedTag(FORWARD_RACE,
+ TAGS_SELECTION));
+ } catch (Exception ex) {
+ }
+ }
+ }
+
+ /**
+ * Gets whether ranking has been requested. This is used by the
+ * AttributeSelection module to determine if rankedAttributes()
+ * should be called.
+ * @return true if ranking has been requested.
+ */
+ public boolean getGenerateRanking() {
+ return m_rankingRequested;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String numToSelectTipText() {
+ return "Specify the number of attributes to retain. Use in conjunction "
+ +"with generateRanking. The default value "
+ +"(-1) indicates that all attributes are to be retained. Use either "
+ +"this option or a threshold to reduce the attribute set.";
+ }
+
+ /**
+ * Specify the number of attributes to select from the ranked list
+ * (if generating a ranking). -1
+ * indicates that all attributes are to be retained.
+ * @param n the number of attributes to retain
+ */
+ public void setNumToSelect(int n) {
+ m_numToSelect = n;
+ }
+
+ /**
+ * Gets the number of attributes to be retained.
+ * @return the number of attributes to retain
+ */
+ public int getNumToSelect() {
+ return m_numToSelect;
+ }
+
+ /**
+ * Gets the calculated number of attributes to retain. This is the
+ * actual number of attributes to retain. This is the same as
+ * getNumToSelect if the user specifies a number which is not less
+ * than zero. Otherwise it should be the number of attributes in the
+ * (potentially transformed) data.
+ */
+ public int getCalculatedNumToSelect() {
+ if (m_numToSelect >= 0) {
+ m_calculatedNumToSelect = m_numToSelect;
+ }
+ return m_calculatedNumToSelect;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String selectionThresholdTipText() {
+ return "Set threshold by which attributes can be discarded. Default value "
+ + "results in no attributes being discarded. Use in conjunction with "
+ + "generateRanking";
+ }
+
+ /**
+ * Set the threshold by which the AttributeSelection module can discard
+ * attributes.
+ * @param threshold the threshold.
+ */
+ public void setSelectionThreshold(double threshold) {
+ m_threshold = threshold;
+ }
+
+ /**
+ * Returns the threshold so that the AttributeSelection module can
+ * discard attributes from the ranking.
+ */
+ public double getSelectionThreshold() {
+ return m_threshold;
+ }
+
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector();
+
+ newVector.addElement(new Option(
+ "\tType of race to perform.\n"
+ + "\t(default = 0).",
+ "R", 1 ,"-R <0 = forward | 1 = backward race | 2 = schemata | 3 = rank>"));
+
+ newVector.addElement(new Option(
+ "\tSignificance level for comaparisons\n"
+ + "\t(default = 0.001(forward/backward/rank)/0.01(schemata)).",
+ "L",1,"-L "));
+
+ newVector.addElement(new Option(
+ "\tThreshold for error comparison.\n"
+ + "\t(default = 0.001).",
+ "T",1,"-T "));
+
+ newVector.addElement(new Option(
+ "\tAttribute ranker to use if doing a \n"
+ + "\trank search. Place any\n"
+ + "\tevaluator options LAST on \n"
+ + "\tthe command line following a \"--\".\n"
+ + "\teg. -A weka.attributeSelection.GainRatioAttributeEval ... -- -M.\n"
+ + "\t(default = GainRatioAttributeEval)",
+ "A", 1, "-A "));
+
+ newVector.addElement(new Option(
+ "\tFolds for cross validation\n"
+ + "\t(default = 0 (1 if schemata race)",
+ "F",1,"-F <0 = 10 fold | 1 = leave-one-out>"));
+
+ newVector.addElement(new Option(
+ "\tGenerate a ranked list of attributes.\n"
+ +"\tForces the search to be forward\n"
+ +"\tand races until all attributes have\n"
+ +"\tselected, thus producing a ranking.",
+ "Q",0,"-Q"));
+
+ newVector.addElement(new Option(
+ "\tSpecify number of attributes to retain from \n"
+ + "\tthe ranking. Overides -T. Use in conjunction with -Q",
+ "N", 1, "-N "));
+
+ newVector.addElement(new Option(
+ "\tSpecify a theshold by which attributes\n"
+ + "\tmay be discarded from the ranking.\n"
+ +"\tUse in conjuction with -Q",
+ "J",1, "-J "));
+
+ newVector.addElement(new Option(
+ "\tVerbose output for monitoring the search.",
+ "Z",0,"-Z"));
+
+ if ((m_ASEval != null) &&
+ (m_ASEval instanceof OptionHandler)) {
+ newVector.addElement(new Option(
+ "",
+ "", 0, "\nOptions specific to evaluator "
+ + m_ASEval.getClass().getName() + ":"));
+
+ Enumeration enu = ((OptionHandler)m_ASEval).listOptions();
+ while (enu.hasMoreElements()) {
+ newVector.addElement(enu.nextElement());
+ }
+ }
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -R <0 = forward | 1 = backward race | 2 = schemata | 3 = rank>
+ * Type of race to perform.
+ * (default = 0).
+ *
+ * -L <significance>
+ * Significance level for comaparisons
+ * (default = 0.001(forward/backward/rank)/0.01(schemata)).
+ *
+ * -T <threshold>
+ * Threshold for error comparison.
+ * (default = 0.001).
+ *
+ * -A <attribute evaluator>
+ * Attribute ranker to use if doing a
+ * rank search. Place any
+ * evaluator options LAST on
+ * the command line following a "--".
+ * eg. -A weka.attributeSelection.GainRatioAttributeEval ... -- -M.
+ * (default = GainRatioAttributeEval)
+ *
+ * -F <0 = 10 fold | 1 = leave-one-out>
+ * Folds for cross validation
+ * (default = 0 (1 if schemata race)
+ *
+ * -Q
+ * Generate a ranked list of attributes.
+ * Forces the search to be forward
+ * and races until all attributes have
+ * selected, thus producing a ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to retain from
+ * the ranking. Overides -T. Use in conjunction with -Q
+ *
+ * -J <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ * Use in conjuction with -Q
+ *
+ * -Z
+ * Verbose output for monitoring the search.
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.GainRatioAttributeEval:
+ *
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('R', options);
+ if (optionString.length() != 0) {
+ setRaceType(new SelectedTag(Integer.parseInt(optionString),
+ TAGS_SELECTION));
+ }
+
+ optionString = Utils.getOption('F', options);
+ if (optionString.length() != 0) {
+ setFoldsType(new SelectedTag(Integer.parseInt(optionString),
+ XVALTAGS_SELECTION));
+ }
+
+ optionString = Utils.getOption('L', options);
+ if (optionString.length() !=0) {
+ setSignificanceLevel(Double.parseDouble(optionString));
+ }
+
+ optionString = Utils.getOption('T', options);
+ if (optionString.length() !=0) {
+ setThreshold(Double.parseDouble(optionString));
+ }
+
+ optionString = Utils.getOption('A', options);
+ if (optionString.length() != 0) {
+ setAttributeEvaluator(ASEvaluation.forName(optionString,
+ Utils.partitionOptions(options)));
+ }
+
+ setGenerateRanking(Utils.getFlag('Q', options));
+
+ optionString = Utils.getOption('J', options);
+ if (optionString.length() != 0) {
+ setSelectionThreshold(Double.parseDouble(optionString));
+ }
+
+ optionString = Utils.getOption('N', options);
+ if (optionString.length() != 0) {
+ setNumToSelect(Integer.parseInt(optionString));
+ }
+
+ setDebug(Utils.getFlag('Z', options));
+ }
+
+ /**
+ * Gets the current settings of BestFirst.
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ int current = 0;
+ String[] evaluatorOptions = new String[0];
+
+ if ((m_ASEval != null) &&
+ (m_ASEval instanceof OptionHandler)) {
+ evaluatorOptions = ((OptionHandler)m_ASEval).getOptions();
+ }
+ String[] options = new String[17+evaluatorOptions.length];
+
+ options[current++] = "-R"; options[current++] = ""+m_raceType;
+ options[current++] = "-L"; options[current++] = ""+getSignificanceLevel();
+ options[current++] = "-T"; options[current++] = ""+getThreshold();
+ options[current++] = "-F"; options[current++] = ""+m_xvalType;
+ if (getGenerateRanking()) {
+ options[current++] = "-Q";
+ }
+ options[current++] = "-N"; options[current++] = ""+getNumToSelect();
+ options[current++] = "-J"; options[current++] = ""+getSelectionThreshold();
+ if (getDebug()) {
+ options[current++] = "-Z";
+ }
+
+ if (getAttributeEvaluator() != null) {
+ options[current++] = "-A";
+ options[current++] = getAttributeEvaluator().getClass().getName();
+ options[current++] = "--";
+ System.arraycopy(evaluatorOptions, 0, options, current,
+ evaluatorOptions.length);
+ current += evaluatorOptions.length;
+ }
+
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+
+
+
+ /**
+ * Searches the attribute subset space by racing cross validation
+ * errors of competing subsets
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator! (RaceSearch)");
+ }
+
+ if (ASEval instanceof UnsupervisedSubsetEvaluator) {
+ throw new Exception("Can't use an unsupervised subset evaluator "
+ +"(RaceSearch).");
+ }
+
+ if (!(ASEval instanceof HoldOutSubsetEvaluator)) {
+ throw new Exception("Must use a HoldOutSubsetEvaluator, eg. "
+ +"weka.attributeSelection.ClassifierSubsetEval "
+ +"(RaceSearch)");
+ }
+
+ if (!(ASEval instanceof ErrorBasedMeritEvaluator)) {
+ throw new Exception("Only error based subset evaluators can be used, "
+ +"eg. weka.attributeSelection.ClassifierSubsetEval "
+ +"(RaceSearch)");
+ }
+
+ m_Instances = new Instances(data);
+ m_Instances.deleteWithMissingClass();
+ if (m_Instances.numInstances() == 0) {
+ throw new Exception("All train instances have missing class! (RaceSearch)");
+ }
+ if (m_rankingRequested && m_numToSelect > m_Instances.numAttributes()-1) {
+ throw new Exception("More attributes requested than exist in the data "
+ +"(RaceSearch).");
+ }
+ m_theEvaluator = (HoldOutSubsetEvaluator)ASEval;
+ m_numAttribs = m_Instances.numAttributes();
+ m_classIndex = m_Instances.classIndex();
+
+ if (m_rankingRequested) {
+ m_rankedAtts = new double[m_numAttribs-1][2];
+ m_rankedSoFar = 0;
+ }
+
+ if (m_xvalType == LEAVE_ONE_OUT) {
+ m_numFolds = m_Instances.numInstances();
+ } else {
+ m_numFolds = 10;
+ }
+
+ Random random = new Random(1); // I guess this should really be a parameter?
+ m_Instances.randomize(random);
+ int [] bestSubset=null;
+
+ switch (m_raceType) {
+ case FORWARD_RACE:
+ case BACKWARD_RACE:
+ bestSubset = hillclimbRace(m_Instances, random);
+ break;
+ case SCHEMATA_RACE:
+ bestSubset = schemataRace(m_Instances, random);
+ break;
+ case RANK_RACE:
+ bestSubset = rankRace(m_Instances, random);
+ break;
+ }
+
+ return bestSubset;
+ }
+
+ public double [][] rankedAttributes() throws Exception {
+ if (!m_rankingRequested) {
+ throw new Exception("Need to request a ranked list of attributes "
+ +"before attributes can be ranked (RaceSearch).");
+ }
+ if (m_rankedAtts == null) {
+ throw new Exception("Search must be performed before attributes "
+ +"can be ranked (RaceSearch).");
+ }
+
+ double [][] final_rank = new double [m_rankedSoFar][2];
+ for (int i=0;i m_threshold) {
+ count++;
+ }
+ }
+ m_calculatedNumToSelect = count;
+ }
+
+ /**
+ * Print an attribute set.
+ */
+ private String printSets(char [][]raceSets) {
+ StringBuffer temp = new StringBuffer();
+ for (int i=0;i 0) {
+ boolean won = false;
+ for (int i=0;i numInstances) {
+ throw new Exception("raceSchemata: No clear winner after sampling "
+ +sampleCount+" instances.");
+ } */
+
+ m_theEvaluator.buildEvaluator(trainCV);
+
+ // the evaluator must retrain for every test point
+ error = -((HoldOutSubsetEvaluator)m_theEvaluator).
+ evaluateSubset(randomB,
+ testInstance,
+ true);
+ evaluationCount++;
+
+ // see which racers match this random subset
+ for (int i=0;i
+ (numInstances)) {
+ break raceSet;
+ }
+ for (int j=0;j<2;j++) {
+ boolean matched = true;
+ for (int k =0;k m_samples &&
+ raceStats[i][1].count > m_samples) {
+ raceStats[i][0].calculateDerived();
+ raceStats[i][1].calculateDerived();
+ // System.err.println(j+" : "+(new String(parallelRaces[i][j])));
+ // System.err.println(raceStats[i][0]);
+ // System.err.println(raceStats[i][1]);
+ // check the ttest
+ double prob = ttest(raceStats[i][0], raceStats[i][1]);
+ // System.err.println("Prob :"+prob);
+ if (prob < m_sigLevel) { // stop the races we have a winner!
+ if (raceStats[i][0].mean < raceStats[i][1].mean) {
+ base = (char [])parallelRaces[i][0].clone();
+ m_bestMerit = raceStats[i][0].mean;
+ if (m_debug) {
+ System.err.println("contender 0 won ");
+ }
+ } else {
+ base = (char [])parallelRaces[i][1].clone();
+ m_bestMerit = raceStats[i][1].mean;
+ if (m_debug) {
+ System.err.println("contender 1 won");
+ }
+ }
+ if (m_debug) {
+ System.err.println((new String(parallelRaces[i][0]))
+ +" "+(new String(parallelRaces[i][1])));
+ System.err.println("Means : "+raceStats[i][0].mean
+ +" vs"+raceStats[i][1].mean);
+ System.err.println("Evaluations so far : "
+ +evaluationCount);
+ }
+ won = true;
+ break checkRaces;
+ }
+ }
+
+ }
+ }
+ }
+ }
+
+ numRaces--;
+ // set up the next set of races if necessary
+ if (numRaces > 0 && won) {
+ parallelRaces = new char [numRaces][2][m_numAttribs-1];
+ raceStats = new Stats[numRaces][2];
+ // update the attribute constraints
+ for (int i=0;i 0) {
+ for (int k=j;k m_samples-1 &&
+ (eliminatedCount < raceSets.length-1)) {
+ for (int j=0;j
+ testers[j][k].yStats.mean) {
+ eliminated[j] = true;
+ eliminatedCount++;
+ if (m_debug) {
+ System.err.println("Eliminating (near identical) "
+ +j+" "+raceBitSets[j].toString()
+ +" vs "+k+" "
+ +raceBitSets[k].toString()
+ +" after "
+ +processedCount
+ +" evaluations\n"
+ +"\nerror "+j+" : "
+ +testers[j][k].xStats.mean
+ +" vs "+k+" : "
+ +testers[j][k].yStats.mean
+ +" diff : "
+ +testers[j][k].differencesStats
+ .mean);
+ }
+ break;
+ } else {
+ eliminated[k] = true;
+ eliminatedCount++;
+ if (m_debug) {
+ System.err.println("Eliminating (near identical) "
+ +k+" "+raceBitSets[k].toString()
+ +" vs "+j+" "
+ +raceBitSets[j].toString()
+ +" after "
+ +processedCount
+ +" evaluations\n"
+ +"\nerror "+k+" : "
+ +testers[j][k].yStats.mean
+ +" vs "+j+" : "
+ +testers[j][k].xStats.mean
+ +" diff : "
+ +testers[j][k].differencesStats
+ .mean);
+ }
+ }
+ }
+ } else {
+ // significantly worse ?
+ if (testers[j][k].differencesSignificance != 0) {
+ if (testers[j][k].differencesSignificance > 0) {
+ eliminated[j] = true;
+ eliminatedCount++;
+ if (m_debug) {
+ System.err.println("Eliminating (-worse) "
+ +j+" "+raceBitSets[j].toString()
+ +" vs "+k+" "
+ +raceBitSets[k].toString()
+ +" after "
+ +processedCount
+ +" evaluations"
+ +"\nerror "+j+" : "
+ +testers[j][k].xStats.mean
+ +" vs "+k+" : "
+ +testers[j][k].yStats.mean);
+ }
+ break;
+ } else {
+ eliminated[k] = true;
+ eliminatedCount++;
+ if (m_debug) {
+ System.err.println("Eliminating (worse) "
+ +k+" "+raceBitSets[k].toString()
+ +" vs "+j+" "
+ +raceBitSets[j].toString()
+ +" after "
+ +processedCount
+ +" evaluations"
+ +"\nerror "+k+" : "
+ +testers[j][k].yStats.mean
+ +" vs "+j+" : "
+ +testers[j][k].xStats.mean);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ // if there is a base set from the previous race and it's the
+ // only remaining subset then terminate the race.
+ if (eliminatedCount == raceSets.length-1 && baseSetIncluded &&
+ !eliminated[0] && !m_rankingRequested) {
+ break race;
+ }
+ }
+ }
+
+ if (m_debug) {
+ System.err.println("*****eliminated count: "+eliminatedCount);
+ }
+ double bestError = Double.MAX_VALUE;
+ int bestIndex=0;
+ // return the index of the winner
+ for (int i=startPt;i 0) {
+ fieldwidth = (int)Math.abs((Math.log(Math.abs(m_bestMerit)) /
+ Math.log(10)))+2;
+ }
+ if (Math.abs(precision) > 0) {
+ precision = Math.abs((Math.log(Math.abs(precision)) / Math.log(10)))+3;
+ } else {
+ precision = 2;
+ }
+
+ text.append(Utils.doubleToString(Math.abs(m_bestMerit),
+ fieldwidth+(int)precision,
+ (int)precision)+"\n");
+ return text.toString();
+
+ }
+
+ /**
+ * Reset the search method.
+ */
+ protected void resetOptions () {
+ m_sigLevel = 0.001;
+ m_delta = 0.001;
+ m_ASEval = new GainRatioAttributeEval();
+ m_Ranking = null;
+ m_raceType = FORWARD_RACE;
+ m_debug = false;
+ m_theEvaluator = null;
+ m_bestMerit = -Double.MAX_VALUE;
+ m_numFolds = 10;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.26 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/RandomSearch.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/RandomSearch.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/RandomSearch.java (revision 29)
@@ -0,0 +1,668 @@
+/*
+ * 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.
+ */
+
+/*
+ * RandomSearch.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Range;
+import weka.core.RevisionUtils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformation.Type;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+
+ * RandomSearch :
+ *
+ * Performs a Random search in the space of attribute subsets. If no start set is supplied, Random search starts from a random point and reports the best subset found. If a start set is supplied, Random searches randomly for subsets that are as good or better than the start point with the same or or fewer attributes. Using RandomSearch in conjunction with a start set containing all attributes equates to the LVF algorithm of Liu and Setiono (ICML-96).
+ *
+ * For more information see:
+ *
+ * H. Liu, R. Setiono: A probabilistic approach to feature selection - A filter solution. In: 13th International Conference on Machine Learning, 319-327, 1996.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @inproceedings{Liu1996,
+ * author = {H. Liu and R. Setiono},
+ * booktitle = {13th International Conference on Machine Learning},
+ * pages = {319-327},
+ * title = {A probabilistic approach to feature selection - A filter solution},
+ * year = {1996}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * If a start point is supplied,
+ * random search evaluates the start
+ * point and then randomly looks for
+ * subsets that are as good as or better
+ * than the start point with the same
+ * or lower cardinality.
+ *
+ * -F <percent>
+ * Percent of search space to consider.
+ * (default = 25%).
+ *
+ * -V
+ * Output subsets as the search progresses.
+ * (default = false).
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.18 $
+ */
+public class RandomSearch
+ extends ASSearch
+ implements StartSetHandler, OptionHandler, TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = 7479392617377425484L;
+
+ /**
+ * holds a starting set as an array of attributes.
+ */
+ private int[] m_starting;
+
+ /** holds the start set as a range */
+ private Range m_startRange;
+
+ /** the best feature set found during the search */
+ private BitSet m_bestGroup;
+
+ /** the merit of the best subset found */
+ private double m_bestMerit;
+
+ /**
+ * only accept a feature set as being "better" than the best if its
+ * merit is better or equal to the best, and it contains fewer
+ * features than the best (this allows LVF to be implimented).
+ */
+ private boolean m_onlyConsiderBetterAndSmaller;
+
+ /** does the data have a class */
+ private boolean m_hasClass;
+
+ /** holds the class index */
+ private int m_classIndex;
+
+ /** number of attributes in the data */
+ private int m_numAttribs;
+
+ /** seed for random number generation */
+ private int m_seed;
+
+ /** percentage of the search space to consider */
+ private double m_searchSize;
+
+ /** the number of iterations performed */
+ private int m_iterations;
+
+ /** random number object */
+ private Random m_random;
+
+ /** output new best subsets as the search progresses */
+ private boolean m_verbose;
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "RandomSearch : \n\nPerforms a Random search in "
+ +"the space of attribute subsets. If no start set is supplied, Random "
+ +"search starts from a random point and reports the best subset found. "
+ +"If a start set is supplied, Random searches randomly for subsets "
+ +"that are as good or better than the start point with the same or "
+ +"or fewer attributes. Using RandomSearch in conjunction with a start "
+ +"set containing all attributes equates to the LVF algorithm of Liu "
+ +"and Setiono (ICML-96).\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.INPROCEEDINGS);
+ result.setValue(Field.AUTHOR, "H. Liu and R. Setiono");
+ result.setValue(Field.TITLE, "A probabilistic approach to feature selection - A filter solution");
+ result.setValue(Field.BOOKTITLE, "13th International Conference on Machine Learning");
+ result.setValue(Field.YEAR, "1996");
+ result.setValue(Field.PAGES, "319-327");
+
+ return result;
+ }
+
+ /**
+ * Constructor
+ */
+ public RandomSearch () {
+ resetOptions();
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(3);
+
+ newVector.addElement(new Option("\tSpecify a starting set of attributes."
+ + "\n\tEg. 1,3,5-7."
+ +"\n\tIf a start point is supplied,"
+ +"\n\trandom search evaluates the start"
+ +"\n\tpoint and then randomly looks for"
+ +"\n\tsubsets that are as good as or better"
+ +"\n\tthan the start point with the same"
+ +"\n\tor lower cardinality."
+ ,"P",1
+ , "-P "));
+
+ newVector.addElement(new Option("\tPercent of search space to consider."
+ +"\n\t(default = 25%)."
+ , "F", 1
+ , "-F "));
+ newVector.addElement(new Option("\tOutput subsets as the search progresses."
+ +"\n\t(default = false)."
+ , "V", 0
+ , "-V"));
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * If a start point is supplied,
+ * random search evaluates the start
+ * point and then randomly looks for
+ * subsets that are as good as or better
+ * than the start point with the same
+ * or lower cardinality.
+ *
+ * -F <percent>
+ * Percent of search space to consider.
+ * (default = 25%).
+ *
+ * -V
+ * Output subsets as the search progresses.
+ * (default = false).
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ *
+ **/
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ optionString = Utils.getOption('F',options);
+ if (optionString.length() != 0) {
+ setSearchPercent((new Double(optionString)).doubleValue());
+ }
+
+ setVerbose(Utils.getFlag('V',options));
+ }
+
+ /**
+ * Gets the current settings of RandomSearch.
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[5];
+ int current = 0;
+
+ if (m_verbose) {
+ options[current++] = "-V";
+ }
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = "" + startSetToString();
+ }
+
+ options[current++] = "-F";
+ options[current++] = "" + getSearchPercent();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String startSetTipText() {
+ return "Set the start point for the search. This is specified as a comma "
+ +"seperated list off attribute indexes starting at 1. It can include "
+ +"ranges. Eg. 1,2,5-9,17. If specified, Random searches for subsets "
+ +"of attributes that are as good as or better than the start set with "
+ +"the same or lower cardinality.";
+ }
+
+ /**
+ * Sets a starting set of attributes for the search. It is the
+ * search method's responsibility to report this start set (if any)
+ * in its toString() method.
+ * @param startSet a string containing a list of attributes (and or ranges),
+ * eg. 1,2,6,10-15. "" indicates no start point.
+ * If a start point is supplied, random search evaluates the
+ * start point and then looks for subsets that are as good as or better
+ * than the start point with the same or lower cardinality.
+ * @throws Exception if start set can't be set.
+ */
+ public void setStartSet (String startSet) throws Exception {
+ m_startRange.setRanges(startSet);
+ }
+
+ /**
+ * Returns a list of attributes (and or attribute ranges) as a String
+ * @return a list of attributes (and or attribute ranges)
+ */
+ public String getStartSet () {
+ return m_startRange.getRanges();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String verboseTipText() {
+ return "Print progress information. Sends progress info to the terminal "
+ +"as the search progresses.";
+ }
+
+ /**
+ * set whether or not to output new best subsets as the search proceeds
+ * @param v true if output is to be verbose
+ */
+ public void setVerbose(boolean v) {
+ m_verbose = v;
+ }
+
+ /**
+ * get whether or not output is verbose
+ * @return true if output is set to verbose
+ */
+ public boolean getVerbose() {
+ return m_verbose;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String searchPercentTipText() {
+ return "Percentage of the search space to explore.";
+ }
+
+ /**
+ * set the percentage of the search space to consider
+ * @param p percent of the search space ( 0 < p <= 100)
+ */
+ public void setSearchPercent(double p) {
+ p = Math.abs(p);
+ if (p == 0) {
+ p = 25;
+ }
+
+ if (p > 100.0) {
+ p = 100;
+ }
+
+ m_searchSize = (p/100.0);
+ }
+
+ /**
+ * get the percentage of the search space to consider
+ * @return the percent of the search space explored
+ */
+ public double getSearchPercent() {
+ return m_searchSize * 100;
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is
+ * used by getOptions to return the actual attributes specified
+ * as the starting set. This is better than using m_startRanges.getRanges()
+ * as the same start set can be specified in different ways from the
+ * command line---eg 1,2,3 == 1-3. This is to ensure that stuff that
+ * is stored in a database is comparable.
+ * @return a comma seperated list of individual attribute numbers as a String
+ */
+ private String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ (m_hasClass == true && i != m_classIndex)) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ }
+ else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * prints a description of the search
+ * @return a description of the search as a string
+ */
+ public String toString() {
+ StringBuffer text = new StringBuffer();
+
+ text.append("\tRandom search.\n\tStart set: ");
+ if (m_starting == null) {
+ text.append("no attributes\n");
+ }
+ else {
+ text.append(startSetToString()+"\n");
+ }
+ text.append("\tNumber of iterations: "+m_iterations+" ("
+ +(m_searchSize * 100.0)+"% of the search space)\n");
+ text.append("\tMerit of best subset found: "
+ +Utils.doubleToString(Math.abs(m_bestMerit),8,3)+"\n");
+
+ return text.toString();
+ }
+
+ /**
+ * Searches the attribute subset space randomly.
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+ double best_merit;
+ int sizeOfBest = m_numAttribs;
+ BitSet temp;
+ m_bestGroup = new BitSet(m_numAttribs);
+
+ m_onlyConsiderBetterAndSmaller = false;
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator!");
+ }
+
+ m_random = new Random(m_seed);
+
+ if (ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ }
+ else {
+ m_hasClass = true;
+ m_classIndex = data.classIndex();
+ }
+
+ SubsetEvaluator ASEvaluator = (SubsetEvaluator)ASEval;
+ m_numAttribs = data.numAttributes();
+
+ m_startRange.setUpper(m_numAttribs-1);
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+
+ // If a starting subset has been supplied, then initialise the bitset
+ if (m_starting != null) {
+ for (int i = 0; i < m_starting.length; i++) {
+ if ((m_starting[i]) != m_classIndex) {
+ m_bestGroup.set(m_starting[i]);
+ }
+ }
+ m_onlyConsiderBetterAndSmaller = true;
+ best_merit = ASEvaluator.evaluateSubset(m_bestGroup);
+ sizeOfBest = countFeatures(m_bestGroup);
+ } else {
+ // do initial random subset
+ m_bestGroup = generateRandomSubset();
+ best_merit = ASEvaluator.evaluateSubset(m_bestGroup);
+ }
+
+ if (m_verbose) {
+ System.out.println("Initial subset ("
+ +Utils.doubleToString(Math.
+ abs(best_merit),8,5)
+ +"): "+printSubset(m_bestGroup));
+ }
+
+ int i;
+ if (m_hasClass) {
+ i = m_numAttribs -1;
+ } else {
+ i = m_numAttribs;
+ }
+ m_iterations = (int)((m_searchSize * Math.pow(2, i)));
+
+ int tempSize;
+ double tempMerit;
+ // main loop
+ for (i=0;i= best_merit) {
+ sizeOfBest = tempSize;
+ m_bestGroup = temp;
+ best_merit = tempMerit;
+ if (m_verbose) {
+ System.out.print("New best subset ("
+ +Utils.doubleToString(Math.
+ abs(best_merit),8,5)
+ +"): "+printSubset(m_bestGroup) + " :");
+ System.out.println(Utils.
+ doubleToString((((double)i)/
+ ((double)m_iterations)*
+ 100.0),5,1)
+ +"% done");
+ }
+ }
+ }
+ } else {
+ tempMerit = ASEvaluator.evaluateSubset(temp);
+ if (tempMerit > best_merit) {
+ m_bestGroup = temp;
+ best_merit = tempMerit;
+ if (m_verbose) {
+ System.out.print("New best subset ("
+ +Utils.doubleToString(Math.abs(best_merit),8,5)
+ +"): "+printSubset(m_bestGroup) + " :");
+ System.out.println(Utils.
+ doubleToString((((double)i)/
+ ((double)m_iterations)
+ *100.0),5,1)
+ +"% done");
+ }
+ }
+ }
+ }
+ m_bestMerit = best_merit;
+ return attributeList(m_bestGroup);
+ }
+
+ /**
+ * prints a subset as a series of attribute numbers
+ * @param temp the subset to print
+ * @return a subset as a String of attribute numbers
+ */
+ private String printSubset(BitSet temp) {
+ StringBuffer text = new StringBuffer();
+
+ for (int j=0;j
+ * RankSearch :
+ *
+ * Uses an attribute/subset evaluator to rank all attributes. If a subset evaluator is specified, then a forward selection search is used to generate a ranked list. From the ranked list of attributes, subsets of increasing size are evaluated, ie. The best attribute, the best attribute plus the next best attribute, etc.... The best attribute set is reported. RankSearch is linear in the number of attributes if a simple attribute evaluator is used such as GainRatioAttributeEval.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -A <attribute evaluator>
+ * class name of attribute evaluator to use for ranking. Place any
+ * evaluator options LAST on the command line following a "--".
+ * eg.:
+ * -A weka.attributeSelection.GainRatioAttributeEval ... -- -M
+ * (default: weka.attributeSelection.GainRatioAttributeEval)
+ *
+ * -S <step size>
+ * number of attributes to be added from the
+ * ranking in each iteration (default = 1).
+ *
+ * -R <start point>
+ * point in the ranking to start evaluating from.
+ * (default = 0, ie. the head of the ranking).
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.GainRatioAttributeEval:
+ *
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 4614 $
+ */
+public class RankSearch
+ extends ASSearch
+ implements OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -7992268736874353755L;
+
+ /** does the data have a class */
+ private boolean m_hasClass;
+
+ /** holds the class index */
+ private int m_classIndex;
+
+ /** number of attributes in the data */
+ private int m_numAttribs;
+
+ /** the best subset found */
+ private BitSet m_best_group;
+
+ /** the attribute evaluator to use for generating the ranking */
+ private ASEvaluation m_ASEval;
+
+ /** the subset evaluator with which to evaluate the ranking */
+ private ASEvaluation m_SubsetEval;
+
+ /** the training instances */
+ private Instances m_Instances;
+
+ /** the merit of the best subset found */
+ private double m_bestMerit;
+
+ /** will hold the attribute ranking */
+ private int [] m_Ranking;
+
+ /** add this many attributes in each iteration from the ranking */
+ protected int m_add = 1;
+
+ /** start from this point in the ranking */
+ protected int m_startPoint = 0;
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search method suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "RankSearch : \n\n"
+ +"Uses an attribute/subset evaluator to rank all attributes. "
+ +"If a subset evaluator is specified, then a forward selection "
+ +"search is used to generate a ranked list. From the ranked "
+ +"list of attributes, subsets of increasing size are evaluated, ie. "
+ +"The best attribute, the best attribute plus the next best attribute, "
+ +"etc.... The best attribute set is reported. RankSearch is linear in "
+ +"the number of attributes if a simple attribute evaluator is used "
+ +"such as GainRatioAttributeEval.\n";
+ }
+
+ /**
+ * Constructor
+ */
+ public RankSearch () {
+ resetOptions();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String attributeEvaluatorTipText() {
+ return "Attribute evaluator to use for generating a ranking.";
+ }
+
+ /**
+ * Set the attribute evaluator to use for generating the ranking.
+ * @param newEvaluator the attribute evaluator to use.
+ */
+ public void setAttributeEvaluator(ASEvaluation newEvaluator) {
+ m_ASEval = newEvaluator;
+ }
+
+ /**
+ * Get the attribute evaluator used to generate the ranking.
+ * @return the evaluator used to generate the ranking.
+ */
+ public ASEvaluation getAttributeEvaluator() {
+ return m_ASEval;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String stepSizeTipText() {
+ return "Add this many attributes from the ranking in each iteration.";
+ }
+
+ /**
+ * Set the number of attributes to add from the rankining
+ * in each iteration
+ * @param ss the number of attribes to add.
+ */
+ public void setStepSize(int ss) {
+ if (ss > 0) {
+ m_add = ss;
+ }
+ }
+
+ /**
+ * Get the number of attributes to add from the rankining
+ * in each iteration
+ * @return the number of attributes to add.
+ */
+ public int getStepSize() {
+ return m_add;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String startPointTipText() {
+ return "Start evaluating from this point in the ranking.";
+ }
+
+ /**
+ * Set the point at which to start evaluating the ranking
+ * @param sp the position in the ranking to start at
+ */
+ public void setStartPoint(int sp) {
+ if (sp >= 0) {
+ m_startPoint = sp;
+ }
+ }
+
+ /**
+ * Get the point at which to start evaluating the ranking
+ * @return the position in the ranking to start at
+ */
+ public int getStartPoint() {
+ return m_startPoint;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(4);
+
+ newVector.addElement(new Option(
+ "\tclass name of attribute evaluator to use for ranking. Place any\n"
+ + "\tevaluator options LAST on the command line following a \"--\".\n"
+ + "\teg.:\n"
+ + "\t\t-A weka.attributeSelection.GainRatioAttributeEval ... -- -M\n"
+ + "\t(default: weka.attributeSelection.GainRatioAttributeEval)",
+ "A", 1, "-A "));
+
+ newVector.addElement(new Option(
+ "\tnumber of attributes to be added from the"
+ +"\n\tranking in each iteration (default = 1).",
+ "S", 1,"-S "));
+
+ newVector.addElement(new Option(
+ "\tpoint in the ranking to start evaluating from. "
+ +"\n\t(default = 0, ie. the head of the ranking).",
+ "R", 1,"-R "));
+
+ if ((m_ASEval != null) &&
+ (m_ASEval instanceof OptionHandler)) {
+ newVector.addElement(new Option("", "", 0, "\nOptions specific to "
+ + "evaluator "
+ + m_ASEval.getClass().getName()
+ + ":"));
+ Enumeration enu = ((OptionHandler)m_ASEval).listOptions();
+
+ while (enu.hasMoreElements()) {
+ newVector.addElement(enu.nextElement());
+ }
+ }
+
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -A <attribute evaluator>
+ * class name of attribute evaluator to use for ranking. Place any
+ * evaluator options LAST on the command line following a "--".
+ * eg.:
+ * -A weka.attributeSelection.GainRatioAttributeEval ... -- -M
+ * (default: weka.attributeSelection.GainRatioAttributeEval)
+ *
+ * -S <step size>
+ * number of attributes to be added from the
+ * ranking in each iteration (default = 1).
+ *
+ * -R <start point>
+ * point in the ranking to start evaluating from.
+ * (default = 0, ie. the head of the ranking).
+ *
+ *
+ * Options specific to evaluator weka.attributeSelection.GainRatioAttributeEval:
+ *
+ *
+ * -M
+ * treat missing values as a seperate value.
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('S', options);
+ if (optionString.length() != 0) {
+ setStepSize(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('R', options);
+ if (optionString.length() != 0) {
+ setStartPoint(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('A', options);
+ if (optionString.length() == 0)
+ optionString = GainRatioAttributeEval.class.getName();
+ setAttributeEvaluator(ASEvaluation.forName(optionString,
+ Utils.partitionOptions(options)));
+ }
+
+ /**
+ * Gets the current settings of WrapperSubsetEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] evaluatorOptions = new String[0];
+
+ if ((m_ASEval != null) &&
+ (m_ASEval instanceof OptionHandler)) {
+ evaluatorOptions = ((OptionHandler)m_ASEval).getOptions();
+ }
+
+ String[] options = new String[8 + evaluatorOptions.length];
+ int current = 0;
+
+ options[current++] = "-S"; options[current++] = ""+getStepSize();
+
+ options[current++] = "-R"; options[current++] = ""+getStartPoint();
+
+ if (getAttributeEvaluator() != null) {
+ options[current++] = "-A";
+ options[current++] = getAttributeEvaluator().getClass().getName();
+ }
+
+ if (evaluatorOptions.length > 0) {
+ options[current++] = "--";
+ System.arraycopy(evaluatorOptions, 0, options, current,
+ evaluatorOptions.length);
+ current += evaluatorOptions.length;
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ /**
+ * Reset the search method.
+ */
+ protected void resetOptions () {
+ m_ASEval = new GainRatioAttributeEval();
+ m_Ranking = null;
+ }
+
+ /**
+ * Ranks attributes using the specified attribute evaluator and then
+ * searches the ranking using the supplied subset evaluator.
+ *
+ * @param ASEval the subset evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+
+ double best_merit = -Double.MAX_VALUE;
+ double temp_merit;
+ BitSet temp_group, best_group=null;
+
+ if (!(ASEval instanceof SubsetEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a "
+ + "Subset evaluator!");
+ }
+
+ m_SubsetEval = ASEval;
+ m_Instances = data;
+ m_numAttribs = m_Instances.numAttributes();
+
+ /* if (m_ASEval instanceof AttributeTransformer) {
+ throw new Exception("Can't use an attribute transformer "
+ +"with RankSearch");
+ } */
+ if (m_ASEval instanceof UnsupervisedAttributeEvaluator ||
+ m_ASEval instanceof UnsupervisedSubsetEvaluator) {
+ m_hasClass = false;
+ /* if (!(m_SubsetEval instanceof UnsupervisedSubsetEvaluator)) {
+ throw new Exception("Must use an unsupervised subset evaluator.");
+ } */
+ }
+ else {
+ m_hasClass = true;
+ m_classIndex = m_Instances.classIndex();
+ }
+
+ if (m_ASEval instanceof AttributeEvaluator) {
+ // generate the attribute ranking first
+ Ranker ranker = new Ranker();
+ m_ASEval.buildEvaluator(m_Instances);
+ if (m_ASEval instanceof AttributeTransformer) {
+ // get the transformed data a rebuild the subset evaluator
+ m_Instances = ((AttributeTransformer)m_ASEval).
+ transformedData(m_Instances);
+ ((ASEvaluation)m_SubsetEval).buildEvaluator(m_Instances);
+ }
+ m_Ranking = ranker.search(m_ASEval, m_Instances);
+ } else {
+ GreedyStepwise fs = new GreedyStepwise();
+ double [][]rankres;
+ fs.setGenerateRanking(true);
+ ((ASEvaluation)m_ASEval).buildEvaluator(m_Instances);
+ fs.search(m_ASEval, m_Instances);
+ rankres = fs.rankedAttributes();
+ m_Ranking = new int[rankres.length];
+ for (int i=0;i best_merit) {
+ best_merit = temp_merit;;
+ best_group = temp_group;
+ }
+ }
+ m_bestMerit = best_merit;
+ return attributeList(best_group);
+ }
+
+ /**
+ * converts a BitSet into a list of attribute indexes
+ * @param group the BitSet to convert
+ * @return an array of attribute indexes
+ **/
+ private int[] attributeList (BitSet group) {
+ int count = 0;
+
+ // count how many were selected
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ count++;
+ }
+ }
+
+ int[] list = new int[count];
+ count = 0;
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ if (group.get(i)) {
+ list[count++] = i;
+ }
+ }
+
+ return list;
+ }
+
+ /**
+ * returns a description of the search as a String
+ * @return a description of the search
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+ text.append("\tRankSearch :\n");
+ text.append("\tAttribute evaluator : "
+ + getAttributeEvaluator().getClass().getName() +" ");
+ if (m_ASEval instanceof OptionHandler) {
+ String[] evaluatorOptions = new String[0];
+ evaluatorOptions = ((OptionHandler)m_ASEval).getOptions();
+ for (int i=0;i 0) {
+ fieldwidth = (int)Math.abs((Math.log(Math.abs(m_bestMerit)) / Math.log(10)))+2;
+ }
+ if (Math.abs(precision) > 0) {
+ precision = Math.abs((Math.log(Math.abs(precision)) / Math.log(10)))+3;
+ } else {
+ precision = 2;
+ }
+
+ text.append(Utils.doubleToString(Math.abs(m_bestMerit),
+ fieldwidth+(int)precision,
+ (int)precision)+"\n");
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 4614 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/RankedOutputSearch.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/RankedOutputSearch.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/RankedOutputSearch.java (revision 29)
@@ -0,0 +1,108 @@
+/*
+ * 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.
+ */
+
+/*
+ * RankedOutputSearch.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+
+package weka.attributeSelection;
+
+
+/**
+ * Interface for search methods capable of producing a
+ * ranked list of attributes.
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.11 $
+ */
+public interface RankedOutputSearch {
+
+
+ // ===============
+ // Public methods.
+ // ===============
+
+ /**
+ * Returns a X by 2 list of attribute indexes and corresponding
+ * evaluations from best (highest) to worst.
+ * @return the ranked list of attribute indexes in an array of ints
+ * @exception Exception if the ranking can't be produced
+ */
+ double[][] rankedAttributes() throws Exception;
+
+ /**
+ * Sets a threshold by which attributes can be discarded from the
+ * ranking. This threshold is used by the AttributeSelection module
+ * which does the actual discarding of attributes---the implementer
+ * of this method needs only to provide a variable in which to store the
+ * supplied threshold. -Double.MAX_VALUE is reserved to mean no threshold,
+ * ie, retain all attributes.
+ * @param threshold the threshold.
+ */
+ void setThreshold(double threshold);
+
+ /**
+ * Gets the threshold by which attributes can be discarded. Discarding
+ * of attributes is done by the AttributeSelection module using the
+ * threshold returned by this method.
+ * @return a threshold by which to discard attributes
+ */
+ double getThreshold();
+
+ /**
+ * Specify the number of attributes to select from the ranked list. < 0
+ * indicates that all attributes are to be retained. NumToSelect has
+ * precedence over threshold, ie. if there is a non -1 value for NumToSelect
+ * then this will take precedence over any threshold value.
+ * @param numToSelect the number of attributes to retain
+ */
+ void setNumToSelect(int numToSelect);
+
+ /**
+ * Gets the user specified number of attributes to be retained.
+ * @return the number of attributes to retain
+ */
+ int getNumToSelect();
+
+ /**
+ * Gets the calculated number of attributes to retain. This is the
+ * actual number of attributes to retain. This is the same as
+ * getNumToSelect if the user specifies a number which is not less
+ * than zero. Otherwise it should be the number of attributes in the
+ * (potentially transformed) data.
+ */
+ int getCalculatedNumToSelect();
+
+ /**
+ * Sets whether or not ranking is to be performed.
+ * When a search method is capable of producing a ranked list
+ * of attributes, the user has the choice of seeing the results of a
+ * normal search or seeing a ranked list.
+ * @param doRanking true if ranked list is to be produced
+ */
+ void setGenerateRanking(boolean doRanking);
+
+ /**
+ * Gets whether the user has opted to see a ranked list of
+ * attributes rather than the normal result of the search
+ * @return true if a ranked list has been requested.
+ */
+ boolean getGenerateRanking();
+
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/Ranker.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/Ranker.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/Ranker.java (revision 29)
@@ -0,0 +1,631 @@
+/*
+ * 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.
+ */
+
+/*
+ * Ranker.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.Range;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+
+ * Ranker :
+ *
+ * Ranks attributes by their individual evaluations. Use in conjunction with attribute evaluators (ReliefF, GainRatio, Entropy etc).
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * Any starting attributes specified are
+ * ignored during the ranking.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 1.26 $
+ */
+public class Ranker
+ extends ASSearch
+ implements RankedOutputSearch, StartSetHandler, OptionHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -9086714848510751934L;
+
+ /** Holds the starting set as an array of attributes */
+ private int[] m_starting;
+
+ /** Holds the start set for the search as a range */
+ private Range m_startRange;
+
+ /** Holds the ordered list of attributes */
+ private int[] m_attributeList;
+
+ /** Holds the list of attribute merit scores */
+ private double[] m_attributeMerit;
+
+ /** Data has class attribute---if unsupervised evaluator then no class */
+ private boolean m_hasClass;
+
+ /** Class index of the data if supervised evaluator */
+ private int m_classIndex;
+
+ /** The number of attribtes */
+ private int m_numAttribs;
+
+ /**
+ * A threshold by which to discard attributes---used by the
+ * AttributeSelection module
+ */
+ private double m_threshold;
+
+ /** The number of attributes to select. -1 indicates that all attributes
+ are to be retained. Has precedence over m_threshold */
+ private int m_numToSelect = -1;
+
+ /** Used to compute the number to select */
+ private int m_calculatedNumToSelect = -1;
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Ranker : \n\nRanks attributes by their individual evaluations. "
+ +"Use in conjunction with attribute evaluators (ReliefF, GainRatio, "
+ +"Entropy etc).\n";
+ }
+
+ /**
+ * Constructor
+ */
+ public Ranker () {
+ resetOptions();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String numToSelectTipText() {
+ return "Specify the number of attributes to retain. The default value "
+ +"(-1) indicates that all attributes are to be retained. Use either "
+ +"this option or a threshold to reduce the attribute set.";
+ }
+
+ /**
+ * Specify the number of attributes to select from the ranked list. -1
+ * indicates that all attributes are to be retained.
+ * @param n the number of attributes to retain
+ */
+ public void setNumToSelect(int n) {
+ m_numToSelect = n;
+ }
+
+ /**
+ * Gets the number of attributes to be retained.
+ * @return the number of attributes to retain
+ */
+ public int getNumToSelect() {
+ return m_numToSelect;
+ }
+
+ /**
+ * Gets the calculated number to select. This might be computed
+ * from a threshold, or if < 0 is set as the number to select then
+ * it is set to the number of attributes in the (transformed) data.
+ * @return the calculated number of attributes to select
+ */
+ public int getCalculatedNumToSelect() {
+ if (m_numToSelect >= 0) {
+ m_calculatedNumToSelect = m_numToSelect;
+ }
+ return m_calculatedNumToSelect;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String thresholdTipText() {
+ return "Set threshold by which attributes can be discarded. Default value "
+ + "results in no attributes being discarded. Use either this option or "
+ +"numToSelect to reduce the attribute set.";
+ }
+
+ /**
+ * Set the threshold by which the AttributeSelection module can discard
+ * attributes.
+ * @param threshold the threshold.
+ */
+ public void setThreshold(double threshold) {
+ m_threshold = threshold;
+ }
+
+ /**
+ * Returns the threshold so that the AttributeSelection module can
+ * discard attributes from the ranking.
+ */
+ public double getThreshold() {
+ return m_threshold;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String generateRankingTipText() {
+ return "A constant option. Ranker is only capable of generating "
+ +" attribute rankings.";
+ }
+
+ /**
+ * This is a dummy set method---Ranker is ONLY capable of producing
+ * a ranked list of attributes for attribute evaluators.
+ * @param doRank this parameter is N/A and is ignored
+ */
+ public void setGenerateRanking(boolean doRank) {
+
+ }
+
+ /**
+ * This is a dummy method. Ranker can ONLY be used with attribute
+ * evaluators and as such can only produce a ranked list of attributes
+ * @return true all the time.
+ */
+ public boolean getGenerateRanking() {
+ return true;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String startSetTipText() {
+ return "Specify a set of attributes to ignore. "
+ +" When generating the ranking, Ranker will not evaluate the attributes "
+ +" in this list. "
+ +"This is specified as a comma "
+ +"seperated list off attribute indexes starting at 1. It can include "
+ +"ranges. Eg. 1,2,5-9,17.";
+ }
+
+ /**
+ * Sets a starting set of attributes for the search. It is the
+ * search method's responsibility to report this start set (if any)
+ * in its toString() method.
+ * @param startSet a string containing a list of attributes (and or ranges),
+ * eg. 1,2,6,10-15.
+ * @throws Exception if start set can't be set.
+ */
+ public void setStartSet (String startSet) throws Exception {
+ m_startRange.setRanges(startSet);
+ }
+
+ /**
+ * Returns a list of attributes (and or attribute ranges) as a String
+ * @return a list of attributes (and or attribute ranges)
+ */
+ public String getStartSet () {
+ return m_startRange.getRanges();
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(3);
+
+ newVector
+ .addElement(new Option("\tSpecify a starting set of attributes.\n"
+ + "\tEg. 1,3,5-7.\n"
+ +"\tAny starting attributes specified are\n"
+ +"\tignored during the ranking."
+ ,"P",1
+ , "-P "));
+ newVector
+ .addElement(new Option("\tSpecify a theshold by which attributes\n"
+ + "\tmay be discarded from the ranking.","T",1
+ , "-T "));
+
+ newVector
+ .addElement(new Option("\tSpecify number of attributes to select"
+ ,"N",1
+ , "-N "));
+
+ return newVector.elements();
+
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -P <start set>
+ * Specify a starting set of attributes.
+ * Eg. 1,3,5-7.
+ * Any starting attributes specified are
+ * ignored during the ranking.
+ *
+ * -T <threshold>
+ * Specify a theshold by which attributes
+ * may be discarded from the ranking.
+ *
+ * -N <num to select>
+ * Specify number of attributes to select
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setStartSet(optionString);
+ }
+
+ optionString = Utils.getOption('T', options);
+ if (optionString.length() != 0) {
+ Double temp;
+ temp = Double.valueOf(optionString);
+ setThreshold(temp.doubleValue());
+ }
+
+ optionString = Utils.getOption('N', options);
+ if (optionString.length() != 0) {
+ setNumToSelect(Integer.parseInt(optionString));
+ }
+ }
+
+ /**
+ * Gets the current settings of ReliefFAttributeEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[6];
+ int current = 0;
+
+ if (!(getStartSet().equals(""))) {
+ options[current++] = "-P";
+ options[current++] = ""+startSetToString();
+ }
+
+ options[current++] = "-T";
+ options[current++] = "" + getThreshold();
+
+ options[current++] = "-N";
+ options[current++] = ""+getNumToSelect();
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+ return options;
+ }
+
+ /**
+ * converts the array of starting attributes to a string. This is
+ * used by getOptions to return the actual attributes specified
+ * as the starting set. This is better than using m_startRanges.getRanges()
+ * as the same start set can be specified in different ways from the
+ * command line---eg 1,2,3 == 1-3. This is to ensure that stuff that
+ * is stored in a database is comparable.
+ * @return a comma seperated list of individual attribute numbers as a String
+ */
+ private String startSetToString() {
+ StringBuffer FString = new StringBuffer();
+ boolean didPrint;
+
+ if (m_starting == null) {
+ return getStartSet();
+ }
+
+ for (int i = 0; i < m_starting.length; i++) {
+ didPrint = false;
+
+ if ((m_hasClass == false) ||
+ (m_hasClass == true && i != m_classIndex)) {
+ FString.append((m_starting[i] + 1));
+ didPrint = true;
+ }
+
+ if (i == (m_starting.length - 1)) {
+ FString.append("");
+ }
+ else {
+ if (didPrint) {
+ FString.append(",");
+ }
+ }
+ }
+
+ return FString.toString();
+ }
+
+ /**
+ * Kind of a dummy search algorithm. Calls a Attribute evaluator to
+ * evaluate each attribute not included in the startSet and then sorts
+ * them to produce a ranked list of attributes.
+ *
+ * @param ASEval the attribute evaluator to guide the search
+ * @param data the training instances.
+ * @return an array (not necessarily ordered) of selected attribute indexes
+ * @throws Exception if the search can't be completed
+ */
+ public int[] search (ASEvaluation ASEval, Instances data)
+ throws Exception {
+ int i, j;
+
+ if (!(ASEval instanceof AttributeEvaluator)) {
+ throw new Exception(ASEval.getClass().getName()
+ + " is not a"
+ + "Attribute evaluator!");
+ }
+
+ m_numAttribs = data.numAttributes();
+
+ if (ASEval instanceof UnsupervisedAttributeEvaluator) {
+ m_hasClass = false;
+ }
+ else {
+ m_classIndex = data.classIndex();
+ if (m_classIndex >= 0) {
+ m_hasClass = true;
+ } else {
+ m_hasClass = false;
+ }
+ }
+
+ // get the transformed data and check to see if the transformer
+ // preserves a class index
+ if (ASEval instanceof AttributeTransformer) {
+ data = ((AttributeTransformer)ASEval).transformedHeader();
+ if (m_classIndex >= 0 && data.classIndex() >= 0) {
+ m_classIndex = data.classIndex();
+ m_hasClass = true;
+ }
+ }
+
+
+ m_startRange.setUpper(m_numAttribs - 1);
+ if (!(getStartSet().equals(""))) {
+ m_starting = m_startRange.getSelection();
+ }
+
+ int sl=0;
+ if (m_starting != null) {
+ sl = m_starting.length;
+ }
+ if ((m_starting != null) && (m_hasClass == true)) {
+ // see if the supplied list contains the class index
+ boolean ok = false;
+ for (i = 0; i < sl; i++) {
+ if (m_starting[i] == m_classIndex) {
+ ok = true;
+ break;
+ }
+ }
+
+ if (ok == false) {
+ sl++;
+ }
+ }
+ else {
+ if (m_hasClass == true) {
+ sl++;
+ }
+ }
+
+
+ m_attributeList = new int[m_numAttribs - sl];
+ m_attributeMerit = new double[m_numAttribs - sl];
+
+ // add in those attributes not in the starting (omit list)
+ for (i = 0, j = 0; i < m_numAttribs; i++) {
+ if (!inStarting(i)) {
+ m_attributeList[j++] = i;
+ }
+ }
+
+ AttributeEvaluator ASEvaluator = (AttributeEvaluator)ASEval;
+
+ for (i = 0; i < m_attributeList.length; i++) {
+ m_attributeMerit[i] = ASEvaluator.evaluateAttribute(m_attributeList[i]);
+ }
+
+ double[][] tempRanked = rankedAttributes();
+ int[] rankedAttributes = new int[m_attributeList.length];
+
+ for (i = 0; i < m_attributeList.length; i++) {
+ rankedAttributes[i] = (int)tempRanked[i][0];
+ }
+
+ return rankedAttributes;
+ }
+
+
+ /**
+ * Sorts the evaluated attribute list
+ *
+ * @return an array of sorted (highest eval to lowest) attribute indexes
+ * @throws Exception of sorting can't be done.
+ */
+ public double[][] rankedAttributes ()
+ throws Exception {
+ int i, j;
+
+ if (m_attributeList == null || m_attributeMerit == null) {
+ throw new Exception("Search must be performed before a ranked "
+ + "attribute list can be obtained");
+ }
+
+ int[] ranked = Utils.sort(m_attributeMerit);
+ // reverse the order of the ranked indexes
+ double[][] bestToWorst = new double[ranked.length][2];
+
+ for (i = ranked.length - 1, j = 0; i >= 0; i--) {
+ bestToWorst[j++][0] = ranked[i];
+ }
+
+ // convert the indexes to attribute indexes
+ for (i = 0; i < bestToWorst.length; i++) {
+ int temp = ((int)bestToWorst[i][0]);
+ bestToWorst[i][0] = m_attributeList[temp];
+ bestToWorst[i][1] = m_attributeMerit[temp];
+ }
+
+ if (m_numToSelect > bestToWorst.length) {
+ throw new Exception("More attributes requested than exist in the data");
+ }
+
+ if (m_numToSelect <= 0) {
+ if (m_threshold == -Double.MAX_VALUE) {
+ m_calculatedNumToSelect = bestToWorst.length;
+ } else {
+ determineNumToSelectFromThreshold(bestToWorst);
+ }
+ }
+ /* if (m_numToSelect > 0) {
+ determineThreshFromNumToSelect(bestToWorst);
+ } */
+
+ return bestToWorst;
+ }
+
+ private void determineNumToSelectFromThreshold(double [][] ranking) {
+ int count = 0;
+ for (int i = 0; i < ranking.length; i++) {
+ if (ranking[i][1] > m_threshold) {
+ count++;
+ }
+ }
+ m_calculatedNumToSelect = count;
+ }
+
+ private void determineThreshFromNumToSelect(double [][] ranking)
+ throws Exception {
+ if (m_numToSelect > ranking.length) {
+ throw new Exception("More attributes requested than exist in the data");
+ }
+
+ if (m_numToSelect == ranking.length) {
+ return;
+ }
+
+ m_threshold = (ranking[m_numToSelect-1][1] +
+ ranking[m_numToSelect][1]) / 2.0;
+ }
+
+ /**
+ * returns a description of the search as a String
+ * @return a description of the search
+ */
+ public String toString () {
+ StringBuffer BfString = new StringBuffer();
+ BfString.append("\tAttribute ranking.\n");
+
+ if (m_starting != null) {
+ BfString.append("\tIgnored attributes: ");
+
+ BfString.append(startSetToString());
+ BfString.append("\n");
+ }
+
+ if (m_threshold != -Double.MAX_VALUE) {
+ BfString.append("\tThreshold for discarding attributes: "
+ + Utils.doubleToString(m_threshold,8,4)+"\n");
+ }
+
+ return BfString.toString();
+ }
+
+
+ /**
+ * Resets stuff to default values
+ */
+ protected void resetOptions () {
+ m_starting = null;
+ m_startRange = new Range();
+ m_attributeList = null;
+ m_attributeMerit = null;
+ m_threshold = -Double.MAX_VALUE;
+ }
+
+
+ private boolean inStarting (int feat) {
+ // omit the class from the evaluation
+ if ((m_hasClass == true) && (feat == m_classIndex)) {
+ return true;
+ }
+
+ if (m_starting == null) {
+ return false;
+ }
+
+ for (int i = 0; i < m_starting.length; i++) {
+ if (m_starting[i] == feat) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.26 $");
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ReliefFAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ReliefFAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ReliefFAttributeEval.java (revision 29)
@@ -0,0 +1,1348 @@
+/*
+ * 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.
+ */
+
+/*
+ * ReliefFAttributeEval.java
+ * Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.core.Attribute;
+import weka.core.Capabilities;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+
+import java.util.Enumeration;
+import java.util.Random;
+import java.util.Vector;
+
+/**
+
+ * ReliefFAttributeEval :
+ *
+ * Evaluates the worth of an attribute by repeatedly sampling an instance and considering the value of the given attribute for the nearest instance of the same and different class. Can operate on both discrete and continuous class data.
+ *
+ * For more information see:
+ *
+ * Kenji Kira, Larry A. Rendell: A Practical Approach to Feature Selection. In: Ninth International Workshop on Machine Learning, 249-256, 1992.
+ *
+ * Igor Kononenko: Estimating Attributes: Analysis and Extensions of RELIEF. In: European Conference on Machine Learning, 171-182, 1994.
+ *
+ * Marko Robnik-Sikonja, Igor Kononenko: An adaptation of Relief for attribute estimation in regression. In: Fourteenth International Conference on Machine Learning, 296-304, 1997.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @inproceedings{Kira1992,
+ * author = {Kenji Kira and Larry A. Rendell},
+ * booktitle = {Ninth International Workshop on Machine Learning},
+ * editor = {Derek H. Sleeman and Peter Edwards},
+ * pages = {249-256},
+ * publisher = {Morgan Kaufmann},
+ * title = {A Practical Approach to Feature Selection},
+ * year = {1992}
+ * }
+ *
+ * @inproceedings{Kononenko1994,
+ * author = {Igor Kononenko},
+ * booktitle = {European Conference on Machine Learning},
+ * editor = {Francesco Bergadano and Luc De Raedt},
+ * pages = {171-182},
+ * publisher = {Springer},
+ * title = {Estimating Attributes: Analysis and Extensions of RELIEF},
+ * year = {1994}
+ * }
+ *
+ * @inproceedings{Robnik-Sikonja1997,
+ * author = {Marko Robnik-Sikonja and Igor Kononenko},
+ * booktitle = {Fourteenth International Conference on Machine Learning},
+ * editor = {Douglas H. Fisher},
+ * pages = {296-304},
+ * publisher = {Morgan Kaufmann},
+ * title = {An adaptation of Relief for attribute estimation in regression},
+ * year = {1997}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -M <num instances>
+ * Specify the number of instances to
+ * sample when estimating attributes.
+ * If not specified, then all instances
+ * will be used.
+ *
+ * -D <seed>
+ * Seed for randomly sampling instances.
+ * (Default = 1)
+ *
+ * -K <number of neighbours>
+ * Number of nearest neighbours (k) used
+ * to estimate attribute relevances
+ * (Default = 10).
+ *
+ * -W
+ * Weight nearest neighbours by distance
+ *
+ * -A <num>
+ * Specify sigma value (used in an exp
+ * function to control how quickly
+ * weights for more distant instances
+ * decrease. Use in conjunction with -W.
+ * Sensible value=1/5 to 1/10 of the
+ * number of nearest neighbours.
+ * (Default = 2)
+ *
+
+ *
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @version $Revision: 5987 $
+ */
+public class ReliefFAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator,
+ OptionHandler,
+ TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -8422186665795839379L;
+
+ /** The training instances */
+ private Instances m_trainInstances;
+
+ /** The class index */
+ private int m_classIndex;
+
+ /** The number of attributes */
+ private int m_numAttribs;
+
+ /** The number of instances */
+ private int m_numInstances;
+
+ /** Numeric class */
+ private boolean m_numericClass;
+
+ /** The number of classes if class is nominal */
+ private int m_numClasses;
+
+ /**
+ * Used to hold the probability of a different class val given nearest
+ * instances (numeric class)
+ */
+ private double m_ndc;
+
+ /**
+ * Used to hold the prob of different value of an attribute given
+ * nearest instances (numeric class case)
+ */
+ private double[] m_nda;
+
+ /**
+ * Used to hold the prob of a different class val and different att
+ * val given nearest instances (numeric class case)
+ */
+ private double[] m_ndcda;
+
+ /** Holds the weights that relief assigns to attributes */
+ private double[] m_weights;
+
+ /** Prior class probabilities (discrete class case) */
+ private double[] m_classProbs;
+
+ /**
+ * The number of instances to sample when estimating attributes
+ * default == -1, use all instances
+ */
+ private int m_sampleM;
+
+ /** The number of nearest hits/misses */
+ private int m_Knn;
+
+ /** k nearest scores + instance indexes for n classes */
+ private double[][][] m_karray;
+
+ /** Upper bound for numeric attributes */
+ private double[] m_maxArray;
+
+ /** Lower bound for numeric attributes */
+ private double[] m_minArray;
+
+ /** Keep track of the farthest instance for each class */
+ private double[] m_worst;
+
+ /** Index in the m_karray of the farthest instance for each class */
+ private int[] m_index;
+
+ /** Number of nearest neighbours stored of each class */
+ private int[] m_stored;
+
+ /** Random number seed used for sampling instances */
+ private int m_seed;
+
+ /**
+ * used to (optionally) weight nearest neighbours by their distance
+ * from the instance in question. Each entry holds
+ * exp(-((rank(r_i, i_j)/sigma)^2)) where rank(r_i,i_j) is the rank of
+ * instance i_j in a sequence of instances ordered by the distance
+ * from r_i. sigma is a user defined parameter, default=20
+ **/
+ private double[] m_weightsByRank;
+ private int m_sigma;
+
+ /** Weight by distance rather than equal weights */
+ private boolean m_weightByDistance;
+
+ /**
+ * Constructor
+ */
+ public ReliefFAttributeEval () {
+ resetOptions();
+ }
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "ReliefFAttributeEval :\n\nEvaluates the worth of an attribute by "
+ +"repeatedly sampling an instance and considering the value of the "
+ +"given attribute for the nearest instance of the same and different "
+ +"class. Can operate on both discrete and continuous class data.\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+ TechnicalInformation additional;
+
+ result = new TechnicalInformation(Type.INPROCEEDINGS);
+ result.setValue(Field.AUTHOR, "Kenji Kira and Larry A. Rendell");
+ result.setValue(Field.TITLE, "A Practical Approach to Feature Selection");
+ result.setValue(Field.BOOKTITLE, "Ninth International Workshop on Machine Learning");
+ result.setValue(Field.EDITOR, "Derek H. Sleeman and Peter Edwards");
+ result.setValue(Field.YEAR, "1992");
+ result.setValue(Field.PAGES, "249-256");
+ result.setValue(Field.PUBLISHER, "Morgan Kaufmann");
+
+ additional = result.add(Type.INPROCEEDINGS);
+ additional.setValue(Field.AUTHOR, "Igor Kononenko");
+ additional.setValue(Field.TITLE, "Estimating Attributes: Analysis and Extensions of RELIEF");
+ additional.setValue(Field.BOOKTITLE, "European Conference on Machine Learning");
+ additional.setValue(Field.EDITOR, "Francesco Bergadano and Luc De Raedt");
+ additional.setValue(Field.YEAR, "1994");
+ additional.setValue(Field.PAGES, "171-182");
+ additional.setValue(Field.PUBLISHER, "Springer");
+
+ additional = result.add(Type.INPROCEEDINGS);
+ additional.setValue(Field.AUTHOR, "Marko Robnik-Sikonja and Igor Kononenko");
+ additional.setValue(Field.TITLE, "An adaptation of Relief for attribute estimation in regression");
+ additional.setValue(Field.BOOKTITLE, "Fourteenth International Conference on Machine Learning");
+ additional.setValue(Field.EDITOR, "Douglas H. Fisher");
+ additional.setValue(Field.YEAR, "1997");
+ additional.setValue(Field.PAGES, "296-304");
+ additional.setValue(Field.PUBLISHER, "Morgan Kaufmann");
+
+ return result;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(4);
+ newVector
+ .addElement(new Option("\tSpecify the number of instances to\n"
+ + "\tsample when estimating attributes.\n"
+ + "\tIf not specified, then all instances\n"
+ + "\twill be used.", "M", 1
+ , "-M "));
+ newVector.
+ addElement(new Option("\tSeed for randomly sampling instances.\n"
+ + "\t(Default = 1)", "D", 1
+ , "-D "));
+ newVector.
+ addElement(new Option("\tNumber of nearest neighbours (k) used\n"
+ + "\tto estimate attribute relevances\n"
+ + "\t(Default = 10).", "K", 1
+ , "-K "));
+ newVector.
+ addElement(new Option("\tWeight nearest neighbours by distance", "W"
+ , 0, "-W"));
+ newVector.
+ addElement(new Option("\tSpecify sigma value (used in an exp\n"
+ + "\tfunction to control how quickly\n"
+ + "\tweights for more distant instances\n"
+ + "\tdecrease. Use in conjunction with -W.\n"
+ + "\tSensible value=1/5 to 1/10 of the\n"
+ + "\tnumber of nearest neighbours.\n"
+ + "\t(Default = 2)", "A", 1, "-A "));
+ return newVector.elements();
+ }
+
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -M <num instances>
+ * Specify the number of instances to
+ * sample when estimating attributes.
+ * If not specified, then all instances
+ * will be used.
+ *
+ * -D <seed>
+ * Seed for randomly sampling instances.
+ * (Default = 1)
+ *
+ * -K <number of neighbours>
+ * Number of nearest neighbours (k) used
+ * to estimate attribute relevances
+ * (Default = 10).
+ *
+ * -W
+ * Weight nearest neighbours by distance
+ *
+ * -A <num>
+ * Specify sigma value (used in an exp
+ * function to control how quickly
+ * weights for more distant instances
+ * decrease. Use in conjunction with -W.
+ * Sensible value=1/5 to 1/10 of the
+ * number of nearest neighbours.
+ * (Default = 2)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an option is not supported
+ */
+ public void setOptions (String[] options)
+ throws Exception {
+ String optionString;
+ resetOptions();
+ setWeightByDistance(Utils.getFlag('W', options));
+ optionString = Utils.getOption('M', options);
+
+ if (optionString.length() != 0) {
+ setSampleSize(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('D', options);
+
+ if (optionString.length() != 0) {
+ setSeed(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('K', options);
+
+ if (optionString.length() != 0) {
+ setNumNeighbours(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('A', options);
+
+ if (optionString.length() != 0) {
+ setWeightByDistance(true); // turn on weighting by distance
+ setSigma(Integer.parseInt(optionString));
+ }
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String sigmaTipText() {
+ return "Set influence of nearest neighbours. Used in an exp function to "
+ +"control how quickly weights decrease for more distant instances. "
+ +"Use in conjunction with weightByDistance. Sensible values = 1/5 to "
+ +"1/10 the number of nearest neighbours.";
+ }
+
+ /**
+ * Sets the sigma value.
+ *
+ * @param s the value of sigma (> 0)
+ * @throws Exception if s is not positive
+ */
+ public void setSigma (int s)
+ throws Exception {
+ if (s <= 0) {
+ throw new Exception("value of sigma must be > 0!");
+ }
+
+ m_sigma = s;
+ }
+
+
+ /**
+ * Get the value of sigma.
+ *
+ * @return the sigma value.
+ */
+ public int getSigma () {
+ return m_sigma;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String numNeighboursTipText() {
+ return "Number of nearest neighbours for attribute estimation.";
+ }
+
+ /**
+ * Set the number of nearest neighbours
+ *
+ * @param n the number of nearest neighbours.
+ */
+ public void setNumNeighbours (int n) {
+ m_Knn = n;
+ }
+
+
+ /**
+ * Get the number of nearest neighbours
+ *
+ * @return the number of nearest neighbours
+ */
+ public int getNumNeighbours () {
+ return m_Knn;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String seedTipText() {
+ return "Random seed for sampling instances.";
+ }
+
+ /**
+ * Set the random number seed for randomly sampling instances.
+ *
+ * @param s the random number seed.
+ */
+ public void setSeed (int s) {
+ m_seed = s;
+ }
+
+
+ /**
+ * Get the seed used for randomly sampling instances.
+ *
+ * @return the random number seed.
+ */
+ public int getSeed () {
+ return m_seed;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String sampleSizeTipText() {
+ return "Number of instances to sample. Default (-1) indicates that all "
+ +"instances will be used for attribute estimation.";
+ }
+
+ /**
+ * Set the number of instances to sample for attribute estimation
+ *
+ * @param s the number of instances to sample.
+ */
+ public void setSampleSize (int s) {
+ m_sampleM = s;
+ }
+
+
+ /**
+ * Get the number of instances used for estimating attributes
+ *
+ * @return the number of instances.
+ */
+ public int getSampleSize () {
+ return m_sampleM;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String weightByDistanceTipText() {
+ return "Weight nearest neighbours by their distance.";
+ }
+
+ /**
+ * Set the nearest neighbour weighting method
+ *
+ * @param b true nearest neighbours are to be weighted by distance.
+ */
+ public void setWeightByDistance (boolean b) {
+ m_weightByDistance = b;
+ }
+
+
+ /**
+ * Get whether nearest neighbours are being weighted by distance
+ *
+ * @return m_weightByDiffernce
+ */
+ public boolean getWeightByDistance () {
+ return m_weightByDistance;
+ }
+
+
+ /**
+ * Gets the current settings of ReliefFAttributeEval.
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions () {
+ String[] options = new String[9];
+ int current = 0;
+
+ if (getWeightByDistance()) {
+ options[current++] = "-W";
+ }
+
+ options[current++] = "-M";
+ options[current++] = "" + getSampleSize();
+ options[current++] = "-D";
+ options[current++] = "" + getSeed();
+ options[current++] = "-K";
+ options[current++] = "" + getNumNeighbours();
+
+ if (getWeightByDistance()) {
+ options[current++] = "-A";
+ options[current++] = "" + getSigma();
+ }
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+
+ /**
+ * Return a description of the ReliefF attribute evaluator.
+ *
+ * @return a description of the evaluator as a String.
+ */
+ public String toString () {
+ StringBuffer text = new StringBuffer();
+
+ if (m_trainInstances == null) {
+ text.append("ReliefF feature evaluator has not been built yet\n");
+ }
+ else {
+ text.append("\tReliefF Ranking Filter");
+ text.append("\n\tInstances sampled: ");
+
+ if (m_sampleM == -1) {
+ text.append("all\n");
+ }
+ else {
+ text.append(m_sampleM + "\n");
+ }
+
+ text.append("\tNumber of nearest neighbours (k): " + m_Knn + "\n");
+
+ if (m_weightByDistance) {
+ text.append("\tExponentially decreasing (with distance) "
+ + "influence for\n"
+ + "\tnearest neighbours. Sigma: "
+ + m_sigma + "\n");
+ }
+ else {
+ text.append("\tEqual influence nearest neighbours\n");
+ }
+ }
+
+ return text.toString();
+ }
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result = super.getCapabilities();
+ result.disableAll();
+
+ // attributes
+ result.enable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.NUMERIC_ATTRIBUTES);
+ result.enable(Capability.DATE_ATTRIBUTES);
+ result.enable(Capability.MISSING_VALUES);
+
+ // class
+ result.enable(Capability.NOMINAL_CLASS);
+ result.enable(Capability.NUMERIC_CLASS);
+ result.enable(Capability.DATE_CLASS);
+ result.enable(Capability.MISSING_CLASS_VALUES);
+
+ return result;
+ }
+
+ /**
+ * Initializes a ReliefF attribute evaluator.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator (Instances data)
+ throws Exception {
+
+ int z, totalInstances;
+ Random r = new Random(m_seed);
+
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ m_trainInstances = data;
+ m_classIndex = m_trainInstances.classIndex();
+ m_numAttribs = m_trainInstances.numAttributes();
+ m_numInstances = m_trainInstances.numInstances();
+
+ if (m_trainInstances.attribute(m_classIndex).isNumeric()) {
+ m_numericClass = true;
+ }
+ else {
+ m_numericClass = false;
+ }
+
+ if (!m_numericClass) {
+ m_numClasses = m_trainInstances.attribute(m_classIndex).numValues();
+ }
+ else {
+ m_ndc = 0;
+ m_numClasses = 1;
+ m_nda = new double[m_numAttribs];
+ m_ndcda = new double[m_numAttribs];
+ }
+
+ if (m_weightByDistance) // set up the rank based weights
+ {
+ m_weightsByRank = new double[m_Knn];
+
+ for (int i = 0; i < m_Knn; i++) {
+ m_weightsByRank[i] =
+ Math.exp(-((i/(double)m_sigma)*(i/(double)m_sigma)));
+ }
+ }
+
+ // the final attribute weights
+ m_weights = new double[m_numAttribs];
+ // num classes (1 for numeric class) knn neighbours,
+ // and 0 = distance, 1 = instance index
+ m_karray = new double[m_numClasses][m_Knn][2];
+
+ if (!m_numericClass) {
+ m_classProbs = new double[m_numClasses];
+
+ for (int i = 0; i < m_numInstances; i++) {
+ m_classProbs[(int)m_trainInstances.instance(i).value(m_classIndex)]++;
+ }
+
+ for (int i = 0; i < m_numClasses; i++) {
+ m_classProbs[i] /= m_numInstances;
+ }
+ }
+
+ m_worst = new double[m_numClasses];
+ m_index = new int[m_numClasses];
+ m_stored = new int[m_numClasses];
+ m_minArray = new double[m_numAttribs];
+ m_maxArray = new double[m_numAttribs];
+
+ for (int i = 0; i < m_numAttribs; i++) {
+ m_minArray[i] = m_maxArray[i] = Double.NaN;
+ }
+
+ for (int i = 0; i < m_numInstances; i++) {
+ updateMinMax(m_trainInstances.instance(i));
+ }
+
+ if ((m_sampleM > m_numInstances) || (m_sampleM < 0)) {
+ totalInstances = m_numInstances;
+ }
+ else {
+ totalInstances = m_sampleM;
+ }
+
+ // process each instance, updating attribute weights
+ for (int i = 0; i < totalInstances; i++) {
+ if (totalInstances == m_numInstances) {
+ z = i;
+ }
+ else {
+ z = r.nextInt()%m_numInstances;
+ }
+
+ if (z < 0) {
+ z *= -1;
+ }
+
+ if (!(m_trainInstances.instance(z).isMissing(m_classIndex))) {
+ // first clear the knn and worst index stuff for the classes
+ for (int j = 0; j < m_numClasses; j++) {
+ m_index[j] = m_stored[j] = 0;
+
+ for (int k = 0; k < m_Knn; k++) {
+ m_karray[j][k][0] = m_karray[j][k][1] = 0;
+ }
+ }
+
+ findKHitMiss(z);
+
+ if (m_numericClass) {
+ updateWeightsNumericClass(z);
+ }
+ else {
+ updateWeightsDiscreteClass(z);
+ }
+ }
+ }
+
+ // now scale weights by 1/m_numInstances (nominal class) or
+ // calculate weights numeric class
+ // System.out.println("num inst:"+m_numInstances+" r_ndc:"+r_ndc);
+ for (int i = 0; i < m_numAttribs; i++) {if (i != m_classIndex) {
+ if (m_numericClass) {
+ m_weights[i] = m_ndcda[i]/m_ndc -
+ ((m_nda[i] - m_ndcda[i])/((double)totalInstances - m_ndc));
+ }
+ else {
+ m_weights[i] *= (1.0/(double)totalInstances);
+ }
+
+ // System.out.println(r_weights[i]);
+ }
+ }
+ }
+
+
+ /**
+ * Evaluates an individual attribute using ReliefF's instance based approach.
+ * The actual work is done by buildEvaluator which evaluates all features.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute (int attribute)
+ throws Exception {
+ return m_weights[attribute];
+ }
+
+
+ /**
+ * Reset options to their default values
+ */
+ protected void resetOptions () {
+ m_trainInstances = null;
+ m_sampleM = -1;
+ m_Knn = 10;
+ m_sigma = 2;
+ m_weightByDistance = false;
+ m_seed = 1;
+ }
+
+
+ /**
+ * Normalizes a given value of a numeric attribute.
+ *
+ * @param x the value to be normalized
+ * @param i the attribute's index
+ * @return the normalized value
+ */
+ private double norm (double x, int i) {
+ if (Double.isNaN(m_minArray[i]) ||
+ Utils.eq(m_maxArray[i], m_minArray[i])) {
+ return 0;
+ }
+ else {
+ return (x - m_minArray[i])/(m_maxArray[i] - m_minArray[i]);
+ }
+ }
+
+
+ /**
+ * Updates the minimum and maximum values for all the attributes
+ * based on a new instance.
+ *
+ * @param instance the new instance
+ */
+ private void updateMinMax (Instance instance) {
+ // for (int j = 0; j < m_numAttribs; j++) {
+ try {
+ for (int j = 0; j < instance.numValues(); j++) {
+ if ((instance.attributeSparse(j).isNumeric()) &&
+ (!instance.isMissingSparse(j))) {
+ if (Double.isNaN(m_minArray[instance.index(j)])) {
+ m_minArray[instance.index(j)] = instance.valueSparse(j);
+ m_maxArray[instance.index(j)] = instance.valueSparse(j);
+ }
+ else {
+ if (instance.valueSparse(j) < m_minArray[instance.index(j)]) {
+ m_minArray[instance.index(j)] = instance.valueSparse(j);
+ }
+ else {
+ if (instance.valueSparse(j) > m_maxArray[instance.index(j)]) {
+ m_maxArray[instance.index(j)] = instance.valueSparse(j);
+ }
+ }
+ }
+ }
+ }
+ } catch (Exception ex) {
+ System.err.println(ex);
+ ex.printStackTrace();
+ }
+ }
+
+ /**
+ * Computes the difference between two given attribute
+ * values.
+ */
+ private double difference(int index, double val1, double val2) {
+
+ switch (m_trainInstances.attribute(index).type()) {
+ case Attribute.NOMINAL:
+
+ // If attribute is nominal
+ if (Utils.isMissingValue(val1) ||
+ Utils.isMissingValue(val2)) {
+ return (1.0 - (1.0/((double)m_trainInstances.
+ attribute(index).numValues())));
+ } else if ((int)val1 != (int)val2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ case Attribute.NUMERIC:
+
+ // If attribute is numeric
+ if (Utils.isMissingValue(val1) ||
+ Utils.isMissingValue(val2)) {
+ if (Utils.isMissingValue(val1) &&
+ Utils.isMissingValue(val2)) {
+ return 1;
+ } else {
+ double diff;
+ if (Utils.isMissingValue(val2)) {
+ diff = norm(val1, index);
+ } else {
+ diff = norm(val2, index);
+ }
+ if (diff < 0.5) {
+ diff = 1.0 - diff;
+ }
+ return diff;
+ }
+ } else {
+ return Math.abs(norm(val1, index) - norm(val2, index));
+ }
+ default:
+ return 0;
+ }
+ }
+
+ /**
+ * Calculates the distance between two instances
+ *
+ * @param first the first instance
+ * @param second the second instance
+ * @return the distance between the two given instances, between 0 and 1
+ */
+ private double distance(Instance first, Instance second) {
+
+ double distance = 0;
+ int firstI, secondI;
+
+ for (int p1 = 0, p2 = 0;
+ p1 < first.numValues() || p2 < second.numValues();) {
+ if (p1 >= first.numValues()) {
+ firstI = m_trainInstances.numAttributes();
+ } else {
+ firstI = first.index(p1);
+ }
+ if (p2 >= second.numValues()) {
+ secondI = m_trainInstances.numAttributes();
+ } else {
+ secondI = second.index(p2);
+ }
+ if (firstI == m_trainInstances.classIndex()) {
+ p1++; continue;
+ }
+ if (secondI == m_trainInstances.classIndex()) {
+ p2++; continue;
+ }
+ double diff;
+ if (firstI == secondI) {
+ diff = difference(firstI,
+ first.valueSparse(p1),
+ second.valueSparse(p2));
+ p1++; p2++;
+ } else if (firstI > secondI) {
+ diff = difference(secondI,
+ 0, second.valueSparse(p2));
+ p2++;
+ } else {
+ diff = difference(firstI,
+ first.valueSparse(p1), 0);
+ p1++;
+ }
+ // distance += diff * diff;
+ distance += diff;
+ }
+
+ // return Math.sqrt(distance / m_NumAttributesUsed);
+ return distance;
+ }
+
+
+ /**
+ * update attribute weights given an instance when the class is numeric
+ *
+ * @param instNum the index of the instance to use when updating weights
+ */
+ private void updateWeightsNumericClass (int instNum) {
+ int i, j;
+ double temp,temp2;
+ int[] tempSorted = null;
+ double[] tempDist = null;
+ double distNorm = 1.0;
+ int firstI, secondI;
+
+ Instance inst = m_trainInstances.instance(instNum);
+
+ // sort nearest neighbours and set up normalization variable
+ if (m_weightByDistance) {
+ tempDist = new double[m_stored[0]];
+
+ for (j = 0, distNorm = 0; j < m_stored[0]; j++) {
+ // copy the distances
+ tempDist[j] = m_karray[0][j][0];
+ // sum normalizer
+ distNorm += m_weightsByRank[j];
+ }
+
+ tempSorted = Utils.sort(tempDist);
+ }
+
+ for (i = 0; i < m_stored[0]; i++) {
+ // P diff prediction (class) given nearest instances
+ if (m_weightByDistance) {
+ temp = difference(m_classIndex,
+ inst.value(m_classIndex),
+ m_trainInstances.
+ instance((int)m_karray[0][tempSorted[i]][1]).
+ value(m_classIndex));
+ temp *= (m_weightsByRank[i]/distNorm);
+ }
+ else {
+ temp = difference(m_classIndex,
+ inst.value(m_classIndex),
+ m_trainInstances.
+ instance((int)m_karray[0][i][1]).
+ value(m_classIndex));
+ temp *= (1.0/(double)m_stored[0]); // equal influence
+ }
+
+ m_ndc += temp;
+
+ Instance cmp;
+ cmp = (m_weightByDistance)
+ ? m_trainInstances.instance((int)m_karray[0][tempSorted[i]][1])
+ : m_trainInstances.instance((int)m_karray[0][i][1]);
+
+ double temp_diffP_diffA_givNearest =
+ difference(m_classIndex, inst.value(m_classIndex),
+ cmp.value(m_classIndex));
+ // now the attributes
+ for (int p1 = 0, p2 = 0;
+ p1 < inst.numValues() || p2 < cmp.numValues();) {
+ if (p1 >= inst.numValues()) {
+ firstI = m_trainInstances.numAttributes();
+ } else {
+ firstI = inst.index(p1);
+ }
+ if (p2 >= cmp.numValues()) {
+ secondI = m_trainInstances.numAttributes();
+ } else {
+ secondI = cmp.index(p2);
+ }
+ if (firstI == m_trainInstances.classIndex()) {
+ p1++; continue;
+ }
+ if (secondI == m_trainInstances.classIndex()) {
+ p2++; continue;
+ }
+ temp = 0.0;
+ temp2 = 0.0;
+
+ if (firstI == secondI) {
+ j = firstI;
+ temp = difference(j, inst.valueSparse(p1), cmp.valueSparse(p2));
+ p1++;p2++;
+ } else if (firstI > secondI) {
+ j = secondI;
+ temp = difference(j, 0, cmp.valueSparse(p2));
+ p2++;
+ } else {
+ j = firstI;
+ temp = difference(j, inst.valueSparse(p1), 0);
+ p1++;
+ }
+
+ temp2 = temp_diffP_diffA_givNearest * temp;
+ // P of different prediction and different att value given
+ // nearest instances
+ if (m_weightByDistance) {
+ temp2 *= (m_weightsByRank[i]/distNorm);
+ }
+ else {
+ temp2 *= (1.0/(double)m_stored[0]); // equal influence
+ }
+
+ m_ndcda[j] += temp2;
+
+ // P of different attribute val given nearest instances
+ if (m_weightByDistance) {
+ temp *= (m_weightsByRank[i]/distNorm);
+ }
+ else {
+ temp *= (1.0/(double)m_stored[0]); // equal influence
+ }
+
+ m_nda[j] += temp;
+ }
+ }
+ }
+
+
+ /**
+ * update attribute weights given an instance when the class is discrete
+ *
+ * @param instNum the index of the instance to use when updating weights
+ */
+ private void updateWeightsDiscreteClass (int instNum) {
+ int i, j, k;
+ int cl;
+ double temp_diff, w_norm = 1.0;
+ double[] tempDistClass;
+ int[] tempSortedClass = null;
+ double distNormClass = 1.0;
+ double[] tempDistAtt;
+ int[][] tempSortedAtt = null;
+ double[] distNormAtt = null;
+ int firstI, secondI;
+
+ // store the indexes (sparse instances) of non-zero elements
+ Instance inst = m_trainInstances.instance(instNum);
+
+ // get the class of this instance
+ cl = (int)m_trainInstances.instance(instNum).value(m_classIndex);
+
+ // sort nearest neighbours and set up normalization variables
+ if (m_weightByDistance) {
+ // do class (hits) first
+ // sort the distances
+ tempDistClass = new double[m_stored[cl]];
+
+ for (j = 0, distNormClass = 0; j < m_stored[cl]; j++) {
+ // copy the distances
+ tempDistClass[j] = m_karray[cl][j][0];
+ // sum normalizer
+ distNormClass += m_weightsByRank[j];
+ }
+
+ tempSortedClass = Utils.sort(tempDistClass);
+ // do misses (other classes)
+ tempSortedAtt = new int[m_numClasses][1];
+ distNormAtt = new double[m_numClasses];
+
+ for (k = 0; k < m_numClasses; k++) {
+ if (k != cl) // already done cl
+ {
+ // sort the distances
+ tempDistAtt = new double[m_stored[k]];
+
+ for (j = 0, distNormAtt[k] = 0; j < m_stored[k]; j++) {
+ // copy the distances
+ tempDistAtt[j] = m_karray[k][j][0];
+ // sum normalizer
+ distNormAtt[k] += m_weightsByRank[j];
+ }
+
+ tempSortedAtt[k] = Utils.sort(tempDistAtt);
+ }
+ }
+ }
+
+ if (m_numClasses > 2) {
+ // the amount of probability space left after removing the
+ // probability of this instance's class value
+ w_norm = (1.0 - m_classProbs[cl]);
+ }
+
+ // do the k nearest hits of the same class
+ for (j = 0, temp_diff = 0.0; j < m_stored[cl]; j++) {
+ Instance cmp;
+ cmp = (m_weightByDistance)
+ ? m_trainInstances.
+ instance((int)m_karray[cl][tempSortedClass[j]][1])
+ : m_trainInstances.instance((int)m_karray[cl][j][1]);
+
+ for (int p1 = 0, p2 = 0;
+ p1 < inst.numValues() || p2 < cmp.numValues();) {
+ if (p1 >= inst.numValues()) {
+ firstI = m_trainInstances.numAttributes();
+ } else {
+ firstI = inst.index(p1);
+ }
+ if (p2 >= cmp.numValues()) {
+ secondI = m_trainInstances.numAttributes();
+ } else {
+ secondI = cmp.index(p2);
+ }
+ if (firstI == m_trainInstances.classIndex()) {
+ p1++; continue;
+ }
+ if (secondI == m_trainInstances.classIndex()) {
+ p2++; continue;
+ }
+ if (firstI == secondI) {
+ i = firstI;
+ temp_diff = difference(i, inst.valueSparse(p1),
+ cmp.valueSparse(p2));
+ p1++;p2++;
+ } else if (firstI > secondI) {
+ i = secondI;
+ temp_diff = difference(i, 0, cmp.valueSparse(p2));
+ p2++;
+ } else {
+ i = firstI;
+ temp_diff = difference(i, inst.valueSparse(p1), 0);
+ p1++;
+ }
+
+ if (m_weightByDistance) {
+ temp_diff *=
+ (m_weightsByRank[j]/distNormClass);
+ } else {
+ if (m_stored[cl] > 0) {
+ temp_diff /= (double)m_stored[cl];
+ }
+ }
+ m_weights[i] -= temp_diff;
+
+ }
+ }
+
+
+ // now do k nearest misses from each of the other classes
+ temp_diff = 0.0;
+
+ for (k = 0; k < m_numClasses; k++) {
+ if (k != cl) // already done cl
+ {
+ for (j = 0; j < m_stored[k]; j++) {
+ Instance cmp;
+ cmp = (m_weightByDistance)
+ ? m_trainInstances.
+ instance((int)m_karray[k][tempSortedAtt[k][j]][1])
+ : m_trainInstances.instance((int)m_karray[k][j][1]);
+
+ for (int p1 = 0, p2 = 0;
+ p1 < inst.numValues() || p2 < cmp.numValues();) {
+ if (p1 >= inst.numValues()) {
+ firstI = m_trainInstances.numAttributes();
+ } else {
+ firstI = inst.index(p1);
+ }
+ if (p2 >= cmp.numValues()) {
+ secondI = m_trainInstances.numAttributes();
+ } else {
+ secondI = cmp.index(p2);
+ }
+ if (firstI == m_trainInstances.classIndex()) {
+ p1++; continue;
+ }
+ if (secondI == m_trainInstances.classIndex()) {
+ p2++; continue;
+ }
+ if (firstI == secondI) {
+ i = firstI;
+ temp_diff = difference(i, inst.valueSparse(p1),
+ cmp.valueSparse(p2));
+ p1++;p2++;
+ } else if (firstI > secondI) {
+ i = secondI;
+ temp_diff = difference(i, 0, cmp.valueSparse(p2));
+ p2++;
+ } else {
+ i = firstI;
+ temp_diff = difference(i, inst.valueSparse(p1), 0);
+ p1++;
+ }
+
+ if (m_weightByDistance) {
+ temp_diff *=
+ (m_weightsByRank[j]/distNormAtt[k]);
+ }
+ else {
+ if (m_stored[k] > 0) {
+ temp_diff /= (double)m_stored[k];
+ }
+ }
+ if (m_numClasses > 2) {
+ m_weights[i] += ((m_classProbs[k]/w_norm)*temp_diff);
+ } else {
+ m_weights[i] += temp_diff;
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Find the K nearest instances to supplied instance if the class is numeric,
+ * or the K nearest Hits (same class) and Misses (K from each of the other
+ * classes) if the class is discrete.
+ *
+ * @param instNum the index of the instance to find nearest neighbours of
+ */
+ private void findKHitMiss (int instNum) {
+ int i, j;
+ int cl;
+ double ww;
+ double temp_diff = 0.0;
+ Instance thisInst = m_trainInstances.instance(instNum);
+
+ for (i = 0; i < m_numInstances; i++) {
+ if (i != instNum) {
+ Instance cmpInst = m_trainInstances.instance(i);
+ temp_diff = distance(cmpInst, thisInst);
+
+ // class of this training instance or 0 if numeric
+ if (m_numericClass) {
+ cl = 0;
+ }
+ else {
+ cl = (int)m_trainInstances.instance(i).value(m_classIndex);
+ }
+
+ // add this diff to the list for the class of this instance
+ if (m_stored[cl] < m_Knn) {
+ m_karray[cl][m_stored[cl]][0] = temp_diff;
+ m_karray[cl][m_stored[cl]][1] = i;
+ m_stored[cl]++;
+
+ // note the worst diff for this class
+ for (j = 0, ww = -1.0; j < m_stored[cl]; j++) {
+ if (m_karray[cl][j][0] > ww) {
+ ww = m_karray[cl][j][0];
+ m_index[cl] = j;
+ }
+ }
+
+ m_worst[cl] = ww;
+ }
+ else
+ /* if we already have stored knn for this class then check to
+ see if this instance is better than the worst */
+ {
+ if (temp_diff < m_karray[cl][m_index[cl]][0]) {
+ m_karray[cl][m_index[cl]][0] = temp_diff;
+ m_karray[cl][m_index[cl]][1] = i;
+
+ for (j = 0, ww = -1.0; j < m_stored[cl]; j++) {
+ if (m_karray[cl][j][0] > ww) {
+ ww = m_karray[cl][j][0];
+ m_index[cl] = j;
+ }
+ }
+
+ m_worst[cl] = ww;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 5987 $");
+ }
+
+ // ============
+ // Test method.
+ // ============
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main (String[] args) {
+ runEvaluator(new ReliefFAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/SVMAttributeEval.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/SVMAttributeEval.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/SVMAttributeEval.java (revision 29)
@@ -0,0 +1,837 @@
+/*
+ * 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.
+ */
+
+/*
+ * SVMAttributeEval.java
+ * Copyright (C) 2002 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package weka.attributeSelection;
+
+import weka.classifiers.functions.SMO;
+import weka.core.Capabilities;
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SelectedTag;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.Capabilities.Capability;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+import weka.filters.Filter;
+import weka.filters.unsupervised.attribute.MakeIndicator;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Vector;
+
+/**
+
+ * SVMAttributeEval :
+ *
+ * Evaluates the worth of an attribute by using an SVM classifier. Attributes are ranked by the square of the weight assigned by the SVM. Attribute selection for multiclass problems is handled by ranking attributes for each class seperately using a one-vs-all method and then "dealing" from the top of each pile to give a final ranking.
+ *
+ * For more information see:
+ *
+ * I. Guyon, J. Weston, S. Barnhill, V. Vapnik (2002). Gene selection for cancer classification using support vector machines. Machine Learning. 46:389-422.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @article{Guyon2002,
+ * author = {I. Guyon and J. Weston and S. Barnhill and V. Vapnik},
+ * journal = {Machine Learning},
+ * pages = {389-422},
+ * title = {Gene selection for cancer classification using support vector machines},
+ * volume = {46},
+ * year = {2002}
+ * }
+ *
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -X <constant rate of elimination>
+ * Specify the constant rate of attribute
+ * elimination per invocation of
+ * the support vector machine.
+ * Default = 1.
+ *
+ * -Y <percent rate of elimination>
+ * Specify the percentage rate of attributes to
+ * elimination per invocation of
+ * the support vector machine.
+ * Trumps constant rate (above threshold).
+ * Default = 0.
+ *
+ * -Z <threshold for percent elimination>
+ * Specify the threshold below which
+ * percentage attribute elimination
+ * reverts to the constant method.
+ *
+ * -P <epsilon>
+ * Specify the value of P (epsilon
+ * parameter) to pass on to the
+ * support vector machine.
+ * Default = 1.0e-25
+ *
+ * -T <tolerance>
+ * Specify the value of T (tolerance
+ * parameter) to pass on to the
+ * support vector machine.
+ * Default = 1.0e-10
+ *
+ * -C <complexity>
+ * Specify the value of C (complexity
+ * parameter) to pass on to the
+ * support vector machine.
+ * Default = 1.0
+ *
+ * -N
+ * Whether the SVM should 0=normalize/1=standardize/2=neither.
+ * (default 0=normalize)
+ *
+
+ *
+ * @author Eibe Frank (eibe@cs.waikato.ac.nz)
+ * @author Mark Hall (mhall@cs.waikato.ac.nz)
+ * @author Kieran Holland
+ * @version $Revision: 1.28 $
+ */
+public class SVMAttributeEval
+ extends ASEvaluation
+ implements AttributeEvaluator,
+ OptionHandler,
+ TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -6489975709033967447L;
+
+ /** The attribute scores */
+ private double[] m_attScores;
+
+ /** Constant rate of attribute elimination per iteration */
+ private int m_numToEliminate = 1;
+
+ /** Percentage rate of attribute elimination, trumps constant
+ rate (above threshold), ignored if = 0 */
+ private int m_percentToEliminate = 0;
+
+ /** Threshold below which percent elimination switches to
+ constant elimination */
+ private int m_percentThreshold = 0;
+
+ /** Complexity parameter to pass on to SMO */
+ private double m_smoCParameter = 1.0;
+
+ /** Tolerance parameter to pass on to SMO */
+ private double m_smoTParameter = 1.0e-10;
+
+ /** Epsilon parameter to pass on to SMO */
+ private double m_smoPParameter = 1.0e-25;
+
+ /** Filter parameter to pass on to SMO */
+ private int m_smoFilterType = 0;
+
+ /**
+ * Returns a string describing this attribute evaluator
+ * @return a description of the evaluator suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "SVMAttributeEval :\n\nEvaluates the worth of an attribute by "
+ + "using an SVM classifier. Attributes are ranked by the square of the "
+ + "weight assigned by the SVM. Attribute selection for multiclass "
+ + "problems is handled by ranking attributes for each class seperately "
+ + "using a one-vs-all method and then \"dealing\" from the top of "
+ + "each pile to give a final ranking.\n\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.ARTICLE);
+ result.setValue(Field.AUTHOR, "I. Guyon and J. Weston and S. Barnhill and V. Vapnik");
+ result.setValue(Field.YEAR, "2002");
+ result.setValue(Field.TITLE, "Gene selection for cancer classification using support vector machines");
+ result.setValue(Field.JOURNAL, "Machine Learning");
+ result.setValue(Field.VOLUME, "46");
+ result.setValue(Field.PAGES, "389-422");
+
+ return result;
+ }
+
+ /**
+ * Constructor
+ */
+ public SVMAttributeEval() {
+ resetOptions();
+ }
+
+ /**
+ * Returns an enumeration describing all the available options
+ *
+ * @return an enumeration of options
+ */
+ public Enumeration listOptions() {
+ Vector newVector = new Vector(4);
+
+ newVector.addElement(
+ new Option(
+ "\tSpecify the constant rate of attribute\n"
+ + "\telimination per invocation of\n"
+ + "\tthe support vector machine.\n"
+ + "\tDefault = 1.",
+ "X",
+ 1,
+ "-X "));
+
+ newVector.addElement(
+ new Option(
+ "\tSpecify the percentage rate of attributes to\n"
+ + "\telimination per invocation of\n"
+ + "\tthe support vector machine.\n"
+ + "\tTrumps constant rate (above threshold).\n"
+ + "\tDefault = 0.",
+ "Y",
+ 1,
+ "-Y "));
+
+ newVector.addElement(
+ new Option(
+ "\tSpecify the threshold below which \n"
+ + "\tpercentage attribute elimination\n"
+ + "\treverts to the constant method.",
+ "Z",
+ 1,
+ "-Z "));
+
+
+ newVector.addElement(
+ new Option(
+ "\tSpecify the value of P (epsilon\n"
+ + "\tparameter) to pass on to the\n"
+ + "\tsupport vector machine.\n"
+ + "\tDefault = 1.0e-25",
+ "P",
+ 1,
+ "-P "));
+
+ newVector.addElement(
+ new Option(
+ "\tSpecify the value of T (tolerance\n"
+ + "\tparameter) to pass on to the\n"
+ + "\tsupport vector machine.\n"
+ + "\tDefault = 1.0e-10",
+ "T",
+ 1,
+ "-T "));
+
+ newVector.addElement(
+ new Option(
+ "\tSpecify the value of C (complexity\n"
+ + "\tparameter) to pass on to the\n"
+ + "\tsupport vector machine.\n"
+ + "\tDefault = 1.0",
+ "C",
+ 1,
+ "-C "));
+
+ newVector.addElement(new Option("\tWhether the SVM should "
+ + "0=normalize/1=standardize/2=neither.\n"
+ + "\t(default 0=normalize)",
+ "N",
+ 1,
+ "-N"));
+
+ return newVector.elements();
+ }
+
+ /**
+ * Parses a given list of options.
+ *
+
+ * Valid options are:
+ *
+ * -X <constant rate of elimination>
+ * Specify the constant rate of attribute
+ * elimination per invocation of
+ * the support vector machine.
+ * Default = 1.
+ *
+ * -Y <percent rate of elimination>
+ * Specify the percentage rate of attributes to
+ * elimination per invocation of
+ * the support vector machine.
+ * Trumps constant rate (above threshold).
+ * Default = 0.
+ *
+ * -Z <threshold for percent elimination>
+ * Specify the threshold below which
+ * percentage attribute elimination
+ * reverts to the constant method.
+ *
+ * -P <epsilon>
+ * Specify the value of P (epsilon
+ * parameter) to pass on to the
+ * support vector machine.
+ * Default = 1.0e-25
+ *
+ * -T <tolerance>
+ * Specify the value of T (tolerance
+ * parameter) to pass on to the
+ * support vector machine.
+ * Default = 1.0e-10
+ *
+ * -C <complexity>
+ * Specify the value of C (complexity
+ * parameter) to pass on to the
+ * support vector machine.
+ * Default = 1.0
+ *
+ * -N
+ * Whether the SVM should 0=normalize/1=standardize/2=neither.
+ * (default 0=normalize)
+ *
+
+ *
+ * @param options the list of options as an array of strings
+ * @throws Exception if an error occurs
+ */
+ public void setOptions(String[] options) throws Exception {
+ String optionString;
+
+ optionString = Utils.getOption('X', options);
+ if (optionString.length() != 0) {
+ setAttsToEliminatePerIteration(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('Y', options);
+ if (optionString.length() != 0) {
+ setPercentToEliminatePerIteration(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('Z', options);
+ if (optionString.length() != 0) {
+ setPercentThreshold(Integer.parseInt(optionString));
+ }
+
+ optionString = Utils.getOption('P', options);
+ if (optionString.length() != 0) {
+ setEpsilonParameter((new Double(optionString)).doubleValue());
+ }
+
+ optionString = Utils.getOption('T', options);
+ if (optionString.length() != 0) {
+ setToleranceParameter((new Double(optionString)).doubleValue());
+ }
+
+ optionString = Utils.getOption('C', options);
+ if (optionString.length() != 0) {
+ setComplexityParameter((new Double(optionString)).doubleValue());
+ }
+
+ optionString = Utils.getOption('N', options);
+ if (optionString.length() != 0) {
+ setFilterType(new SelectedTag(Integer.parseInt(optionString), SMO.TAGS_FILTER));
+ } else {
+ setFilterType(new SelectedTag(SMO.FILTER_NORMALIZE, SMO.TAGS_FILTER));
+ }
+
+ Utils.checkForRemainingOptions(options);
+ }
+
+ /**
+ * Gets the current settings of SVMAttributeEval
+ *
+ * @return an array of strings suitable for passing to setOptions()
+ */
+ public String[] getOptions() {
+ String[] options = new String[14];
+ int current = 0;
+
+ options[current++] = "-X";
+ options[current++] = "" + getAttsToEliminatePerIteration();
+
+ options[current++] = "-Y";
+ options[current++] = "" + getPercentToEliminatePerIteration();
+
+ options[current++] = "-Z";
+ options[current++] = "" + getPercentThreshold();
+
+ options[current++] = "-P";
+ options[current++] = "" + getEpsilonParameter();
+
+ options[current++] = "-T";
+ options[current++] = "" + getToleranceParameter();
+
+ options[current++] = "-C";
+ options[current++] = "" + getComplexityParameter();
+
+ options[current++] = "-N";
+ options[current++] = "" + m_smoFilterType;
+
+ while (current < options.length) {
+ options[current++] = "";
+ }
+
+ return options;
+ }
+
+ //________________________________________________________________________
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String attsToEliminatePerIterationTipText() {
+ return "Constant rate of attribute elimination.";
+ }
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String percentToEliminatePerIterationTipText() {
+ return "Percent rate of attribute elimination.";
+ }
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String percentThresholdTipText() {
+ return "Threshold below which percent elimination reverts to constant elimination.";
+ }
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String epsilonParameterTipText() {
+ return "P epsilon parameter to pass to the SVM";
+ }
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String toleranceParameterTipText() {
+ return "T tolerance parameter to pass to the SVM";
+ }
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String complexityParameterTipText() {
+ return "C complexity parameter to pass to the SVM";
+ }
+
+ /**
+ * Returns a tip text for this property suitable for display in the
+ * GUI
+ *
+ * @return tip text string describing this property
+ */
+ public String filterTypeTipText() {
+ return "filtering used by the SVM";
+ }
+
+ //________________________________________________________________________
+
+ /**
+ * Set the constant rate of attribute elimination per iteration
+ *
+ * @param cRate the constant rate of attribute elimination per iteration
+ */
+ public void setAttsToEliminatePerIteration(int cRate) {
+ m_numToEliminate = cRate;
+ }
+
+ /**
+ * Get the constant rate of attribute elimination per iteration
+ *
+ * @return the constant rate of attribute elimination per iteration
+ */
+ public int getAttsToEliminatePerIteration() {
+ return m_numToEliminate;
+ }
+
+ /**
+ * Set the percentage of attributes to eliminate per iteration
+ *
+ * @param pRate percent of attributes to eliminate per iteration
+ */
+ public void setPercentToEliminatePerIteration(int pRate) {
+ m_percentToEliminate = pRate;
+ }
+
+ /**
+ * Get the percentage rate of attribute elimination per iteration
+ *
+ * @return the percentage rate of attribute elimination per iteration
+ */
+ public int getPercentToEliminatePerIteration() {
+ return m_percentToEliminate;
+ }
+
+ /**
+ * Set the threshold below which percentage elimination reverts to
+ * constant elimination.
+ *
+ * @param pThresh percent of attributes to eliminate per iteration
+ */
+ public void setPercentThreshold(int pThresh) {
+ m_percentThreshold = pThresh;
+ }
+
+ /**
+ * Get the threshold below which percentage elimination reverts to
+ * constant elimination.
+ *
+ * @return the threshold below which percentage elimination stops
+ */
+ public int getPercentThreshold() {
+ return m_percentThreshold;
+ }
+
+ /**
+ * Set the value of P for SMO
+ *
+ * @param svmP the value of P
+ */
+ public void setEpsilonParameter(double svmP) {
+ m_smoPParameter = svmP;
+ }
+
+ /**
+ * Get the value of P used with SMO
+ *
+ * @return the value of P
+ */
+ public double getEpsilonParameter() {
+ return m_smoPParameter;
+ }
+
+ /**
+ * Set the value of T for SMO
+ *
+ * @param svmT the value of T
+ */
+ public void setToleranceParameter(double svmT) {
+ m_smoTParameter = svmT;
+ }
+
+ /**
+ * Get the value of T used with SMO
+ *
+ * @return the value of T
+ */
+ public double getToleranceParameter() {
+ return m_smoTParameter;
+ }
+
+
+ /**
+ * Set the value of C for SMO
+ *
+ * @param svmC the value of C
+ */
+ public void setComplexityParameter(double svmC) {
+ m_smoCParameter = svmC;
+ }
+
+ /**
+ * Get the value of C used with SMO
+ *
+ * @return the value of C
+ */
+ public double getComplexityParameter() {
+ return m_smoCParameter;
+ }
+
+ /**
+ * The filtering mode to pass to SMO
+ *
+ * @param newType the new filtering mode
+ */
+ public void setFilterType(SelectedTag newType) {
+
+ if (newType.getTags() == SMO.TAGS_FILTER) {
+ m_smoFilterType = newType.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Get the filtering mode passed to SMO
+ *
+ * @return the filtering mode
+ */
+ public SelectedTag getFilterType() {
+
+ return new SelectedTag(m_smoFilterType, SMO.TAGS_FILTER);
+ }
+
+ //________________________________________________________________________
+
+ /**
+ * Returns the capabilities of this evaluator.
+ *
+ * @return the capabilities of this evaluator
+ * @see Capabilities
+ */
+ public Capabilities getCapabilities() {
+ Capabilities result;
+
+ result = new SMO().getCapabilities();
+
+ result.setOwner(this);
+
+ // only binary attributes are allowed, otherwise the NominalToBinary
+ // filter inside SMO will increase the number of attributes which in turn
+ // will lead to ArrayIndexOutOfBounds-Exceptions.
+ result.disable(Capability.NOMINAL_ATTRIBUTES);
+ result.enable(Capability.BINARY_ATTRIBUTES);
+ result.disableAllAttributeDependencies();
+
+ return result;
+ }
+
+ /**
+ * Initializes the evaluator.
+ *
+ * @param data set of instances serving as training data
+ * @throws Exception if the evaluator has not been
+ * generated successfully
+ */
+ public void buildEvaluator(Instances data) throws Exception {
+ // can evaluator handle data?
+ getCapabilities().testWithFail(data);
+
+ //System.out.println("Class attribute: " + data.attribute(data.classIndex()).name());
+ // Check settings
+ m_numToEliminate = (m_numToEliminate > 1) ? m_numToEliminate : 1;
+ m_percentToEliminate = (m_percentToEliminate < 100) ? m_percentToEliminate : 100;
+ m_percentToEliminate = (m_percentToEliminate > 0) ? m_percentToEliminate : 0;
+ m_percentThreshold = (m_percentThreshold < data.numAttributes()) ? m_percentThreshold : data.numAttributes() - 1;
+ m_percentThreshold = (m_percentThreshold > 0) ? m_percentThreshold : 0;
+
+ // Get ranked attributes for each class seperately, one-vs-all
+ int[][] attScoresByClass;
+ int numAttr = data.numAttributes() - 1;
+ if(data.numClasses()>2) {
+ attScoresByClass = new int[data.numClasses()][numAttr];
+ for (int i = 0; i < data.numClasses(); i++) {
+ attScoresByClass[i] = rankBySVM(i, data);
+ }
+ }
+ else {
+ attScoresByClass = new int[1][numAttr];
+ attScoresByClass[0] = rankBySVM(0, data);
+ }
+
+ // Cycle through class-specific ranked lists, poping top one off for each class
+ // and adding it to the overall ranked attribute list if it's not there already
+ ArrayList ordered = new ArrayList(numAttr);
+ for (int i = 0; i < numAttr; i++) {
+ for (int j = 0; j < (data.numClasses()>2 ? data.numClasses() : 1); j++) {
+ Integer rank = new Integer(attScoresByClass[j][i]);
+ if (!ordered.contains(rank))
+ ordered.add(rank);
+ }
+ }
+ m_attScores = new double[data.numAttributes()];
+ Iterator listIt = ordered.iterator();
+ for (double i = (double) numAttr; listIt.hasNext(); i = i - 1.0) {
+ m_attScores[((Integer) listIt.next()).intValue()] = i;
+ }
+ }
+
+ /**
+ * Get SVM-ranked attribute indexes (best to worst) selected for
+ * the class attribute indexed by classInd (one-vs-all).
+ */
+ private int[] rankBySVM(int classInd, Instances data) {
+ // Holds a mapping into the original array of attribute indices
+ int[] origIndices = new int[data.numAttributes()];
+ for (int i = 0; i < origIndices.length; i++)
+ origIndices[i] = i;
+
+ // Count down of number of attributes remaining
+ int numAttrLeft = data.numAttributes()-1;
+ // Ranked attribute indices for this class, one vs.all (highest->lowest)
+ int[] attRanks = new int[numAttrLeft];
+
+ try {
+ MakeIndicator filter = new MakeIndicator();
+ filter.setAttributeIndex("" + (data.classIndex() + 1));
+ filter.setNumeric(false);
+ filter.setValueIndex(classInd);
+ filter.setInputFormat(data);
+ Instances trainCopy = Filter.useFilter(data, filter);
+ double pctToElim = ((double) m_percentToEliminate) / 100.0;
+ while (numAttrLeft > 0) {
+ int numToElim;
+ if (pctToElim > 0) {
+ numToElim = (int) (trainCopy.numAttributes() * pctToElim);
+ numToElim = (numToElim > 1) ? numToElim : 1;
+ if (numAttrLeft - numToElim <= m_percentThreshold) {
+ pctToElim = 0;
+ numToElim = numAttrLeft - m_percentThreshold;
+ }
+ } else {
+ numToElim = (numAttrLeft >= m_numToEliminate) ? m_numToEliminate : numAttrLeft;
+ }
+
+ // Build the linear SVM with default parameters
+ SMO smo = new SMO();
+
+ // SMO seems to get stuck if data not normalised when few attributes remain
+ // smo.setNormalizeData(numAttrLeft < 40);
+ smo.setFilterType(new SelectedTag(m_smoFilterType, SMO.TAGS_FILTER));
+ smo.setEpsilon(m_smoPParameter);
+ smo.setToleranceParameter(m_smoTParameter);
+ smo.setC(m_smoCParameter);
+ smo.buildClassifier(trainCopy);
+
+ // Find the attribute with maximum weight^2
+ double[] weightsSparse = smo.sparseWeights()[0][1];
+ int[] indicesSparse = smo.sparseIndices()[0][1];
+ double[] weights = new double[trainCopy.numAttributes()];
+ for (int j = 0; j < weightsSparse.length; j++) {
+ weights[indicesSparse[j]] = weightsSparse[j] * weightsSparse[j];
+ }
+ weights[trainCopy.classIndex()] = Double.MAX_VALUE;
+ int minWeightIndex;
+ int[] featArray = new int[numToElim];
+ boolean[] eliminated = new boolean[origIndices.length];
+ for (int j = 0; j < numToElim; j++) {
+ minWeightIndex = Utils.minIndex(weights);
+ attRanks[--numAttrLeft] = origIndices[minWeightIndex];
+ featArray[j] = minWeightIndex;
+ eliminated[minWeightIndex] = true;
+ weights[minWeightIndex] = Double.MAX_VALUE;
+ }
+
+ // Delete the worst attributes.
+ weka.filters.unsupervised.attribute.Remove delTransform =
+ new weka.filters.unsupervised.attribute.Remove();
+ delTransform.setInvertSelection(false);
+ delTransform.setAttributeIndicesArray(featArray);
+ delTransform.setInputFormat(trainCopy);
+ trainCopy = Filter.useFilter(trainCopy, delTransform);
+
+ // Update the array of remaining attribute indices
+ int[] temp = new int[origIndices.length - numToElim];
+ int k = 0;
+ for (int j = 0; j < origIndices.length; j++) {
+ if (!eliminated[j]) {
+ temp[k++] = origIndices[j];
+ }
+ }
+ origIndices = temp;
+ }
+ // Carefully handle all exceptions
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return attRanks;
+ }
+
+ /**
+ * Resets options to defaults.
+ */
+ protected void resetOptions() {
+ m_attScores = null;
+ }
+
+ /**
+ * Evaluates an attribute by returning the rank of the square of its coefficient in a
+ * linear support vector machine.
+ *
+ * @param attribute the index of the attribute to be evaluated
+ * @throws Exception if the attribute could not be evaluated
+ */
+ public double evaluateAttribute(int attribute) throws Exception {
+ return m_attScores[attribute];
+ }
+
+ /**
+ * Return a description of the evaluator
+ * @return description as a string
+ */
+ public String toString() {
+
+ StringBuffer text = new StringBuffer();
+ if (m_attScores == null) {
+ text.append("\tSVM feature evaluator has not been built yet");
+ } else {
+ text.append("\tSVM feature evaluator");
+ }
+
+ text.append("\n");
+ return text.toString();
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.28 $");
+ }
+
+ /**
+ * Main method for testing this class.
+ *
+ * @param args the options
+ */
+ public static void main(String[] args) {
+ runEvaluator(new SVMAttributeEval(), args);
+ }
+}
Index: branches/MetisMQI/src/main/java/weka/attributeSelection/ScatterSearchV1.java
===================================================================
--- branches/MetisMQI/src/main/java/weka/attributeSelection/ScatterSearchV1.java (revision 29)
+++ branches/MetisMQI/src/main/java/weka/attributeSelection/ScatterSearchV1.java (revision 29)
@@ -0,0 +1,1312 @@
+/*
+ * 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.
+ */
+
+/*
+ * ScatterSearchV1.java
+ * Copyright (C) 2008 Adrian Pino
+ * Copyright (C) 2008 University of Waikato, Hamilton, NZ
+ *
+ */
+
+package weka.attributeSelection;
+
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Random;
+import java.util.Vector;
+
+import weka.core.Instances;
+import weka.core.Option;
+import weka.core.OptionHandler;
+import weka.core.RevisionUtils;
+import weka.core.SelectedTag;
+import weka.core.Tag;
+import weka.core.TechnicalInformation;
+import weka.core.TechnicalInformationHandler;
+import weka.core.Utils;
+import weka.core.TechnicalInformation.Field;
+import weka.core.TechnicalInformation.Type;
+
+
+/**
+ * Class for performing the Sequential Scatter Search.
+ *
+
+ * Scatter Search :
+ *
+ * Performs an Scatter Search through the space of attribute subsets. Start with a population of many significants and diverses subset stops when the result is higher than a given treshold or there's not more improvement
+ * For more information see:
+ *
+ * Felix Garcia Lopez (2004). Solving feature subset selection problem by a Parallel Scatter Search. Elsevier.
+ *
+
+ *
+
+ * Valid options are:
+ *
+ * -Z <num>
+ * Specify the number of subsets to generate
+ * in the initial population..
+ *
+ * -T <threshold>
+ * Specify the treshold used for considering when a subset is significant.
+ *
+ * -R <0 = greedy combination | 1 = reduced greedy combination >
+ * Specify the kind of combiantion
+ * for using it in the combination method.
+ *
+ * -S <seed>
+ * Set the random number seed.
+ * (default = 1)
+ *
+ * -D
+ * Verbose output for monitoring the search.
+ *
+
+ *
+
+ * BibTeX:
+ *
+ * @book{Lopez2004,
+ * author = {Felix Garcia Lopez},
+ * month = {October},
+ * publisher = {Elsevier},
+ * title = {Solving feature subset selection problem by a Parallel Scatter Search},
+ * year = {2004},
+ * language = {English}
+ * }
+ *
+ *
+
+ *
+ * from the Book: Solving feature subset selection problem by a Parallel Scatter Search, Felix Garcia Lopez.
+ * @author Adrian Pino (apinoa@facinf.uho.edu.cu)
+ * @version $Revision: 4977 $
+ *
+ */
+
+public class ScatterSearchV1 extends ASSearch
+ implements OptionHandler, TechnicalInformationHandler {
+
+ /** for serialization */
+ static final long serialVersionUID = -8512041420388121326L;
+
+ /** number of attributes in the data */
+ private int m_numAttribs;
+
+ /** holds the class index */
+ private int m_classIndex;
+
+ /** holds the treshhold that delimits the good attributes */
+ private double m_treshold;
+
+ /** the initial threshold */
+ private double m_initialThreshold;
+
+ /** the kind of comination betwen parents ((0)greedy combination/(1)reduced greedy combination)*/
+ int m_typeOfCombination;
+
+ /** random number generation */
+ private Random m_random;
+
+ /** seed for random number generation */
+ private int m_seed;
+
+ /** verbose output for monitoring the search and debugging */
+ private boolean m_debug = false;
+
+ /** holds a report of the search */
+ private StringBuffer m_InformationReports;
+
+ /** total number of subsets evaluated during a search */
+ private int m_totalEvals;
+
+ /** holds the merit of the best subset found */
+ protected double m_bestMerit;
+
+ /** time for procesing the search method */
+ private long m_processinTime;
+
+ /** holds the Initial Population of Subsets*/
+ private List m_population;
+
+ /** holds the population size*/
+ private int m_popSize;
+
+ /** holds the user selected initial population size */
+ private int m_initialPopSize;
+
+ /** if no initial user pop size, then this holds the initial
+ * pop size calculated from the number of attributes in the data
+ * (for use in the toString() method)
+ */
+ private int m_calculatedInitialPopSize;
+
+ /** holds the subsets most significants and diverses
+ * of the population (ReferenceSet).
+ *
+ * (transient because the subList() method returns
+ * a non serializable Object).
+ */
+ private transient List m_ReferenceSet;
+
+ /** holds the greedy combination(reduced or not) of all the subsets of the ReferenceSet*/
+ private transient List m_parentsCombination;
+
+ /**holds the attributes ranked*/
+ private List m_attributeRanking;
+
+ /**Evaluator used to know the significance of a subset (for guiding the search)*/
+ private SubsetEvaluator ASEvaluator =null;
+
+
+ /** kind of combination */
+ protected static final int COMBINATION_NOT_REDUCED = 0;
+ protected static final int COMBINATION_REDUCED = 1; ;
+ public static final Tag [] TAGS_SELECTION = {
+ new Tag(COMBINATION_NOT_REDUCED, "Greedy Combination"),
+ new Tag(COMBINATION_REDUCED, "Reduced Greedy Combination")
+ };
+
+ /**
+ * Returns a string describing this search method
+ * @return a description of the search suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String globalInfo() {
+ return "Scatter Search :\n\nPerforms an Scatter Search "
+ +"through "
+ +"the space of attribute subsets. Start with a population of many significants and diverses subset "
+ +" stops when the result is higher than a given treshold or there's not more improvement\n"
+ + "For more information see:\n\n"
+ + getTechnicalInformation().toString();
+ }
+
+ /**
+ * Returns an instance of a TechnicalInformation object, containing
+ * detailed information about the technical background of this class,
+ * e.g., paper reference or book this class is based on.
+ *
+ * @return the technical information about this class
+ */
+ public TechnicalInformation getTechnicalInformation() {
+ TechnicalInformation result;
+
+ result = new TechnicalInformation(Type.BOOK);
+ result.setValue(Field.AUTHOR, "Felix Garcia Lopez");
+ result.setValue(Field.MONTH, "October");
+ result.setValue(Field.YEAR, "2004");
+ result.setValue(Field.TITLE, "Solving feature subset selection problem by a Parallel Scatter Search");
+ result.setValue(Field.PUBLISHER, "Elsevier");
+ result.setValue(Field.LANGUAGE, "English");
+
+ return result;
+ }
+
+ /**
+ * Returns the revision string.
+ *
+ * @return the revision
+ */
+ public String getRevision() {
+ return RevisionUtils.extract("$Revision: 1.0$");
+ }
+
+ public ScatterSearchV1 () {
+ resetOptions();
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String tresholdTipText() {
+ return "Set the treshold that subsets most overcome to be considered as significants";
+ }
+
+ /**
+ * Set the treshold
+ *
+ * @param treshold for identifyng significant subsets
+ */
+ public void setTreshold (double treshold) {
+ m_initialThreshold = treshold;
+ }
+
+ /**
+ * Get the treshold
+ *
+ * @return the treshold that subsets most overcome to be considered as significants
+ */
+ public double getTreshold () {
+ return m_initialThreshold;
+ }
+
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String populationSizeTipText() {
+ return "Set the number of subset to generate in the initial Population";
+ }
+
+ /**
+ * Set the population size
+ *
+ * @param size the number of subset in the initial population
+ */
+ public void setPopulationSize (int size) {
+ m_initialPopSize = size;
+ }
+
+ /**
+ * Get the population size
+ *
+ * @return the number of subsets to generate in the initial population
+ */
+ public int getPopulationSize () {
+ return m_initialPopSize;
+ }
+
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String combinationTipText() {
+ return "Set the kind of combination for using it to combine ReferenceSet subsets.";
+ }
+
+ /**
+ * Set the kind of combination
+ *
+ * @param c the kind of combination of the search
+ */
+ public void setCombination (SelectedTag c) {
+ if (c.getTags() == TAGS_SELECTION) {
+ m_typeOfCombination = c.getSelectedTag().getID();
+ }
+ }
+
+ /**
+ * Get the combination
+ *
+ * @return the kind of combination used in the Combination method
+ */
+ public SelectedTag getCombination () {
+ return new SelectedTag(m_typeOfCombination, TAGS_SELECTION);
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String seedTipText() {
+ return "Set the random seed.";
+ }
+
+ /**
+ * set the seed for random number generation
+ * @param s seed value
+ */
+ public void setSeed(int s) {
+ m_seed = s;
+ }
+
+ /**
+ * get the value of the random number generator's seed
+ * @return the seed for random number generation
+ */
+ public int getSeed() {
+ return m_seed;
+ }
+
+ /**
+ * Returns the tip text for this property
+ * @return tip text for this property suitable for
+ * displaying in the explorer/experimenter gui
+ */
+ public String debugTipText() {
+ return "Turn on verbose output for monitoring the search's progress.";
+ }
+
+ /**
+ * Set whether verbose output should be generated.
+ * @param d true if output is to be verbose.
+ */
+ public void setDebug(boolean d) {
+ m_debug = d;
+ }
+
+ /**
+ * Get whether output is to be verbose
+ * @return true if output will be verbose
+ */
+ public boolean getDebug() {
+ return m_debug;
+ }
+
+ /**
+ * Returns an enumeration describing the available options.
+ * @return an enumeration of all the available options.
+ **/
+ public Enumeration listOptions () {
+ Vector newVector = new Vector(6);
+
+ newVector.addElement(new Option("\tSpecify the number of subsets to generate "
+ + "\n\tin the initial population.."
+ ,"Z",1
+ , "-Z