de.fu_berlin.ties.classify
Class MetaClassifier

java.lang.Object
  extended by de.fu_berlin.ties.classify.TrainableClassifier
      extended by de.fu_berlin.ties.classify.MetaClassifier
All Implemented Interfaces:
Classifier, XMLStorable

public class MetaClassifier
extends TrainableClassifier

A meta classifier combines several layers of classifiers. For each layer (except the last one), there is a "judge" that decides whether or not the decision of this classifier is likely to be correct. If the judge decides that it is likely to be wrong, the next layer is invoked to correct the decision.

This classifier supports only error-driven training since it necessary to TOE train each classifier to decide whether to train the next one. Thus you always have to use the TrainableClassifier.trainOnError(FeatureVector, String, Set) method. Trying to call the TrainableClassifier.train(FeatureVector, String) method instead will result in an UnsupportedOperationException.

Instances of this class are thread-safe if and only if instances of the wrapped classifier are.

Version:
$Revision: 1.15 $, $Date: 2006/10/21 16:03:54 $, $Author: siefkes $
Author:
Christian Siefkes

Field Summary
 
Fields inherited from class de.fu_berlin.ties.classify.TrainableClassifier
ATTRIB_CLASSES, ATTRIB_TRAIN_ALL, ELEMENT_MAIN, META_CLASSIFIER, MULTI_CLASSIFIER, OAR_CLASSIFIER, TIE_CLASSIFIER
 
Fields inherited from interface de.fu_berlin.ties.classify.Classifier
CONFIG_CLASSIFIER
 
Constructor Summary
MetaClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, String[] innerSpec, int layers, String[] judgeSpec, Reranker judgeReranker, TiesConfiguration conf)
          Creates a new instance.
MetaClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, String[] innerSpec, TiesConfiguration conf)
          Creates a new instance.
 
Method Summary
 void destroy()
          Destroys the classifer.
protected  PredictionDistribution doClassify(FeatureVector features, Set candidateClasses, ContextMap context)
          Classifies an item that is represented by a feature vector by choosing the most probable class among a set of candidate classes.
protected  void doTrain(FeatureVector features, String targetClass, ContextMap context)
          This classifier supports only error-driven training, so you always have to use the TrainableClassifier.trainOnError(FeatureVector, String, Set) method instead of this one.
protected  boolean doTrainOnError(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          The core of the TrainableClassifier.trainOnError(FeatureVector, String, Set) method.
 void reset()
          Resets the classifer, completely deleting the prediction model.
protected  boolean shouldTrain(String targetClass, PredictionDistribution predDist, ContextMap context)
          Invoked by TrainableClassifier.trainOnError(FeatureVector, String, Set) to decide whether to train an instance.
 ObjectElement toElement()
          Stores all relevant fields of this object in an XML element for serialization. An equivalent object can be created by calling ObjectElement.createObject(org.dom4j.Element, Class) on the created element. Subclasses of TrainableClassifier should extend this method and the corresponding constructor from Element to ensure (de)serialization works as expected. Currently, this classifier does not support XML serialization, throwing an UnsupportedOperationException instead.
 String toString()
          Returns a string representation of this object.
protected  boolean trainOnErrorHook(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          Subclasses can implement this hook for more refined error-driven learning.
 
Methods inherited from class de.fu_berlin.ties.classify.TrainableClassifier
classify, createClassifier, createClassifier, createClassifier, createClassifier, createClassifier, getAllClasses, getConfig, train, trainOnError
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Constructor Detail

MetaClassifier

public MetaClassifier(Set<String> allValidClasses,
                      FeatureTransformer trans,
                      File runDirectory,
                      String[] innerSpec,
                      TiesConfiguration conf)
               throws ProcessingException
Creates a new instance.

Parameters:
allValidClasses - the set of all valid classes
trans - the last transformer in the transformer chain to use, or null if no feature transformers should be used
runDirectory - optional run directory passed to inner classifiers of the ExternalClassifier type
innerSpec - the specification used to initialize the inner classifiers, passed to the TrainableClassifier.createClassifier(Set, File, FeatureTransformer, String[], TiesConfiguration) factory method
conf - used to configure this instance and the inner classifiers
Throws:
ProcessingException - if an error occurred while creating this classifier or one of the wrapped classifiers

MetaClassifier

public MetaClassifier(Set<String> allValidClasses,
                      FeatureTransformer trans,
                      File runDirectory,
                      String[] innerSpec,
                      int layers,
                      String[] judgeSpec,
                      Reranker judgeReranker,
                      TiesConfiguration conf)
               throws ProcessingException
Creates a new instance.

Parameters:
allValidClasses - the set of all valid classes
trans - the last transformer in the transformer chain to use, or null if no feature transformers should be used
runDirectory - optional run directory passed to inner classifiers of the ExternalClassifier type
innerSpec - the specification used to initialize the inner classifiers, passed to the TrainableClassifier.createClassifier(Set, File, FeatureTransformer, String[], TiesConfiguration) factory method
layers - the number of layers to use, must be at least one
judgeSpec - the specification used to initialize the judges, passed to the TrainableClassifier.createClassifier(Set, File, FeatureTransformer, String[], TiesConfiguration) factory method
judgeReranker - used the rerank the predictions of the judges; might be null
conf - used to configure this instance as well as the inner classifiers and judges
Throws:
ProcessingException - if an error occurred while creating this classifier or one of the wrapped classifiers
Method Detail

destroy

public void destroy()
             throws ProcessingException
Destroys the classifer. This method must be called only if the classifier will never be used again. The default implementation delegates to TrainableClassifier.reset(), but subclasses can overwrite this behaviour if appropriate.

Specified by:
destroy in interface Classifier
Overrides:
destroy in class TrainableClassifier
Throws:
ProcessingException - if an error occurs while the classifier is being destroyed

doClassify

protected PredictionDistribution doClassify(FeatureVector features,
                                            Set candidateClasses,
                                            ContextMap context)
                                     throws ProcessingException
Classifies an item that is represented by a feature vector by choosing the most probable class among a set of candidate classes.

Specified by:
doClassify in class TrainableClassifier
Parameters:
features - the feature vector to consider
candidateClasses - an set of classes that are allowed for this item
context - can be used to transport implementation-specific contextual information between the TrainableClassifier.doClassify(FeatureVector, Set, ContextMap), TrainableClassifier.doTrain(FeatureVector, String, ContextMap), and TrainableClassifier.trainOnErrorHook(PredictionDistribution, FeatureVector, String, Set, ContextMap) methods
Returns:
the result of the classification; you can call PredictionDistribution.best() to get the most probably class
Throws:
ProcessingException - if an error occurs during classification

doTrain

protected void doTrain(FeatureVector features,
                       String targetClass,
                       ContextMap context)
                throws UnsupportedOperationException
This classifier supports only error-driven training, so you always have to use the TrainableClassifier.trainOnError(FeatureVector, String, Set) method instead of this one. Trying to call this method instead will result in anUnsupportedOperationException.

Specified by:
doTrain in class TrainableClassifier
Parameters:
features - ignored by this method
targetClass - ignored by this method
context - ignored by this method
Throws:
UnsupportedOperationException - always thrown by this method; use TrainableClassifier.trainOnError(FeatureVector, String, Set) instead

doTrainOnError

protected boolean doTrainOnError(PredictionDistribution predDist,
                                 FeatureVector features,
                                 String targetClass,
                                 Set candidateClasses,
                                 ContextMap context)
                          throws ProcessingException
The core of the TrainableClassifier.trainOnError(FeatureVector, String, Set) method. Generally there is no need for subclasses to modify this method.

Overrides:
doTrainOnError in class TrainableClassifier
Parameters:
predDist - the prediction distribution returned by TrainableClassifier.classify(FeatureVector, Set)
features - the feature vector to consider
targetClass - the expected class of this feature vector; must be contained in the set of candidateClasses
candidateClasses - an set of classes that are allowed for this item (the actual targetClass must be one of them)
context - can be used to transport implementation-specific contextual information between the TrainableClassifier.doClassify(FeatureVector, Set, ContextMap), TrainableClassifier.doTrain(FeatureVector, String, ContextMap), and TrainableClassifier.trainOnErrorHook(PredictionDistribution, FeatureVector, String, Set, ContextMap) methods
Returns:
the result of the TrainableClassifier.shouldTrain(String, PredictionDistribution, ContextMap) method
Throws:
ProcessingException - if an error occurs during training

reset

public void reset()
           throws ProcessingException
Resets the classifer, completely deleting the prediction model.

Specified by:
reset in class TrainableClassifier
Throws:
ProcessingException - if an error occurs during reset

shouldTrain

protected boolean shouldTrain(String targetClass,
                              PredictionDistribution predDist,
                              ContextMap context)
Invoked by TrainableClassifier.trainOnError(FeatureVector, String, Set) to decide whether to train an instance. The default behavior is to train if the best prediction was wrong or didn't yield a positive probability ("train only errors"). Subclasses can override this method to add their own behavior, e.g. reinforcement training (thick threshold heuristic).

Overrides:
shouldTrain in class TrainableClassifier
Parameters:
targetClass - the expected class of this feature vector; must be contained in the set of candidateClasses
predDist - the prediction distribution returned by TrainableClassifier.doClassify(FeatureVector, Set, ContextMap)
context - can be used to transport implementation-specific contextual information between the TrainableClassifier.doClassify(FeatureVector, Set, ContextMap), TrainableClassifier.doTrain(FeatureVector, String, ContextMap), and TrainableClassifier.trainOnErrorHook(PredictionDistribution, FeatureVector, String, Set, ContextMap) methods
Returns:
whether to train this instance

toElement

public ObjectElement toElement()
                        throws UnsupportedOperationException
Stores all relevant fields of this object in an XML element for serialization. An equivalent object can be created by calling ObjectElement.createObject(org.dom4j.Element, Class) on the created element. Subclasses of TrainableClassifier should extend this method and the corresponding constructor from Element to ensure (de)serialization works as expected. Currently, this classifier does not support XML serialization, throwing an UnsupportedOperationException instead.

Specified by:
toElement in interface XMLStorable
Overrides:
toElement in class TrainableClassifier
Returns:
the created XML element
Throws:
UnsupportedOperationException - always thrown by this implementation

toString

public String toString()
Returns a string representation of this object.

Overrides:
toString in class TrainableClassifier
Returns:
a textual representation

trainOnErrorHook

protected boolean trainOnErrorHook(PredictionDistribution predDist,
                                   FeatureVector features,
                                   String targetClass,
                                   Set candidateClasses,
                                   ContextMap context)
Subclasses can implement this hook for more refined error-driven learning. It is called from the TrainableClassifier.trainOnError(FeatureVector, String, Set) method after classifying. This method can do any necessary training itself and return true to signal that no further action is necessary. This implementation is just a placeholder that always returns false.

Overrides:
trainOnErrorHook in class TrainableClassifier
Parameters:
predDist - the prediction distribution returned by TrainableClassifier.classify(FeatureVector, Set)
features - the feature vector to consider
targetClass - the expected class of this feature vector; must be contained in the set of candidateClasses
candidateClasses - an set of classes that are allowed for this item (the actual targetClass must be one of them)
context - can be used to transport implementation-specific contextual information between the TrainableClassifier.doClassify(FeatureVector, Set, ContextMap), TrainableClassifier.doTrain(FeatureVector, String, ContextMap), and TrainableClassifier.trainOnErrorHook(PredictionDistribution, FeatureVector, String, Set, ContextMap) methods
Returns:
this implementation always returns false; subclasses can return true to signal that any error-driven learning was already handled


Copyright © 2003-2007 Christian Siefkes. All Rights Reserved.