import weka.classifiers.evaluation.NominalPrediction; //导入依赖的package包/类
public double computeAccuracyAndRecordPrediction(BayesianNetwork bn, DataOnMemory<DataInstance> data){


        double correctPredictions = 0;
        Variable classVariable = bn.getVariables().getVariableById(nb_.getClassIndex());

        VMP vmp = new VMP();
        vmp.setModel(bn);
        for (DataInstance instance : data) {
            double realValue = instance.getValue(classVariable);
            instance.setValue(classVariable, Utils.missingValue());
            vmp.setEvidence(instance);
            vmp.runInference();
            Multinomial posterior = vmp.getPosterior(classVariable);

            if (Utils.maxIndex(posterior.getProbabilities())==realValue)
                correctPredictions++;
            Prediction prediction = new NominalPrediction(realValue, posterior.getProbabilities());
            predictions.add(prediction);

            instance.setValue(classVariable, realValue);
        }

        return correctPredictions/data.getNumberOfDataInstances();

    }
 

import weka.classifiers.evaluation.NominalPrediction; //导入依赖的package包/类
/**
 * Evaluates the supplied distribution on a single instance.
 *
 * @param dist     the supplied distribution
 * @param instance the test instance to be classified
 * @return the prediction
 * @throws Exception if model could not be evaluated successfully
 */
public double evaluateModelOnceAndRecordPrediction(double[] dist,
                                                   Instance instance) throws Exception {
    double pred;
    if (m_ClassIsNominal) {
        if (m_Predictions == null) {
            m_Predictions = new FastVector();
        }
        pred = Utils.maxIndex(dist);
        if (dist[(int) pred] <= 0) {
            pred = Instance.missingValue();
        }
        updateStatsForClassifier(dist, instance);
        m_Predictions.addElement(new NominalPrediction(instance.classValue(),
                dist, instance.weight()));
    } else {
        pred = dist[0];
        updateStatsForPredictor(pred, instance);
    }
    return pred;
}
 

import weka.classifiers.evaluation.NominalPrediction; //导入依赖的package包/类
public static double calculateAccuracy(FastVector predictions) {
    double correct = 0;

    for (int i = 0; i < predictions.size(); i++) {
        NominalPrediction np = (NominalPrediction) predictions.elementAt(i);
        if (np.predicted() == np.actual()) {
            correct++;
        }
    }

    return 100 * correct / predictions.size();
}