Probabilidad de clasificación WEKA de las clases

Question

Me gustaría saber si hay una forma en WEKA para producir una serie de 'mejores conjeturas' para una clasificación.

Mi situación es: clasifico los datos con validación cruzada, por ejemplo, y luego en la salida de weka obtengo algo así como: estas son las 3 mejores suposiciones para la clasificación de esta instancia. Lo que quiero es que, incluso si una instancia no está correctamente clasificada, obtengo un resultado de las 3 o 5 mejores suposiciones para esa instancia.

Ejemplo:

clases: A, B, C, D, E Instancias: 1 ... 10

y salida sería: ejemplo 1 es de 90% de probabilidades de ser de clase A, 75% de probabilidad de ser clase B, 60% quiere ser clase C ..

Gracias.

Answer 1

No sé si puedes hacerlo de forma nativa, pero puedes obtener las probabilidades para cada clase, ordenarlas y tomar las tres primeras.

La función que desea es distributionForInstance(Instance instance) que devuelve double[] dando la probabilidad para cada clase.

Answer 2

No en general. La información que desea no está disponible con todos los clasificadores; en la mayoría de los casos (por ejemplo, para los árboles de decisión), la decisión es clara (aunque potencialmente incorrecta) sin un valor de confianza. Su tarea requiere clasificadores que puedan manejar la incertidumbre (como el clasificador ingenuo de Bayes).

Técnicamente, la cosa más fácil de hacer es probablemente entrenar el modelo y luego clasificar una instancia individual, para lo cual Weka debería darle el resultado deseado. En general, puede, por supuesto, hacerlo también para conjuntos de instancias, pero no creo que Weka lo proporcione de la caja. Probablemente tendrías que personalizar el código o usarlo a través de una API (por ejemplo, en R).

Answer 3

cuando calcula una probabilidad para la instancia, ¿cómo lo hace exactamente?

He publicado mis reglas y datos PART para la nueva instancia here, pero en cuanto al cálculo manual, ¡no estoy tan seguro de cómo hacerlo! Gracias

EDIT: ahora calculado:

privada flotador [] getProbDist (split String) {

// toma en algo como (52/2) lo que significa 52 casos clasificados correctamente y 2 incorrectamente clasificados.

if(prob_dis.length > 2) 
     return null; 

    if(prob_dis.length == 1){ 
     String temp = prob_dis[0]; 
     prob_dis = new String[2]; 
     prob_dis[0] = "1"; 
     prob_dis[1] = temp; 
    } 

    float p1 = new Float(prob_dis[0]); 
    float p2 = new Float(prob_dis[1]); 
    // assumes two tags 
    float[] tag_prob = new float[2]; 

    tag_prob[1] = 1 - tag_prob[1]; 
    tag_prob[0] = (float)p2/p1; 

// returns double[] as being the probabilities 

return tag_prob;  
} 

Answer 4

API de Weka tiene un método llamado Classifier.distributionForInstance() tha se puede utilizar para obtener la distribución de predicción de clasificación. Luego puede ordenar la distribución disminuyendo la probabilidad para obtener sus predicciones de N superior.

A continuación se muestra una función que imprime: (1) la etiqueta de verdad del terreno de la instancia de prueba; (2) la etiqueta predicha de classifyInstance(); y (3) la distribución de predicción de distributionForInstance(). Lo he usado con J48, pero debería funcionar con otros clasificadores.

Los parámetros de entrada son el archivo de modelo serializado (que puede crear durante la fase de capacitación del modelo y aplicar la opción -d) y el archivo de prueba en formato ARFF.

public void test(String modelFileSerialized, String testFileARFF) 
    throws Exception 
{ 
    // Deserialize the classifier. 
    Classifier classifier = 
     (Classifier) weka.core.SerializationHelper.read(
      modelFileSerialized); 

    // Load the test instances. 
    Instances testInstances = DataSource.read(testFileARFF); 

    // Mark the last attribute in each instance as the true class. 
    testInstances.setClassIndex(testInstances.numAttributes()-1); 

    int numTestInstances = testInstances.numInstances(); 
    System.out.printf("There are %d test instances\n", numTestInstances); 

    // Loop over each test instance. 
    for (int i = 0; i < numTestInstances; i++) 
    { 
     // Get the true class label from the instance's own classIndex. 
     String trueClassLabel = 
      testInstances.instance(i).toString(testInstances.classIndex()); 

     // Make the prediction here. 
     double predictionIndex = 
      classifier.classifyInstance(testInstances.instance(i)); 

     // Get the predicted class label from the predictionIndex. 
     String predictedClassLabel = 
      testInstances.classAttribute().value((int) predictionIndex); 

     // Get the prediction probability distribution. 
     double[] predictionDistribution = 
      classifier.distributionForInstance(testInstances.instance(i)); 

     // Print out the true label, predicted label, and the distribution. 
     System.out.printf("%5d: true=%-10s, predicted=%-10s, distribution=", 
          i, trueClassLabel, predictedClassLabel); 

     // Loop over all the prediction labels in the distribution. 
     for (int predictionDistributionIndex = 0; 
      predictionDistributionIndex < predictionDistribution.length; 
      predictionDistributionIndex++) 
     { 
      // Get this distribution index's class label. 
      String predictionDistributionIndexAsClassLabel = 
       testInstances.classAttribute().value(
        predictionDistributionIndex); 

      // Get the probability. 
      double predictionProbability = 
       predictionDistribution[predictionDistributionIndex]; 

      System.out.printf("[%10s : %6.3f]", 
           predictionDistributionIndexAsClassLabel, 
           predictionProbability); 
     } 

     o.printf("\n"); 
    } 
}