Java CounterMap类代码示例

import edu.berkeley.nlp.util.CounterMap; //导入依赖的package包/类
public ProbabilisticClassifier<I, L> trainClassifier(
		List<LabeledInstance<I, L>> trainingData) {
	CounterMap<L, F> featureProbs = new CounterMap<L, F>();
	Counter<F> backoffProbs = new Counter<F>();
	Counter<L> labelProbs = new Counter<L>();
	for (LabeledInstance<I, L> instance : trainingData) {
		L label = instance.getLabel();
		labelProbs.incrementCount(label, 1.0);
		I inst = instance.getInput();
		Counter<F> featCounts = featureExtractor.extractFeatures(inst);
		for (F feat : featCounts.keySet()) {
			double count = featCounts.getCount(feat);
			backoffProbs.incrementCount(feat, count);
			featureProbs.incrementCount(label, feat, count);
		}
	}
	featureProbs.normalize();
	labelProbs.normalize();
	backoffProbs.normalize();
	return new NaiveBayesClassifier<I, F, L>(featureProbs,
			backoffProbs, labelProbs, featureExtractor);
}
 

import edu.berkeley.nlp.util.CounterMap; //导入依赖的package包/类
/**
 * Count statistics for a collection of StateSet trees.
 */
public CorpusStatistics(Numberer tagNumberer,
		Collection<Tree<StateSet>> trees) {
	counts = new int[tagNumberer.objects().size()];
	this.trees = trees;
	unaryRuleCounter = new Counter<UnaryRule>();
	binaryRuleCounter = new Counter<BinaryRule>();
	contexts = new int[tagNumberer.objects().size()];
	posCounter = new CounterMap<Integer, String>();
}
 

import edu.berkeley.nlp.util.CounterMap; //导入依赖的package包/类
/**
 * Rather than calling some all-in-one constructor that takes a list of
 * trees as training data, you call Grammar() to create an empty grammar,
 * call tallyTree() repeatedly to include all the training data, then call
 * optimize() to take it into account.
 * 
 * @param oldGrammar
 *            This is the previous grammar. We use this to copy the split
 *            trees that record how each state is split recursively. These
 *            parameters are intialized if oldGrammar is null.
 */
@SuppressWarnings("unchecked")
public Grammar(short[] nSubStates, boolean findClosedPaths,
		Smoother smoother, Grammar oldGrammar, double thresh) {
	this.tagNumberer = Numberer.getGlobalNumberer("tags");
	this.findClosedPaths = findClosedPaths;
	this.smoother = smoother;
	this.threshold = thresh;
	unaryRuleCounter = new UnaryCounterTable(nSubStates);
	binaryRuleCounter = new BinaryCounterTable(nSubStates);
	symbolCounter = new CounterMap<Integer, Integer>();
	numStates = (short) nSubStates.length;
	numSubStates = nSubStates;
	bSearchRule = new BinaryRule((short) 0, (short) 0, (short) 0);
	uSearchRule = new UnaryRule((short) 0, (short) 0);
	logarithmMode = false;
	if (oldGrammar != null) {
		splitTrees = oldGrammar.splitTrees;
	} else {
		splitTrees = new Tree[numStates];
		boolean hasAnySplits = false;
		for (int tag = 0; !hasAnySplits && tag < numStates; tag++) {
			hasAnySplits = hasAnySplits || numSubStates[tag] > 1;
		}
		for (int tag = 0; tag < numStates; tag++) {
			ArrayList<Tree<Short>> children = new ArrayList<Tree<Short>>(
					numSubStates[tag]);
			if (hasAnySplits) {
				for (short substate = 0; substate < numSubStates[tag]; substate++) {
					children.add(substate, new Tree<Short>(substate));
				}
			}
			splitTrees[tag] = new Tree<Short>((short) 0, children);
		}
	}
	init();
}
 

import edu.berkeley.nlp.util.CounterMap; //导入依赖的package包/类
public NaiveBayesClassifier(CounterMap<L, F> featureProbs,
		Counter<F> backoffProbs, Counter<L> labelProbs,
		FeatureExtractor<I, F> featureExtractor) {
	super();
	this.featureProbs = featureProbs;
	this.backoffProbs = backoffProbs;
	this.labelProbs = labelProbs;
	this.featureExtractor = featureExtractor;
}
 

import edu.berkeley.nlp.util.CounterMap; //导入依赖的package包/类
public void clearCounts() {
	unaryRuleCounter = new UnaryCounterTable(numSubStates);
	binaryRuleCounter = new BinaryCounterTable(numSubStates);
	symbolCounter = new CounterMap<Integer, Integer>();

}