计算两个字符串之间相等的布尔值

Question

我想从我的训练数据中计算两个 String 之间的真实值的数量，但是，我实现的代码只计算真实实例的数量，而不是真实的总和.

//Load dataset
public class DatasetLoading {

  public static Instances loadData(String location) {
    try {
      return DataSource.read(location);
    }
    catch (Exception e) {
      System.err.println("Failed to load data from: " + location);
      e.printStackTrace();
      return null;
    }
  }

  public static void main(String[] args) {
    String dataLocation = "C:/Users/Emil/Desktop/Machine Learning - Java/Week 1/Arsenal_TRAIN1.arff";
    Instances train = loadData(dataLocation);
    System.out.println(train);
  }
}


public class ForClassifier {
    public static void main(String[] args) throws Exception {
        String train1 = "C:/Users/Emil/Downloads/Week 1/Arsenal_TRAIN.arff";

       Instances train = DatasetLoading.loadData(train1);

//train data    
    train.setClassIndex(train.numAttributes()-1);

    Classifier Model = (Classifier)new NaiveBayes();
    Model.buildClassifier(train);

    int z=0;
    double x = 0;
    String x2 = null;
    for (int i = 0; i < train.numInstances(); i++)      
    {
         //return data
      String  trueClassLabel = train.instance(i).toString(train.classIndex());
        double predicted = Model.classifyInstance(train.get(i));
       
  
        if(predicted == 0.0) {
            x=predicted;
        }else if (predicted == 1.0){
            x=predicted;

        }else if(predicted == 2.0) {
            x=predicted;
        }
       
        if(x == 0.0) {
        String x1 = "Loss";
        x2 = x1;
        } else if(x == 1.0) {
            String x1 = "Draw";
            x2=x1;
        } else if(x == 2.0) {
            String x1 = "Win";
            x2=x1;
        }
        
       //System.out.println(x2 + "\t"+trueClassLabel + "\t" + x2.equals(trueClassLabel));
        
        if(x2.equals(trueClassLabel)) {
            z++;
            System.out.println(z);
 }}}

我得到的输出：

预期输出：

我也尝试过获取最大值，但是这个 returns 1 而不是 13:

 if(x2.equals(trueClassLabel)) {
            
            z++;
            Integer[] test2= {z};
            
            for(int j = 0; j<test2.length;j++) {
                if(test2[max] < test2[i]) {
                    max=i;
                    

                }
            }System.out.println(test2[max]);//1

@data:

@RELATION Arsenal

@ATTRIBUTE Leno  {0,1}
@ATTRIBUTE Tierney   {0,1}
@ATTRIBUTE Saka  {0,1}
@ATTRIBUTE class    {Loss,Draw,Win}
@DATA

1, 0,  0,  Loss
1, 0,  0,  Loss
0, 1,  1,  Draw
1, 0,  1,  Draw
0, 0,  1,  Win
0, 1,  1,  Win
1, 1,  1,  Win
0, 1,  1,  Win
1, 1,  0,  Win
1, 0,  1,  Win
1, 1,  0,  Loss
0, 1,  0,  Draw
1, 1,  0,  Draw
1, 1,  0,  Draw
0, 0,  1,  Win
1, 0,  1,  Win
0, 1,  1,  Win
1, 1,  0,  Win
1, 1,  1,  Win
1, 1,  0,  Win

Answer 1

为什么不比较字符串，为什么不直接比较从 classifyInstance 获得的数字预测与来自训练数据 (train.instance(i).classValue()) 的实际数字 class 标签？

由于您没有 post 完整代码（缺少 DatasetLoading class），这里是对代码的简单重写。 class 期望数据集的文件名用作第一个参数。 class 使用两种方法来评估模型：手动比较预测和使用 Weka 的 Evaluation class（它为您提供了更多的统计数据）。

import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.bayes.NaiveBayes;
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;

public class ForClassifier {

  public static void main(String[] args) throws Exception {
    // load dataset
    Instances train = DataSource.read(args[0]);
    train.setClassIndex(train.numAttributes() - 1);

    // build classifier
    Classifier model = new NaiveBayes();
    model.buildClassifier(train);

    // 1. manual evaluation
    System.out.println("manual evaluation");
    int correct = 0;
    int incorrect = 0;
    for (int i = 0; i < train.numInstances(); i++) {
      double actual = train.instance(i).classValue();
      double predicted = model.classifyInstance(train.get(i));
      if (actual == predicted)
        correct++;
      else
        incorrect++;
    }
    System.out.println("- correct: " + correct);
    System.out.println("- incorrect: " + incorrect);

    // 2. using Weka's Evaluation class
    System.out.println("Weka's Evaluation");
    Evaluation eval = new Evaluation(train);
    eval.evaluateModel(model, train);
    System.out.println("- correct: " + eval.correct());
    System.out.println("- incorrect: " + eval.incorrect());
  }
}

顺便说一句：你永远不应该评估训练数据，因为这会过于乐观（模型已经看到了所有这些数据！）。

计算两个字符串之间相等的布尔值

count boolean values that equal between two strings

java

boolean

weka