ViterbiClassifier (ClearTK TimeML 2.0.0 API)

java.lang.Object
- org.cleartk.ml.viterbi.ViterbiClassifier<OUTCOME_TYPE>

All Implemented Interfaces:

org.apache.uima.fit.factory.initializable.Initializable, SequenceClassifier<OUTCOME_TYPE>, ReflectionUtil.TypeArgumentDelegator
```
public class ViterbiClassifier<OUTCOME_TYPE>
extends Object
implements SequenceClassifier<OUTCOME_TYPE>, org.apache.uima.fit.factory.initializable.Initializable, ReflectionUtil.TypeArgumentDelegator
```
Copyright (c) 2007-2008, Regents of the University of Colorado
All rights reserved.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`addScores`
`protected Classifier<OUTCOME_TYPE>`	`delegatedClassifier`
`protected OutcomeFeatureExtractor[]`	`outcomeFeatureExtractors`
`static String`	`PARAM_ADD_SCORES`
`static String`	`PARAM_STACK_SIZE`
`protected int`	`stackSize`

Constructor Summary

Constructors
Constructor and Description
`ViterbiClassifier(Classifier<OUTCOME_TYPE> delegatedClassifier, OutcomeFeatureExtractor[] outcomeFeatureExtractors)`

Method Summary

Methods
Modifier and Type	Method and Description
`List<OUTCOME_TYPE>`	`classify(List<List<Feature>> features)` Classifies a sequence of feature lists.
`Map<String,Type>`	`getTypeArguments(Class<?> genericType)`
`void`	`initialize(UimaContext context)`
`List<Map<OUTCOME_TYPE,Double>>`	`score(List<List<Feature>> features)` Classify a sequence of feature lists, and return the scores for each of the outcomes for each feature list.
`List<OUTCOME_TYPE>`	`viterbi(List<List<Feature>> featureLists)` This implementation of Viterbi requires at most stackSize * sequenceLength calls to the classifier.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - addScores
```
protected boolean addScores
```
  - delegatedClassifier
```
protected Classifier<OUTCOME_TYPE> delegatedClassifier
```
  - outcomeFeatureExtractors
```
protected OutcomeFeatureExtractor[] outcomeFeatureExtractors
```
  - PARAM_ADD_SCORES
```
public static final String PARAM_ADD_SCORES
```
    See Also:
    Constant Field Values
  - PARAM_STACK_SIZE
```
public static final String PARAM_STACK_SIZE
```
    See Also:
    Constant Field Values
  - stackSize
```
protected int stackSize
```
- Constructor Detail
  - ViterbiClassifier
```
public ViterbiClassifier(Classifier<OUTCOME_TYPE> delegatedClassifier,
                 OutcomeFeatureExtractor[] outcomeFeatureExtractors)
```
- Method Detail
  - classify
```
public List<OUTCOME_TYPE> classify(List<List<Feature>> features)
                            throws CleartkProcessingException
```
    Description copied from interface: SequenceClassifier
    
    Classifies a sequence of feature lists.
    
    Specified by:
    
    classify in interface SequenceClassifier<OUTCOME_TYPE>
    
    Parameters:
    features - a list of features for each member in the sequence
    
    Returns:
    a list of the classifications made.
    
    Throws:
    
    CleartkProcessingException
  - getTypeArguments
```
public Map<String,Type> getTypeArguments(Class<?> genericType)
```
    Specified by:
    
    getTypeArguments in interface ReflectionUtil.TypeArgumentDelegator
  - initialize
```
public void initialize(UimaContext context)
                throws ResourceInitializationException
```
    Specified by:
    
    initialize in interface org.apache.uima.fit.factory.initializable.Initializable
    
    Throws:
    
    ResourceInitializationException
  - score
```
public List<Map<OUTCOME_TYPE,Double>> score(List<List<Feature>> features)
                                     throws CleartkProcessingException
```
    Description copied from interface: SequenceClassifier
    
    Classify a sequence of feature lists, and return the scores for each of the outcomes for each feature list.
    
    Specified by:
    
    score in interface SequenceClassifier<OUTCOME_TYPE>
    
    Parameters:
    features - a list of features for each member in the sequence
    
    Returns:
    a map from outcomes to classification scores for each member in the sequence
    
    Throws:
    
    CleartkProcessingException
  - viterbi
```
public List<OUTCOME_TYPE> viterbi(List<List<Feature>> featureLists)
                           throws CleartkProcessingException
```
    This implementation of Viterbi requires at most stackSize * sequenceLength calls to the classifier. If this proves to be too expensive, then consider using a smaller stack size.
    
    Parameters:
    featureLists - a sequence-worth of features. Each List in features should corresond to all of the features for a given element in a sequence to be classified.
    
    Returns:
    a list of outcomes (classifications) - one classification for each member of the sequence.
    
    Throws:
    
    CleartkProcessingException
    See Also:
    PARAM_STACK_SIZE, OutcomeFeatureExtractor

Class ViterbiClassifier<OUTCOME_TYPE>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

addScores

delegatedClassifier

outcomeFeatureExtractors

PARAM_ADD_SCORES

PARAM_STACK_SIZE

stackSize

Constructor Detail

ViterbiClassifier

Method Detail

classify

getTypeArguments

initialize

score

viterbi