import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
private static RankedFeatureVector countFeatures(InstanceList ilist, boolean countInstances) {
  int numFeatures = ilist.getDataAlphabet().size();
  double[] counts = new double[numFeatures];
  for (int i = 0; i < ilist.size(); i++) {
    Instance inst = ilist.get(i);
    if (ilist.getInstanceWeight(i) == 0) {
      continue;
    }
    Object data = inst.getData();
    if (data instanceof FeatureVectorSequence) {
      FeatureVectorSequence fvs = (FeatureVectorSequence) data;
      for (int j = 0; j < fvs.size(); j++) {
        countVector(counts, fvs.get(j), countInstances);
      }
    } else {
      throw new IllegalArgumentException("Currently only handles FeatureVectorSequence data");
    }
  }
  return new RankedFeatureVector(ilist.getDataAlphabet(), counts);
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public void testBiNormalSeparation() {
  BinaryTestData binaryTestData = new BinaryTestData(4);
  binaryTestData.addInstance(new int[] {0, 1}, true);
  binaryTestData.addInstance(new int[] {0, 2}, true);
  binaryTestData.addInstance(new int[] {2, 3}, false);
  binaryTestData.addInstance(new int[] {3}, false);
  InstanceList iList = binaryTestData.getInstanceList();
  RankedFeatureVector rankedFeatureVector = new BiNormalSeparation.Factory()
      .newRankedFeatureVector(iList);
  assertEquals(6.58, rankedFeatureVector.getValueAtRank(0), 0.005);
  assertEquals(3.29, rankedFeatureVector.getValueAtRank(2), 0.005);
  assertEquals(0, rankedFeatureVector.getValueAtRank(3), 0);
  assertEquals(6.58, rankedFeatureVector.getValueAtRank(1), 0.005);
  assertEquals(2, rankedFeatureVector.getIndexAtRank(3));
  assertEquals(1, rankedFeatureVector.getIndexAtRank(2));
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
/**
 * Returns a ranked feature vector of the gradient gain for the given training data on the given trained CRF.  The
 * instance list must have the target labels as LabelSequence
 */
public static RankedFeatureVector gradientGainFrom(InstanceList ilist, CRF crf) {
  int numFeatures = ilist.getDataAlphabet().size();
  double[] gradientgains = new double[numFeatures];
  fillResults(ilist, crf, gradientgains, null, null);
  return new RankedFeatureVector(ilist.getDataAlphabet(), gradientgains);
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public static RankedFeatureVector gradientGainRatioFrom(InstanceList ilist, CRF crf) {
  int numFeatures = ilist.getDataAlphabet().size();
  double[] gradientgains = new double[numFeatures];
  double[] gradientlosses = new double[numFeatures];
  fillResults(ilist, crf, null, gradientgains, gradientlosses);

  return makeRatioVector(ilist, numFeatures, gradientgains, gradientlosses);
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public static Pair<RankedFeatureVector, RankedFeatureVector> gradientsFrom(InstanceList ilist, CRF crf) {
  int numFeatures = ilist.getDataAlphabet().size();
  double[] gradientgains = new double[numFeatures];
  double[] pos = new double[numFeatures];
  double[] neg = new double[numFeatures];
  fillResults(ilist, crf, gradientgains, pos, neg);
  return Pair.of(new RankedFeatureVector(ilist.getDataAlphabet(), gradientgains),
                 makeRatioVector(ilist, numFeatures, pos, neg));
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
private static RankedFeatureVector makeRatioVector(InstanceList ilist, int numFeatures,
                                                   double[] gradientgains,
                                                   double[] gradientlosses) {
  double[] ratios = new double[numFeatures];
  for (int i = 0; i < numFeatures; i++) {
    double pos = gradientgains[i];
    double neg = gradientlosses[i];
    ratios[i] = (pos + 1.0) / (neg + 1.0);
  }
  return new RankedFeatureVector(ilist.getDataAlphabet(), ratios);
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public static void writeRankedToFile(RankedFeatureVector rfv, File outputFile) {
  try {
    try (PrintWriter writer = new PrintWriter(Files.newWriter(outputFile, Charsets.UTF_8))) {

      for (int i = 0; i < rfv.singleSize(); i++) {
        Object objectAtRank = rfv.getObjectAtRank(i);
        double gradAtRank = rfv.getValueAtRank(i);
        writer.println(String.format("%s,%.5f", objectAtRank.toString(), gradAtRank));
      }
    }
  } catch (IOException e) {
    throw Throwables.propagate(e);
  }
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public void testSetRankOrder ()
{
	Alphabet v = new Alphabet ();
	RankedFeatureVector rfv =
		new RankedFeatureVector (v, new int[] {v.lookupIndex ("a"), v.lookupIndex ("b"), v.lookupIndex ("c"), v.lookupIndex ("d") },
														new double[] {3.0, 1.0, 2.0, 6.0});
	System.out.println ("vector size ="+rfv.numLocations());
	for (int i = 0; i < rfv.numLocations(); i++)
		System.out.println ("Rank="+i+" value="+rfv.getValueAtRank(i));
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public void print (PrintWriter out)
{
	out.println ("*** CRF STATES ***");
	for (int i = 0; i < numStates (); i++) {
		State s = (State) getState (i);
		out.print ("STATE NAME=\"");
		out.print (s.name); out.print ("\" ("); out.print (s.destinations.length); out.print (" outgoing transitions)\n");
		out.print ("  "); out.print ("initialWeight = "); out.print (parameters.initialWeights[i]); out.print ('\n');
		out.print ("  "); out.print ("finalWeight = "); out.print (parameters.finalWeights[i]); out.print ('\n');
		out.println ("  transitions:");
		for (int j = 0; j < s.destinations.length; j++) {
			out.print ("    "); out.print (s.name); out.print (" -> "); out.println (s.getDestinationState (j).getName ());
			for (int k = 0; k < s.weightsIndices[j].length; k++) {
				out.print ("        WEIGHTS = \"");
				int widx = s.weightsIndices[j][k];
				out.print (parameters.weightAlphabet.lookupObject (widx).toString ());
				out.print ("\"\n");
			}
		}
		out.println ();
	}

	if (parameters.weights == null)
		out.println ("\n\n*** NO WEIGHTS ***");
	else {		
		out.println ("\n\n*** CRF WEIGHTS ***");
		for (int widx = 0; widx < parameters.weights.length; widx++) {
			out.println ("WEIGHTS NAME = " + parameters.weightAlphabet.lookupObject (widx));
			out.print (": <DEFAULT_FEATURE> = "); out.print (parameters.defaultWeights[widx]); out.print ('\n');
			SparseVector transitionWeights = parameters.weights[widx];
			if (transitionWeights.numLocations () == 0)
				continue;
			RankedFeatureVector rfv = new RankedFeatureVector (inputAlphabet, transitionWeights);
			for (int m = 0; m < rfv.numLocations (); m++) {
				double v = rfv.getValueAtRank (m);
				//int index = rfv.indexAtLocation (rfv.getIndexAtRank (m));  // This doesn't make any sense.  How did this ever work?  -akm 12/2007
				int index = rfv.getIndexAtRank (m);
				Object feature = inputAlphabet.lookupObject (index);
				if (v != 0) {
					out.print (": "); out.print (feature); out.print (" = "); out.println (v);
				}
			}
		}
	}

	out.flush ();
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public static RankedFeatureVector featureCountsFrom(InstanceList ilist) {
  return countFeatures(ilist, true);
}
 

import cc.mallet.types.RankedFeatureVector; //导入依赖的package包/类
public static RankedFeatureVector featureSumFrom(InstanceList ilist) {
  return countFeatures(ilist, false);
}