Uses of Class
de.fu_berlin.ties.ProcessingException

Packages that use ProcessingException
de.fu_berlin.ties This package bundles main entry points and general interfaces and classes for the TIE software. 
de.fu_berlin.ties.classify This package provides functionality for classification of texts and feature vectors. 
de.fu_berlin.ties.classify.feature This package contains classes for working with features, feature vectors and feature transformers. 
de.fu_berlin.ties.classify.winnow This package contains the Winnow classification algorithm and related algorithms and classes. 
de.fu_berlin.ties.combi This package provides combination strategies for combining sequential classification decisions. 
de.fu_berlin.ties.context This packages provides functionality for building and managing representations of context in texts (XML documents). 
de.fu_berlin.ties.context.sensor Sensors are object that look up information for a token, for example semantic information from gazetteers or thesauri. 
de.fu_berlin.ties.eval This packages provides functionality for evaluating results of classifiers and extractors. 
de.fu_berlin.ties.extract This package handles information extraction and entitiy recognition. 
de.fu_berlin.ties.filter This packages provides generic filtering functionality and an implementation for sentence filtering. 
de.fu_berlin.ties.preprocess This packages handles format conversions and linguistic preprocessing of documents. 
de.fu_berlin.ties.xml.dom This package contains utility classes for working with DOM-like XML representations, focussing especially on dom4j
 

Uses of ProcessingException in de.fu_berlin.ties
 

Subclasses of ProcessingException in de.fu_berlin.ties
 class ParsingException
          Exception thrown when an input cannot be parsed, typically because it contains uncorrectable errors.
 

Methods in de.fu_berlin.ties that throw ProcessingException
 void Closeable.close(int errorCount)
          Closes this instance, releasing all resources and stopping any background threads.
 void CollectingProcessor.close(int errorCount)
          Closes this instance, releasing all resources and stopping any background threads.
protected  void DocumentReader.doProcess(Reader reader, Writer writer, ContextMap context)
          Processes the contents of a reader, writing a modified version to a writer.
protected abstract  void TextProcessor.doProcess(Reader reader, Writer writer, ContextMap context)
          Processes the contents of a reader, writing a modified version to a writer.
abstract  void DocumentProcessor.process(Document document, ContextMap context)
          Processes an XML document.
 void DocumentProcessor.process(Document document, Writer writer, ContextMap context)
          Processes an XML document, writing a modified version to a writer.
abstract  void DocumentReader.process(Document document, Writer writer, ContextMap context)
          Reads an XML document and stores the results of processing in a writer.
 void DirectoryProcessor.process(File directory)
          Processes the contents of a directory.
abstract  void DirectoryProcessor.process(File[] files, ContextMap context)
          Processes an array of files.
 void TextProcessor.process(File file, Writer writer)
          Processes the contents of a file, delegating to the TextProcessor.process(File, Writer, ContextMap) method.
 void TextProcessor.process(File file, Writer writer, ContextMap context)
          Processes the contents of a file, delegating to the TextProcessor.process(Reader, Writer, ContextMap) method.
abstract  void CollectingProcessor.process(List<String> collected, ContextMap context)
          Processes the collected input arguments.
 void TextProcessor.process(Reader reader, Writer writer, ContextMap context)
          Delegates to the abstract TextProcessor.doProcess(Reader, Writer, ContextMap) method and invokes a post-processor, if configured.
 void DirectoryProcessor.process(String inputName)
          Processes an input argument that must specify a directory.
 void Processor.process(String input)
          Processes an input argument.
 void TextProcessor.process(String inputName)
          Processes a file or URL given as input argument, delegating to the appropriate process method.
 void TextProcessor.process(URLConnection urlConn, Writer writer)
          Processes the contents of an URL connection, delegating to the TextProcessor.process(URLConnection, Writer, ContextMap) method.
 void TextProcessor.process(URLConnection urlConn, Writer writer, ContextMap context)
          Processes the contents of an URL connection, delegating to the TextProcessor.process(Reader, Writer, ContextMap) method.
 

Uses of ProcessingException in de.fu_berlin.ties.classify
 

Methods in de.fu_berlin.ties.classify that throw ProcessingException
 PredictionDistribution TrainableClassifier.classify(FeatureVector features, Set candidateClasses)
          Classifies an item that is represented by a feature vector by choosing the most probable class among a set of candidate classes.
 PredictionDistribution Classifier.classify(FeatureVector features, Set candidateClasses)
          Classifies an item that is represented by a feature vector by choosing the most probable class among a set of candidate classes.
 FieldContainer ClassTrain.classifyAndTrain(FieldContainer filesToClassify, File directory, String charset)
          Classifies a list of files, training the classifier on each error.
static TrainableClassifier TrainableClassifier.createClassifier(Set<String> allValidClasses)
          Factory method that delegates to TrainableClassifier.createClassifier(Set, TiesConfiguration) using the standard configuration.
static TrainableClassifier TrainableClassifier.createClassifier(Set<String> allValidClasses, File runDirectory, FeatureTransformer trans, String[] spec, TiesConfiguration conf)
          Factory method that creates a trainable classifier based on the provided specification.
static TrainableClassifier TrainableClassifier.createClassifier(Set<String> allValidClasses, File runDirectory, TiesConfiguration conf)
          Factory method that delegates to TrainableClassifier.createClassifier(Set, File, FeatureTransformer, String[], TiesConfiguration).
static TrainableClassifier TrainableClassifier.createClassifier(Set<String> allValidClasses, TiesConfiguration conf)
          Factory method that delegates to TrainableClassifier.createClassifier(Set, File, TiesConfiguration) without specifying an run directory.
protected  PredictionDistribution MetaClassifier.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  PredictionDistribution OneAgainstTheRestClassifier.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. This implementation combines the predictions for the positive class of all involved inner classifiers.
protected  PredictionDistribution ExternalClassifier.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 abstract  PredictionDistribution TrainableClassifier.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  PredictionDistribution MultiBinaryClassifier.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. This implementation combines the predictions for the foreground of all involved inner classifiers.
protected  void ClassTrain.doProcess(Reader reader, Writer writer, ContextMap context)
          Delegates to ClassTrain.classifyAndTrain(FieldContainer, File, String).
protected  void MetaClassifier.doTrain(FeatureVector features, String targetClass, ContextMap context)
          Incorporates an item that is represented by a feature vector into the classification model.
protected  void OneAgainstTheRestClassifier.doTrain(FeatureVector features, String targetClass, ContextMap context)
          Incorporates an item that is represented by a feature vector into the classification model.
protected  void ExternalClassifier.doTrain(FeatureVector features, String targetClass, ContextMap context)
          Incorporates an item that is represented by a feature vector into the classification model.
protected abstract  void TrainableClassifier.doTrain(FeatureVector features, String targetClass, ContextMap context)
          Incorporates an item that is represented by a feature vector into the classification model.
protected  void MultiBinaryClassifier.doTrain(FeatureVector features, String targetClass, ContextMap context)
          Incorporates an item that is represented by a feature vector into the classification model.
 void MetaClassifier.reset()
          Resets the classifer, completely deleting the prediction model.
 void OneAgainstTheRestClassifier.reset()
          Resets the classifer, completely deleting the prediction model.
 void ExternalClassifier.reset()
          Resets the classifer, completely deleting the prediction model.
abstract  void TrainableClassifier.reset()
          Resets the classifer, completely deleting the prediction model.
 void MultiBinaryClassifier.reset()
          Resets the classifer, completely deleting the prediction model.
 void TrainableClassifier.train(FeatureVector features, String targetClass)
          Incorporates an item that is represented by a feature vector into the classification model.
 PredictionDistribution TrainableClassifier.trainOnError(FeatureVector features, String targetClass, Set candidateClasses)
          Handles error-driven learning ("train only errors"): the specified feature vector is trained into the model only if the predicted class for the feature vector differs from the specified target class.
protected  boolean MetaClassifier.trainOnErrorHook(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          Subclasses can implement this hook for more refined error-driven learning.
protected  boolean OneAgainstTheRestClassifier.trainOnErrorHook(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          Subclasses can implement this hook for more refined error-driven learning.
protected  boolean TrainableClassifier.trainOnErrorHook(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          Subclasses can implement this hook for more refined error-driven learning.
protected  boolean MultiBinaryClassifier.trainOnErrorHook(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          Subclasses can implement this hook for more refined error-driven learning.
 

Constructors in de.fu_berlin.ties.classify that throw ProcessingException
ExternalClassifier(Set<String> allValidClasses)
          Creates a new instance based on the standard configuration.
ExternalClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, TiesConfiguration config)
          Creates a new instance based on the provided arguments.
ExternalClassifier(Set<String> allValidClasses, TiesConfiguration config)
          Creates a new instance based on the provided configuration.
MetaClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, String[] innerSpec, int layers, String[] judgeSpec, TiesConfiguration conf)
          Creates a new instance.
MetaClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, String[] innerSpec, TiesConfiguration conf)
          Creates a new instance.
MultiBinaryClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, String[] innerSpec, TiesConfiguration conf)
          Creates a new instance.
OneAgainstTheRestClassifier(Set<String> allValidClasses, FeatureTransformer trans, File runDirectory, String[] innerSpec, TiesConfiguration conf)
          Creates a new instance.
 

Uses of ProcessingException in de.fu_berlin.ties.classify.feature
 

Methods in de.fu_berlin.ties.classify.feature that throw ProcessingException
static FeatureTransformer FeatureTransformer.createTransformer()
          Factory method that delegates to FeatureTransformer.createTransformer() using the standard configuration.
static FeatureTransformer FeatureTransformer.createTransformer(TiesConfiguration config)
          Factory method that creates a feature transformer based on the FeatureTransformer.CONFIG_TRANSFORMERS key in the provided configuration.
 

Uses of ProcessingException in de.fu_berlin.ties.classify.winnow
 

Methods in de.fu_berlin.ties.classify.winnow that throw ProcessingException
protected  boolean Winnow.trainOnErrorHook(PredictionDistribution predDist, FeatureVector features, String targetClass, Set candidateClasses, ContextMap context)
          Hook implementing error-driven learning, promoting and demoting weights as required.
 

Constructors in de.fu_berlin.ties.classify.winnow that throw ProcessingException
UltraconservativeWinnow(Set<String> allValidClasses)
          Creates a new instance by delegating to the corresponding super constructor.
UltraconservativeWinnow(Set<String> allValidClasses, FeatureTransformer trans, TiesConfiguration config)
          Creates a new instance by delegating to the corresponding super constructor.
UltraconservativeWinnow(Set<String> allValidClasses, TiesConfiguration config)
          Creates a new instance by delegating to the corresponding super constructor.
Winnow(Set<String> allValidClasses)
          Creates a new instance based on the standard configuration.
Winnow(Set<String> allValidClasses, FeatureTransformer trans, TiesConfiguration config)
          Creates a new instance based on the provided configuration.
Winnow(Set<String> allValidClasses, FeatureTransformer trans, TiesConfiguration config, String configSuffix)
          Creates a new instance based on the provided configuration.
Winnow(Set<String> allValidClasses, String configSuffix)
          Creates a new instance based on the standard configuration.
Winnow(Set<String> allValidClasses, TiesConfiguration config)
          Creates a new instance based on the provided configuration.
Winnow(Set<String> allValidClasses, TiesConfiguration config, String configSuffix)
          Creates a new instance based on the provided configuration.
 

Uses of ProcessingException in de.fu_berlin.ties.combi
 

Methods in de.fu_berlin.ties.combi that throw ProcessingException
static CombinationStrategy CombinationStrategy.createStrategy(Set<String> classNames)
          Factory method that delegates to CombinationStrategy.createStrategy(Set, TiesConfiguration) using the standard configuration.
static CombinationStrategy CombinationStrategy.createStrategy(Set<String> classNames, TiesConfiguration config)
          Factory method that creates a combination strategy based on the CombinationStrategy.CONFIG_COMBINATION key in the provided configuration.
 

Uses of ProcessingException in de.fu_berlin.ties.context
 

Constructors in de.fu_berlin.ties.context that throw ProcessingException
DefaultRepresentation()
          Creates a new instance based on the standard configuration.
DefaultRepresentation(int recogNum, int detailedRecogs, int numberOfAncestors, int numberOfSiblings, int splitMax, int prefixMax, String headElementName, String headAttribName, String[] defaultAttribs, int n, String outCharset, String[] sensorNames, TiesConfiguration config)
          Creates a new instance.
DefaultRepresentation(TiesConfiguration config)
          Creates a new instance based on the provided configuration.
SimpleRepresentation()
          Creates a new instance based on the standard configuration.
SimpleRepresentation(TiesConfiguration config)
          Creates a new instance based on the provided configuration.
SimpleRepresentation(TiesConfiguration config, String suffix)
          Creates a new instance based on the provided configuration.
 

Uses of ProcessingException in de.fu_berlin.ties.context.sensor
 

Methods in de.fu_berlin.ties.context.sensor that throw ProcessingException
static Sensor[] BaseSensor.createSensors(String[] classNames, TiesConfiguration conf)
          Factory method that initializes an array of sensors.
 

Uses of ProcessingException in de.fu_berlin.ties.eval
 

Methods in de.fu_berlin.ties.eval that throw ProcessingException
protected  void ReEvaluator.doProcess(Reader reader, Writer writer, ContextMap context)
          Processes the contents of a reader, writing a modified version to a writer.
 

Uses of ProcessingException in de.fu_berlin.ties.extract
 

Methods in de.fu_berlin.ties.extract that throw ProcessingException
 ExtractionContainer AnswerBuilder.buildAnswers(Document document)
          Buildings an ExtractionContainer of answer keys from from an annotated XML document.
 void TrainEval.close(int errorCount)
          Closes this instance, releasing all resources and stopping any background threads.
static TrainableFilter ExtractorBase.createSentenceFilter(TiesConfiguration conf, Representation representation)
          Helper methat that initializes the filter to be used for the first step of a double classification approach ("sentence filtering").
protected  void TrainEval.doProcess(Reader reader, Writer writer, ContextMap context)
          Processes the contents of a reader, writing a modified version to a writer.
 ExtractionContainer Extractor.extract(Document document)
          Extracts items of interest from the contents of an XML document, based on context representation and local classifier.
protected  void ExtractorBase.initFields()
          Initializes the fields used for processing a document (feature cache, buffer of prior recognitions, token walker, and statistics) and resets the combination strategy.
protected  Trainer TrainEval.initTrainer(File runDirectory)
          Creates and initializes a trainer to use for an evaluation run, configured from the stored configuration.
 void AnswerBuilder.process(Document document, Writer writer, ContextMap context)
          Buildings an ExtractionContainer of answer keys from from an annotated XML document.
 void Extractor.process(Document document, Writer writer, ContextMap context)
          Extracts items of interest from the contents of an XML document and serializes the extractions.
 void Trainer.process(Document document, Writer writer, ContextMap context)
          Trains the local classifier with the correct extractions of an XML document, using the provided context representation.
 void Extractor.processToken(Element element, String left, TokenDetails details, String right, ContextMap context)
          Processes a token in an XML element, optionally modifying the element or the document it is part of.
 void Trainer.processToken(Element element, String left, TokenDetails details, String right, ContextMap context)
          Processes a token in an XML element, optionally modifying the element or the document it is part of.
 void Trainer.reset()
          Resets the internal classifer, completely deleting the prediction model.
 Accuracy[] Trainer.train(Document document, ExtractionContainer correctExtractions)
          Trains the local classifier with the correct extractions of an XML document, using the provided context representation.
 TrainEval.Results TrainEval.trainAndEval(String[] files, File inDirectory, File outDirectory, String baseName, Writer writer)
          Processes an array of files.
 

Constructors in de.fu_berlin.ties.extract that throw ProcessingException
Extractor()
          Creates a new instance using a default extension.
Extractor(String outExt)
          Creates a new instance.
Extractor(String outExt, File runDirectory, TiesConfiguration config)
          Creates a new instance.
Extractor(String outExt, TiesConfiguration config)
          Creates a new instance.
ExtractorBase(String outExt)
          Creates a new instance.
ExtractorBase(String outExt, File runDirectory, TiesConfiguration config)
          Creates a new instance, configuring target structure, classifier, DefaultRepresentation, node filter, combination strategy and tokenizer factory from the provided configuration.
ExtractorBase(String outExt, TiesConfiguration config)
          Creates a new instance, configuring target structure, classifier, DefaultRepresentation, node filter and combination strategy from the provided configuration.
Trainer()
          Creates a new instance without specifying an output extension (which isn't needed anyway, because this class doesn't produce output).
Trainer(String outExt)
          Creates a new instance.
Trainer(String outExt, File runDirectory, TiesConfiguration config)
          Creates a new instance.
Trainer(String outExt, TiesConfiguration config)
          Creates a new instance.
 

Uses of ProcessingException in de.fu_berlin.ties.filter
 

Methods in de.fu_berlin.ties.filter that throw ProcessingException
protected  boolean TrainableFilteringTokenWalker.handleAccept(Element element, Element filteredElement, boolean decision)
          This method can be overwritten by subclasses to modify decisions of the element filter. This implementation relies on the oracle to make the final decision and joins the predicted decision and the correct decision via OR.
protected  boolean FilteringTokenWalker.handleAccept(Element element, Element filteredElement, boolean decision)
          This method can be overwritten by subclasses to modify decisions of the element filter.
 boolean RepresentationFilter.matches(Element element)
          Decides whether an element is accepted by this filter.
 boolean ElementFilter.matches(Element element)
          Decides whether an element is accepted by this filter.
 boolean TrainableFilter.matches(Element element)
          Decides whether an element is accepted by this filter.
protected  void FilteringTokenWalker.processToken(Element element, String left, TokenDetails details, String right, ContextMap context)
          Processes a token in an XML element by delegating to the configured TokenProcessor.
 boolean Oracle.shouldMatch(Element element)
          Decides whether an element should be accepted by filters.
 PredictionDistribution TrainableFilter.trainIfNecessary(Element element, boolean decision)
          Trains the correct decision for an element by calling the TrainableClassifier.trainOnError(FeatureVector, String, java.util.Set) method on the stored trainable classifier.
 void FilteringTokenWalker.walk(Document document, ContextMap context)
          Walks through the contents of an XML document, tokenizing the textual contents.
 

Constructors in de.fu_berlin.ties.filter that throw ProcessingException
RepresentationFilter(TiesConfiguration conf, NodeFilter positiveFilter, NodeFilter negativeFilter, Reranker rerank, Representation rep, String filterPurpose)
          Creates a new instance.
TrainableFilter(TiesConfiguration conf, NodeFilter positiveFilter, NodeFilter negativeFilter, Reranker rerank)
          Creates a new instance.
 

Uses of ProcessingException in de.fu_berlin.ties.preprocess
 

Methods in de.fu_berlin.ties.preprocess that throw ProcessingException
protected  void PreProcessor.doProcess(Reader reader, Writer writer, ContextMap context)
          Preprocesses the contents of a file.
 

Uses of ProcessingException in de.fu_berlin.ties.xml.dom
 

Methods in de.fu_berlin.ties.xml.dom that throw ProcessingException
protected  void TokenWalker.processCollectedText(Element element, CharSequence collectedText, TokenCounter tokenCounter, TextTokenizer tokenizer, ContextMap context)
          Helper method that tokenizes the collected textual contents of an element and delegates to the token processor for each of them.
 void ElementProcessor.processElement(Element element, TokenContainer tokenContainer, ContextMap context)
          Processes an element in an XML document, optionally modifying the element or the document it is part of.
protected  void TokenWalker.processToken(Element element, String left, TokenDetails details, String right, ContextMap context)
          Processes a token in an XML element by delegating to the configured TokenProcessor.
 void TokenProcessor.processToken(Element element, String left, TokenDetails details, String right, ContextMap context)
          Processes a token in an XML element, optionally modifying the element or the document it is part of.
 void DocumentWalker.walk(Document document, ContextMap context)
          Walks through the contents of an XML document, tokenizing the textual contents.
 void TokenWalker.walk(Document document, ContextMap context)
          Walks through the contents of an XML document, tokenizing the textual contents.
protected  void DocumentWalker.walk(Element element, TokenContainer tokenContainer, ContextMap context)
          Walks through the contents of a node, tokenizing textual contents and recursing through nested elements.
protected  void TokenWalker.walk(Element element, TokenCounter tokenCounter, TextTokenizer tokenizer, ContextMap context)
          Walks through the contents of a node, tokenizing textual contents and recursing through nested elements.
 



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