Java Instance.getName方法代码示例

import cc.mallet.types.Instance; //导入方法依赖的package包/类
/**
 * 
 * @param inst input instance, with FeatureVectorSequence as data.
 * @param alphabetsPipe a Noop pipe containing the data and target alphabets for 
 * the resulting InstanceList and AugmentableFeatureVectors
 * @return list of instances, each with one AugmentableFeatureVector as data
 */
public static InstanceList convert(Instance inst, Noop alphabetsPipe)
{
	InstanceList ret = new InstanceList(alphabetsPipe);
	Object obj = inst.getData();
	assert(obj instanceof FeatureVectorSequence);

	FeatureVectorSequence fvs = (FeatureVectorSequence) obj;
	LabelSequence ls = (LabelSequence) inst.getTarget();
	assert(fvs.size() == ls.size());

	Object instName = (inst.getName() == null ? "NONAME" : inst.getName());
	
	for (int j = 0; j < fvs.size(); j++) {
		FeatureVector fv = fvs.getFeatureVector(j);
		int[] indices = fv.getIndices();
		FeatureVector data = new AugmentableFeatureVector (alphabetsPipe.getDataAlphabet(),
				indices, fv.getValues(), indices.length); 
		Labeling target = ls.getLabelAtPosition(j);
		String name = instName.toString() + "[email protected]_POS_" + (j + 1);
		Object source = inst.getSource();
		Instance toAdd = alphabetsPipe.pipe(new Instance(data, target, name, source));

		ret.add(toAdd);
	}

	return ret;
}
 

import cc.mallet.types.Instance; //导入方法依赖的package包/类
/**
 * 
 * @param instance the instance to classify
 * @param useOutOfFold whether to check the instance name and use the out-of-fold classifier
 * if the instance name matches one in the training data
 * @return the token classifier's output
 */
public Classification classify(Instance instance, boolean useOutOfFold)
{
	Object instName = instance.getName();
	
	if (! useOutOfFold || ! m_table.containsKey(instName))
		return m_tokenClassifier.classify(instance);
	
	Classifier classifier = (Classifier) m_table.get(instName);

	return classifier.classify(instance);
}
 

import cc.mallet.types.Instance; //导入方法依赖的package包/类
public Instance next ()
{
  Instance inst = subIt.next ();
  inst = pipe.pipe (inst);
  return new Instance (inst.getData (), inst.getTarget (), inst.getName (), inst.getSource ());
}
 

import cc.mallet.types.Instance; //导入方法依赖的package包/类
protected double getExpectationValue ()
{
	// Instance values must either always or never be included in
	// the total values; we can't just sometimes skip a value
	// because it is infinite, this throws off the total values.
	boolean initializingInfiniteValues = false;
	double value = 0;
	if (infiniteValues == null) {
		infiniteValues = new BitSet ();
		initializingInfiniteValues = true;
	}

	// Reset expectations to zero before we fill them again
	assert (expectations.structureMatches(crf.parameters));
	expectations.zero();

	// count the number of instances that have infinite weight
	int numInfLabeledWeight = 0;
	int numInfUnlabeledWeight = 0;
	int numInfWeight = 0;
	
	// Calculate the value of each instance, and also fill in expectations
	double unlabeledWeight, labeledWeight, weight;
	for (int ii = 0; ii < trainingSet.size(); ii++) {
		Instance instance = trainingSet.get(ii);
		double instanceWeight = trainingSet.getInstanceWeight(instance);
		FeatureVectorSequence input = (FeatureVectorSequence) instance.getData();
		FeatureSequence output = (FeatureSequence) instance.getTarget();
		labeledWeight = new SumLatticeDefault (this.crf, input, output, (Transducer.Incrementor)null).getTotalWeight();
		String instanceName = instance.getName() == null ? "instance#"+ii : instance.getName().toString();
		//System.out.println ("labeledWeight = "+labeledWeight);
		if (Double.isInfinite (labeledWeight)) {
			++numInfLabeledWeight;
			logger.warning (instanceName + " has -infinite labeled weight.\n"+(instance.getSource() != null ? instance.getSource() : ""));
		}
		
		Transducer.Incrementor incrementor = instanceWeight == 1.0 ? expectations.new Incrementor() : expectations.new WeightedIncrementor (instanceWeight);
		unlabeledWeight = new SumLatticeDefault (this.crf, input, null, incrementor).getTotalWeight();
		//System.out.println ("unlabeledWeight = "+unlabeledWeight);
		if (Double.isInfinite (unlabeledWeight)) {
			++numInfUnlabeledWeight;
			logger.warning (instance.getName().toString() + " has -infinite unlabeled weight.\n"+(instance.getSource() != null ? instance.getSource() : ""));
		}
		
		// Here weight is log(conditional probability correct label sequence)
		weight = labeledWeight - unlabeledWeight;
		//System.out.println ("Instance "+ii+" CRF.MaximizableCRF.getWeight = "+weight);
		if (Double.isInfinite(weight)) {
			++numInfWeight;
			logger.warning (instanceName + " has -infinite weight; skipping.");
			if (initializingInfiniteValues)
				infiniteValues.set (ii);
			else if (!infiniteValues.get(ii))
				throw new IllegalStateException ("Instance i used to have non-infinite value, but now it has infinite value.");
			continue;
		}
     // Weights are log probabilities, and we want to return a log probability
     value += weight * instanceWeight;
	}

	if (numInfLabeledWeight > 0 || numInfUnlabeledWeight > 0 || numInfWeight > 0) {
		logger.warning("Number of instances with:\n" +
				"\t -infinite labeled weight: " + numInfLabeledWeight + "\n" +
				"\t -infinite unlabeled weight: " + numInfUnlabeledWeight + "\n" +
				"\t -infinite weight: " + numInfWeight);
	}
	
	return value;
}