使用 WEKA 的文本分类器:如何正确训练分类器问题

Question

我正在尝试使用 Weka 构建一个文本分类器，但distributionForInstance类的概率在一个类中1.0，在所有其他情况下0.0，因此classifyInstance总是返回与预测相同的类。培训中的某些内容无法正常工作。

地区电影节培训

@relation test1
@attribute tweetmsg    String
@attribute classValues {politica,sport,musicatvcinema,infogeneriche,fattidelgiorno,statopersonale,checkin,conversazione}
@DATA
"Renzi Berlusconi Salvini Bersani",politica
"Allegri insulta la terna arbitrale",sport
"Bravo Garcia",sport

训练方法

public void trainClassifier(final String INPUT_FILENAME) throws Exception
{
    getTrainingDataset(INPUT_FILENAME);
    //trainingInstances consists of feature vector of every input
    for(Instance currentInstance : inputDataset)
    {           
        Instance currentFeatureVector = extractFeature(currentInstance);
        currentFeatureVector.setDataset(trainingInstances);
        trainingInstances.add(currentFeatureVector);                
    }
    classifier = new NaiveBayes();
    try {
        //classifier training code
        classifier.buildClassifier(trainingInstances);
        //storing the trained classifier to a file for future use
        weka.core.SerializationHelper.write("NaiveBayes.model",classifier);
    } catch (Exception ex) {
        System.out.println("Exception in training the classifier."+ex);
    }
}
private Instance extractFeature(Instance inputInstance) throws Exception
{       
    String tweet = inputInstance.stringValue(0);
    StringTokenizer defaultTokenizer = new StringTokenizer(tweet);
    List<String> tokens=new ArrayList<String>();
    while (defaultTokenizer.hasMoreTokens())
    {
        String t= defaultTokenizer.nextToken();
        tokens.add(t);
    }
    Iterator<String> a = tokens.iterator();
    while(a.hasNext())
    {
                String token=(String) a.next();
                String word = token.replaceAll("#","");
                if(featureWords.contains(word))
                {                                              
                    double cont=featureMap.get(featureWords.indexOf(word))+1;
                    featureMap.put(featureWords.indexOf(word),cont);
                }
                else{
                    featureWords.add(word);
                    featureMap.put(featureWords.indexOf(word), 1.0);
                }
    }
    attributeList.clear();
    for(String featureWord : featureWords)
    {
        attributeList.add(new Attribute(featureWord));   
    }
    attributeList.add(new Attribute("Class", classValues));
    int indices[] = new int[featureMap.size()+1];
    double values[] = new double[featureMap.size()+1];
    int i=0;
    for(Map.Entry<Integer,Double> entry : featureMap.entrySet())
    {
        indices[i] = entry.getKey();
        values[i] = entry.getValue();
        i++;
    }
    indices[i] = featureWords.size();
    values[i] = (double)classValues.indexOf(inputInstance.stringValue(1));
    trainingInstances = createInstances("TRAINING_INSTANCES");
    return new SparseInstance(1.0,values,indices,1000000);
}

private void getTrainingDataset(final String INPUT_FILENAME)
{
    try{
        ArffLoader trainingLoader = new ArffLoader();
        trainingLoader.setSource(new File(INPUT_FILENAME));
        inputDataset = trainingLoader.getDataSet();
    }catch(IOException ex)
    {
        System.out.println("Exception in getTrainingDataset Method");
    }
    System.out.println("dataset "+inputDataset.numAttributes());
}
private Instances createInstances(final String INSTANCES_NAME)
{
    //create an Instances object with initial capacity as zero 
    Instances instances = new Instances(INSTANCES_NAME,attributeList,0);
    //sets the class index as the last attribute
    instances.setClassIndex(instances.numAttributes()-1);
    return instances;
}
public static void main(String[] args) throws Exception
{
      Classificatore wekaTutorial = new Classificatore();
      wekaTutorial.trainClassifier("training_set_prova_tent.arff");
      wekaTutorial.testClassifier("testing.arff");
}
public Classificatore()
{
    attributeList = new ArrayList<Attribute>();
    initialize();
}    
private void initialize()
{
    featureWords= new ArrayList<String>(); 
    featureMap = new TreeMap<>();
    classValues= new ArrayList<String>();
    classValues.add("politica");
    classValues.add("sport");
    classValues.add("musicatvcinema");
    classValues.add("infogeneriche");
    classValues.add("fattidelgiorno");
    classValues.add("statopersonale");
    classValues.add("checkin");
    classValues.add("conversazione");
}

测试方法

public void testClassifier(final String INPUT_FILENAME) throws Exception
{
    getTrainingDataset(INPUT_FILENAME);
    //trainingInstances consists of feature vector of every input
    Instances testingInstances = createInstances("TESTING_INSTANCES");
    for(Instance currentInstance : inputDataset)
    {
        //extractFeature method returns the feature vector for the current input
        Instance currentFeatureVector = extractFeature(currentInstance);
        //Make the currentFeatureVector to be added to the trainingInstances
        currentFeatureVector.setDataset(testingInstances);
        testingInstances.add(currentFeatureVector);
    }

    try {
        //Classifier deserialization
        classifier = (Classifier) weka.core.SerializationHelper.read("NaiveBayes.model");
        //classifier testing code
        for(Instance testInstance : testingInstances)
        {
            double score = classifier.classifyInstance(testInstance);
            double[] vv= classifier.distributionForInstance(testInstance);
            for(int k=0;k<vv.length;k++){
            System.out.println("distribution "+vv[k]); //this are the probabilities of the classes and as result i get 1.0 in one and 0.0 in all the others
            }
            System.out.println(testingInstances.attribute("Class").value((int)score));
        }
    } catch (Exception ex) {
        System.out.println("Exception in testing the classifier."+ex);
    }
}

我想为短消息创建一个文本分类器，此代码基于本教程 http://preciselyconcise.com/apis_and_installations/training_a_weka_classifier_in_java.php。问题在于分类器为test.arff中的几乎每条消息预测了错误的类，因为类的概率不正确。training_set_prova_tent.arff 每个类具有相同数量的消息。我遵循的示例使用 featureWords.dat如果消息中存在 1.0 并将 1.0 与单词相关联，而是我想创建自己的字典，其中包含training_set_prova_tent中存在的单词加上测试中存在的单词，并将出现的次数与每个单词相关联。

附言我知道这正是我可以使用过滤器 StringToWordVector 做的事情，但我还没有找到任何示例来解释如何将此过滤器与两个文件一起使用：一个用于训练集，一个用于测试集。因此，调整我找到的代码似乎更容易。

谢谢

Answer 1

似乎您在某些关键点上更改了您引用的网站的代码，但方式并不好。我会试着起草你想做什么以及我发现了什么错误。

你（可能）想在extractFeature做的事情是

• 将每条推文拆分为单词（标记化）
• 计算这些单词的出现次数
• 创建一个表示这些字数加上类的特征向量

您在该方法中忽略的是

1. 您永远不会重置featureMap。该行

   Map<Integer,Double> featureMap = new TreeMap<>();
   

   原本在开头extractFeatures，但你把它移到了initialize。这意味着您始终将字数相加，但从不重置它们。对于每条新推文，字数统计还包括所有先前推文的字数。我敢肯定这不是你想要的。

2. 您不会使用要作为功能的单词来初始化featureWords。是的，您创建了一个空列表，但您在每条推文中迭代填充它。 原始代码在 initialize 方法中初始化了一次，此后再也没有更改过。这有两个问题：

   随着每
   • 条新推文的出现，都会添加新的特征（单词），因此您的特征向量会随着每条推文的增长而增长。这不会是一个大问题（SparseInstance），但这意味着
   • 您的class属性始终位于其他位置。这两行适用于原始代码，因为featureWords.size()基本上是一个常量，但在代码中，类标签将位于索引 5，然后是 8，然后是 12，依此类推，但对于每个实例都必须相同。

   indices[i] = featureWords.size();
   values[i] = (double) classValues.indexOf(inputInstance.stringValue(1));
   

3. 这也体现在您用每条新推文构建一个新attributeList，而不是initialize中只构建一次，由于已经解释过的原因，这很糟糕。

可能还有更多的东西，但是 - 因为它 - 你的代码是相当不可修复的。你想要的比你的版本更接近你修改的教程源代码。

另外，你应该看看StringToWordVector，因为它看起来这正是你想要做的：

将 String 属性转换为一组属性，这些属性表示字符串中包含的文本中的单词出现次数（取决于分词器）信息。单词（属性）集由第一批筛选（通常是训练数据）确定。