Java Classifier类代码示例

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public ConfidencePredictingClassifier (Classifier underlyingClassifier, Classifier confidencePredictingClassifier)
{
	super (underlyingClassifier.getInstancePipe());
	this.underlyingClassifier = underlyingClassifier;
	this.confidencePredictingClassifier = confidencePredictingClassifier;
	// for testing confidence accuracy
	totalCorrect = 0.0;
	totalIncorrect = 0.0;
	totalIncorrectIncorrect = 0.0;
	totalIncorrectCorrect = 0.0;
	numCorrectInstances = 0;
	numIncorrectInstances = 0;
	numConfidenceCorrect = 0;
	numFalsePositive = 0;
	 numFalseNegative = 0;

}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public static void main(String[] args) throws IOException, Exception {
    ArrayList<Pipe> pipes = new ArrayList<Pipe>();
    pipes.add(new Target2Label());
    pipes.add(new CharSequence2TokenSequence());
    pipes.add(new TokenSequence2FeatureSequence());
    pipes.add(new FeatureSequence2FeatureVector());
    SerialPipes pipe = new SerialPipes(pipes);

    //prepare training instances
    InstanceList trainingInstanceList = new InstanceList(pipe);
    trainingInstanceList.addThruPipe(new CsvIterator(new FileReader("webkb-train-stemmed.txt"),
            "(.*)\t(.*)", 2, 1, -1));

    //prepare test instances
    InstanceList testingInstanceList = new InstanceList(pipe);
    testingInstanceList.addThruPipe(new CsvIterator(new FileReader("webkb-test-stemmed.txt"),
            "(.*)\t(.*)", 2, 1, -1));

    ClassifierTrainer trainer = new SVMClassifierTrainer(new LinearKernel());
    Classifier classifier = trainer.train(trainingInstanceList);
    System.out.println("Accuracy: " + classifier.getAccuracy(testingInstanceList));

}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
@Override
public void initialize(UimaContext context)
        throws ResourceInitializationException {
    super.initialize(context);
    try {
        // load model for inference
        File modelfile = new File(ReferencesHelper.REFERENCES_RESOURCES
                + "models/" + modelName);
        checkArgument(modelfile.exists(), "no modelFile at " + modelName);
        ObjectInputStream s = new ObjectInputStream(new FileInputStream(
                modelfile));
        classifier = (Classifier) s.readObject();
        s.close();
        checkArgument(classifier != null);
        pipes = classifier.getInstancePipe();
    } catch (Exception e) {
        throw new ResourceInitializationException(e);
    }
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
@Override
public List<ModelApplication> applyModel(
        AnnotationSet instanceAS, AnnotationSet inputAS, AnnotationSet sequenceAS, String parms) {
  // NOTE: the crm should be of type CorpusRepresentationMalletClass for this to work!
  if(!(corpusRepresentation instanceof CorpusRepresentationMalletTarget)) {
    throw new GateRuntimeException("Cannot perform classification with data from "+corpusRepresentation.getClass());
  }
  CorpusRepresentationMalletTarget data = (CorpusRepresentationMalletTarget)corpusRepresentation;
  data.stopGrowth();
  List<ModelApplication> gcs = new ArrayList<ModelApplication>();
  LFPipe pipe = (LFPipe)data.getRepresentationMallet().getPipe();
  Classifier classifier = (Classifier)model;
  // iterate over the instance annotations and create mallet instances 
  for(Annotation instAnn : instanceAS.inDocumentOrder()) {
    Instance inst = data.extractIndependentFeatures(instAnn, inputAS);
    inst = pipe.instanceFrom(inst);
    Classification classification = classifier.classify(inst);
    Labeling labeling = classification.getLabeling();
    LabelVector labelvec = labeling.toLabelVector();
    List<String> classes = new ArrayList<String>(labelvec.numLocations());
    List<Double> confidences = new ArrayList<Double>(labelvec.numLocations());
    for(int i=0; i<labelvec.numLocations(); i++) {
      classes.add(labelvec.getLabelAtRank(i).toString());
      confidences.add(labelvec.getValueAtRank(i));
    }      
    ModelApplication gc = new ModelApplication(instAnn, labeling.getBestLabel().toString(), 
            labeling.getBestValue(), classes, confidences);
    //System.err.println("ADDING GC "+gc);
    // now save the class in our special class feature on the instance as well
    instAnn.getFeatures().put("gate.LF.target",labeling.getBestLabel().toString());
    gcs.add(gc);
  }
  data.startGrowth();
  return gcs;
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
private void doTraining(InstanceList trainList)
{
	// train a classifier on the entire training set
	logger.info("Training token classifier on entire data set (size=" + trainList.size() + ")...");
	m_tokenClassifier = m_trainer.train(trainList);

	Trial t = new Trial(m_tokenClassifier, trainList);
	logger.info("Training set accuracy = " + t.getAccuracy());
	
	if (m_numCV == 0)
		return;

	// train classifiers using cross validation
	InstanceList.CrossValidationIterator cvIter = trainList.new CrossValidationIterator(m_numCV, m_randSeed);
	int f = 1;

	while (cvIter.hasNext()) {
		f++;
		InstanceList[] fold = cvIter.nextSplit();

		logger.info("Training token classifier on cv fold " + f + " / " + m_numCV + " (size=" + fold[0].size() + ")...");
		
		Classifier foldClassifier = m_trainer.train(fold[0]);
		Trial t1 = new Trial(foldClassifier, fold[0]);
		Trial t2 = new Trial(foldClassifier, fold[1]);

		logger.info("Within-fold accuracy = " + t1.getAccuracy());
		logger.info("Out-of-fold accuracy = " + t2.getAccuracy());

		/*for (int x = 0; x < t2.size(); x++) {
			logger.info("xxx pred:" + t2.getClassification(x).getLabeling().getBestLabel() + " true:" + t2.getClassification(x).getInstance().getLabeling());
		}*/
		
		for (int i = 0; i < fold[1].size(); i++) {
			Instance inst = fold[1].get(i);
			m_table.put(inst.getName(), foldClassifier);
		}
	}
}
 

import cc.mallet.classify.Classifier; //导入依赖的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.classify.Classifier; //导入依赖的package包/类
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
	int version = in.readInt();
	if (version != CURRENT_SERIAL_VERSION)
		throw new ClassNotFoundException("Mismatched TokenClassifiers versions: wanted " +
				CURRENT_SERIAL_VERSION + ", got " +
				version);
	instancePipe = (Pipe) in.readObject();
	m_numCV = in.readInt();
	m_randSeed = in.readInt();
	m_table = (HashMap) in.readObject();
	m_tokenClassifier = (Classifier) in.readObject();
	m_trainer = (ClassifierTrainer) in.readObject();
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public Classifier train (InstanceList trainingSet)
{
	featureSelector.selectFeaturesFor (trainingSet);
	// TODO What about also selecting features for the validation set?
	this.classifier = underlyingTrainer.train (trainingSet);
	return classifier;
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public Classification (Instance instance, Classifier classifier,
											 Labeling labeling)
{
	this.instance = instance;
	this.classifier = classifier;
	this.labeling = labeling;
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public DecisionTreeTrainer newClassifierTrainer (Classifier initialClassifier) {
	DecisionTreeTrainer t = new DecisionTreeTrainer ();
	t.maxDepth = this.maxDepth;
	t.minInfoGainSplit = this.minInfoGainSplit;
	
	return t;
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public MedoidEvaluator(Classifier classifier, String scoringLabel,boolean singleLink,boolean mergeFirst)
   {
super(classifier,scoringLabel);
this.singleLink=singleLink;
this.mergeFirst=mergeFirst;
System.out.println("Using Medoid Evaluator. Single link="+singleLink+".");
   }
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
@Override
protected void unpackageClassifier(JarInputStream modelStream) throws IOException {
  super.unpackageClassifier(modelStream);
  JarStreams.getNextJarEntry(modelStream, MODEL_NAME);
  ObjectInputStream objectStream = new ObjectInputStream(modelStream);
  try {
    this.classifier = (Classifier) objectStream.readObject();
  } catch (ClassNotFoundException e) {
    throw new IOException(e);
  }
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public MalletClassifier_ImplBase(
    FeaturesEncoder<List<NameNumber>> featuresEncoder,
    OutcomeEncoder<OUTCOME_TYPE, String> outcomeEncoder,
    Classifier classifier) {
  super(featuresEncoder, outcomeEncoder);
  this.classifier = classifier;
  this.alphabet = classifier.getAlphabet();
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public Classifier train (InstanceList trainingSet)
{
	featureSelector.selectFeaturesFor (trainingSet);

	// TODO What about also selecting features for the validation set?
	this.classifier = underlyingTrainer.train (trainingSet);
	return classifier;
}
 

import cc.mallet.classify.Classifier; //导入依赖的package包/类
public void saveClassifier(Classifier classifier, File serializedFile)
        throws IOException {
    ObjectOutputStream oos =
            new ObjectOutputStream(new FileOutputStream(serializedFile));
    oos.writeObject(classifier);
    oos.close();
}