/*
* 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.
*/
/*
* Grading.java
* Copyright (C) 2000 University of Waikato
*
*/
package weka.classifiers.meta;
import weka.classifiers.Classifier;
import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
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.util.Random;
import weka.classifiers.AbstractClassifier;
import weka.core.DenseInstance;
/**
<!-- globalinfo-start -->
* Implements Grading. The base classifiers are "graded".<br/>
* <br/>
* For more information, see<br/>
* <br/>
* A.K. Seewald, J. Fuernkranz: An Evaluation of Grading Classifiers. In: Advances in Intelligent Data Analysis: 4th International Conference, Berlin/Heidelberg/New York/Tokyo, 115-124, 2001.
* <p/>
<!-- globalinfo-end -->
*
<!-- technical-bibtex-start -->
* BibTeX:
* <pre>
* @inproceedings{Seewald2001,
* address = {Berlin/Heidelberg/New York/Tokyo},
* author = {A.K. Seewald and J. Fuernkranz},
* booktitle = {Advances in Intelligent Data Analysis: 4th International Conference},
* editor = {F. Hoffmann et al.},
* pages = {115-124},
* publisher = {Springer},
* title = {An Evaluation of Grading Classifiers},
* year = {2001}
* }
* </pre>
* <p/>
<!-- technical-bibtex-end -->
*
<!-- options-start -->
* Valid options are: <p/>
*
* <pre> -M <scheme specification>
* Full name of meta classifier, followed by options.
* (default: "weka.classifiers.rules.Zero")</pre>
*
* <pre> -X <number of folds>
* Sets the number of cross-validation folds.</pre>
*
* <pre> -S <num>
* Random number seed.
* (default 1)</pre>
*
* <pre> -B <classifier specification>
* Full class name of classifier to include, followed
* by scheme options. May be specified multiple times.
* (default: "weka.classifiers.rules.ZeroR")</pre>
*
* <pre> -D
* If set, classifier is run in debug mode and
* may output additional info to the console</pre>
*
<!-- options-end -->
*
* @author Alexander K. Seewald (alex@seewald.at)
* @author Eibe Frank (eibe@cs.waikato.ac.nz)
* @version $Revision: 1.13 $
*/
public class Grading
extends Stacking
implements TechnicalInformationHandler {
/** for serialization */
static final long serialVersionUID = 5207837947890081170L;
/** The meta classifiers, one for each base classifier. */
protected Classifier [] m_MetaClassifiers = new Classifier[0];
/** InstPerClass */
protected double [] m_InstPerClass = null;
/**
* Returns a string describing classifier
* @return a description suitable for
* displaying in the explorer/experimenter gui
*/
public String globalInfo() {
return
"Implements Grading. The base classifiers are \"graded\".\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, "A.K. Seewald and J. Fuernkranz");
result.setValue(Field.TITLE, "An Evaluation of Grading Classifiers");
result.setValue(Field.BOOKTITLE, "Advances in Intelligent Data Analysis: 4th International Conference");
result.setValue(Field.EDITOR, "F. Hoffmann et al.");
result.setValue(Field.YEAR, "2001");
result.setValue(Field.PAGES, "115-124");
result.setValue(Field.PUBLISHER, "Springer");
result.setValue(Field.ADDRESS, "Berlin/Heidelberg/New York/Tokyo");
return result;
}
/**
* Generates the meta data
*
* @param newData the data to work on
* @param random the random number generator used in the generation
* @throws Exception if generation fails
*/
protected void generateMetaLevel(Instances newData, Random random)
throws Exception {
m_MetaFormat = metaFormat(newData);
Instances [] metaData = new Instances[m_Classifiers.length];
for (int i = 0; i < m_Classifiers.length; i++) {
metaData[i] = metaFormat(newData);
}
for (int j = 0; j < m_NumFolds; j++) {
Instances train = newData.trainCV(m_NumFolds, j, random);
Instances test = newData.testCV(m_NumFolds, j);
// Build base classifiers
for (int i = 0; i < m_Classifiers.length; i++) {
getClassifier(i).buildClassifier(train);
for (int k = 0; k < test.numInstances(); k++) {
metaData[i].add(metaInstance(test.instance(k),i));
}
}
}
// calculate InstPerClass
m_InstPerClass = new double[newData.numClasses()];
for (int i=0; i < newData.numClasses(); i++) m_InstPerClass[i]=0.0;
for (int i=0; i < newData.numInstances(); i++) {
m_InstPerClass[(int)newData.instance(i).classValue()]++;
}
m_MetaClassifiers = AbstractClassifier.makeCopies(m_MetaClassifier,
m_Classifiers.length);
for (int i = 0; i < m_Classifiers.length; i++) {
m_MetaClassifiers[i].buildClassifier(metaData[i]);
}
}
/**
* Returns class probabilities for a given instance using the stacked classifier.
* One class will always get all the probability mass (i.e. probability one).
*
* @param instance the instance to be classified
* @throws Exception if instance could not be classified
* successfully
* @return the class distribution for the given instance
*/
public double[] distributionForInstance(Instance instance) throws Exception {
double maxPreds;
int numPreds=0;
int numClassifiers=m_Classifiers.length;
int idxPreds;
double [] predConfs = new double[numClassifiers];
double [] preds;
for (int i=0; i<numClassifiers; i++) {
preds = m_MetaClassifiers[i].distributionForInstance(metaInstance(instance,i));
if (m_MetaClassifiers[i].classifyInstance(metaInstance(instance,i))==1)
predConfs[i]=preds[1];
else
predConfs[i]=-preds[0];
}
if (predConfs[Utils.maxIndex(predConfs)]<0.0) { // no correct classifiers
for (int i=0; i<numClassifiers; i++) // use neg. confidences instead
predConfs[i]=1.0+predConfs[i];
} else {
for (int i=0; i<numClassifiers; i++) // otherwise ignore neg. conf
if (predConfs[i]<0) predConfs[i]=0.0;
}
/*System.out.print(preds[0]);
System.out.print(":");
System.out.print(preds[1]);
System.out.println("#");*/
preds=new double[instance.numClasses()];
for (int i=0; i<instance.numClasses(); i++) preds[i]=0.0;
for (int i=0; i<numClassifiers; i++) {
idxPreds=(int)(m_Classifiers[i].classifyInstance(instance));
preds[idxPreds]+=predConfs[i];
}
maxPreds=preds[Utils.maxIndex(preds)];
int MaxInstPerClass=-100;
int MaxClass=-1;
for (int i=0; i<instance.numClasses(); i++) {
if (preds[i]==maxPreds) {
numPreds++;
if (m_InstPerClass[i]>MaxInstPerClass) {
MaxInstPerClass=(int)m_InstPerClass[i];
MaxClass=i;
}
}
}
int predictedIndex;
if (numPreds==1)
predictedIndex = Utils.maxIndex(preds);
else
{
// System.out.print("?");
// System.out.print(instance.toString());
// for (int i=0; i<instance.numClasses(); i++) {
// System.out.print("/");
// System.out.print(preds[i]);
// }
// System.out.println(MaxClass);
predictedIndex = MaxClass;
}
double[] classProbs = new double[instance.numClasses()];
classProbs[predictedIndex] = 1.0;
return classProbs;
}
/**
* Output a representation of this classifier
*
* @return a string representation of the classifier
*/
public String toString() {
if (m_Classifiers.length == 0) {
return "Grading: No base schemes entered.";
}
if (m_MetaClassifiers.length == 0) {
return "Grading: No meta scheme selected.";
}
if (m_MetaFormat == null) {
return "Grading: No model built yet.";
}
String result = "Grading\n\nBase classifiers\n\n";
for (int i = 0; i < m_Classifiers.length; i++) {
result += getClassifier(i).toString() +"\n\n";
}
result += "\n\nMeta classifiers\n\n";
for (int i = 0; i < m_Classifiers.length; i++) {
result += m_MetaClassifiers[i].toString() +"\n\n";
}
return result;
}
/**
* Makes the format for the level-1 data.
*
* @param instances the level-0 format
* @return the format for the meta data
* @throws Exception if an error occurs
*/
protected Instances metaFormat(Instances instances) throws Exception {
FastVector attributes = new FastVector();
Instances metaFormat;
for (int i = 0; i<instances.numAttributes(); i++) {
if ( i != instances.classIndex() ) {
attributes.addElement(instances.attribute(i));
}
}
FastVector nomElements = new FastVector(2);
nomElements.addElement("0");
nomElements.addElement("1");
attributes.addElement(new Attribute("PredConf",nomElements));
metaFormat = new Instances("Meta format", attributes, 0);
metaFormat.setClassIndex(metaFormat.numAttributes()-1);
return metaFormat;
}
/**
* Makes a level-1 instance from the given instance.
*
* @param instance the instance to be transformed
* @param k index of the classifier
* @return the level-1 instance
* @throws Exception if an error occurs
*/
protected Instance metaInstance(Instance instance, int k) throws Exception {
double[] values = new double[m_MetaFormat.numAttributes()];
Instance metaInstance;
double predConf;
int i;
int maxIdx;
double maxVal;
int idx = 0;
for (i = 0; i < instance.numAttributes(); i++) {
if (i != instance.classIndex()) {
values[idx] = instance.value(i);
idx++;
}
}
Classifier classifier = getClassifier(k);
if (m_BaseFormat.classAttribute().isNumeric()) {
throw new Exception("Class Attribute must not be numeric!");
} else {
double[] dist = classifier.distributionForInstance(instance);
maxIdx=0;
maxVal=dist[0];
for (int j = 1; j < dist.length; j++) {
if (dist[j]>maxVal) {
maxVal=dist[j];
maxIdx=j;
}
}
predConf= (instance.classValue()==maxIdx) ? 1:0;
}
values[idx]=predConf;
metaInstance = new DenseInstance(1, values);
metaInstance.setDataset(m_MetaFormat);
return metaInstance;
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 1.13 $");
}
/**
* Main method for testing this class.
*
* @param argv should contain the following arguments:
* -t training file [-T test file] [-c class index]
*/
public static void main(String [] argv) {
runClassifier(new Grading(), argv);
}
}