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

问题描述

我想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);
 }}}

我得到的输出：

预期输出：

我也尝试过获得最大值但是，这会返回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

@数据：

@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

标签： javabooleanweka

解决方案

为什么不比较字符串，而不是比较classifyInstance从训练数据中获得的数字预测与实际数字类标签（train.instance(i).classValue()）？

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

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());
  }
}

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

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

问题描述

解决方案

推荐阅读