Changeset 34788 for main/trunk/model-sites-dev/mars/src/java

Timestamp:

2021-02-02T00:46:14+13:00 (3 years ago)

Author:

davidb

Message:

Code refactored, and then valence version of training and applying model developed

Location:

main/trunk/model-sites-dev/mars/src/java/org/greenstone/mars

Files:

• WekaApplyArousalModel.java (modified) (4 diffs)
• WekaApplyValanceModel.java (added)
• WekaTrainArousalModel.java (modified) (6 diffs)
• WekaTrainValanceModel.java (added)
• WekaUtil.java (modified) (9 diffs)

main/trunk/model-sites-dev/mars/src/java/org/greenstone/mars/WekaApplyArousalModel.java

@@ -28 +28 @@
 class WekaApplyArousalModel
 {
-    //public final static String AROUSAL_ATTRIBUTE_NAME = "arousal_sample_26500ms";
-    //public final static String VALANCE_ATTRIBUTE_NAME = "valance_sample_26500ms";
 
-    public final static String PREDICT_ATTRIBUTE_NAME = WekaUtil.AROUSAL_ATTRIBUTE_NAME;
+    //public final static String PREDICT_ATTRIBUTE_NAME = WekaUtil.AROUSAL_ATTRIBUTE_NAME;
     
 
-    /*
-    public static Instances applyFilter(Instances data_instances,String additional_remove)
-    {
-    String remove_option_args = ("-R 425,458-466"); // remove ordinal attributes
-    if (additional_remove != null) {
-        // top up, e.g. '472' representing valance in ground-truth files
-        remove_option_args += "," + additional_remove;
-    }
-
-
-    Instances filtered_data_instances = null;
-    try {
-        String[] filter_options = weka.core.Utils.splitOptions(remove_option_args); // remove ordinal attributes and 'valance'
-        Remove filter_remove = new Remove();
-        filter_remove.setOptions(filter_options);
-        filter_remove.setInputFormat(data_instances);
-        filtered_data_instances = Filter.useFilter(data_instances, filter_remove);
-    }
-    catch (Exception e) {
-        e.printStackTrace();
-        System.exit(1);
-    }
-    
-    return filtered_data_instances; 
-    }
-    */
-    
-    /*
-    
-    public static void checkDatasetInstancesCompatible(Instances new_instances)
-    {
-
-    final String gt_datasource_filename = "collect/deam/etc/deam-essentia-features-arousal-valence.arff";
-
-    try {
-        DataSource gt_data_source = new DataSource(gt_datasource_filename);
-        Instances gt_instances = gt_data_source.getDataSet();
-        gt_instances = applyFilter(gt_instances,"472"); // top up with removing 'valance'
-        
-        gt_instances.setClassIndex(gt_instances.numAttributes() - 1);
-
-        String equal_header_message = gt_instances.equalHeadersMsg(new_instances);
-        
-        if (equal_header_message != null) {
-        System.err.println("Headers to datasets were not equal!");
-        System.err.println(equal_header_message);
-        System.exit(1);
-        }
-    }
-    catch (Exception e) {
-        e.printStackTrace();
-        System.exit(1);
-    }
-
-    }
-    */
     
     public static void main(String[] args)
     {
+    /*
     if (args.length != 3) {
         System.err.println("Error: incorrect number of command-line arguments");
@@ -98 +41 @@
         System.exit(1);
     }
-        
+    */
+
+    WekaUtil.checkUsageApplyModel(args);
+    
     String classifier_input_filename        = args[0];
     String unclassified_data_input_filename = args[1];
     String classified_data_output_filename  = args[2];
 
+
+    Classifier classifier = WekaUtil.loadClassifierModel(classifier_input_filename);
+
+    /*
         System.out.println("Loading Weka saved Classifier: " + classifier_input_filename);
 
@@ -152 +102 @@
         WekaUtil.checkDatasetInstancesCompatible(unlabeled_instances);
 
+
+
+
+        
         // Create copy where the predictions are to be made
         Instances labeled_instances = new Instances(unlabeled_instances);
@@ -199 +153 @@
         e.printStackTrace();
     }
-       
+
+    */
+
+
+    Instances unlabeled_instances= WekaUtil.loadInstancesForClassification(unclassified_data_input_filename);
+
+    // It is permissible to run this code and supply it with a data file that includes groundtruth in it.
+    // In this situation, the 'unlabeled' instances:
+    //  (i) need to be massaged to be in the same form as truly unlabeled data
+    // (ii) we also set up 'groundtruth_instances' as an alias (reference) to 'filtered_unlabeled_instanced'
+    //      to trigger calculating the error on the predicted vaues
+
+    boolean has_groundtruth_data = WekaUtil.instancesHavePredictAttribute(unlabeled_instances,WekaUtil.AROUSAL_ATTRIBUTE_NAME); 
+
+    // The following deals with (i) internally, ensuring that what is returned is suitable for making predictions on
+    Instances filtered_unlabeled_instances
+        = WekaUtil.filterInstancesForApplying(unlabeled_instances,has_groundtruth_data,
+                          WekaUtil.AROUSAL_ATTRIBUTE_NAME,"472");
+
+    // The following deals with (ii)
+    Instances groundtruth_instances = (has_groundtruth_data) ? filtered_unlabeled_instances : null;
+    
+    Instances labeled_instances = WekaUtil.makePredictions(classifier, filtered_unlabeled_instances, groundtruth_instances);
+        
+    try {
+        // Save labeled data
+        
+        System.out.println("Saving labeled instances: " + classified_data_output_filename);     
+        FileWriter fw = new FileWriter(classified_data_output_filename);
+        BufferedWriter bw = new BufferedWriter(fw);
+        
+        bw.write(labeled_instances.toString());
+        bw.newLine();
+        bw.flush();
+        bw.close();
+             
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+    }
+        
     }
 }

main/trunk/model-sites-dev/mars/src/java/org/greenstone/mars/WekaTrainArousalModel.java

@@ -1 +1 @@
 package org.greenstone.mars;
     
-import java.util.Random;
-
-import weka.core.converters.ConverterUtils.DataSource;
+//import weka.core.converters.ConverterUtils.DataSource;
 import weka.core.Instances;
  
-import weka.filters.Filter;
-import weka.filters.unsupervised.attribute.Remove;
+//import weka.filters.Filter;
+//import weka.filters.unsupervised.attribute.Remove;
 
+import weka.classifiers.Classifier;
 import weka.classifiers.Evaluation;
-import weka.classifiers.trees.REPTree;
 
 // Based on:
@@ -30 +28 @@
 class WekaTrainArousalModel
 {
-    // Scheme:       weka.classifiers.trees.REPTree -M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0
+    // Scheme:       weka.classifiers.trees.REPTree -M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0   -- (i.e., default vals)
     // Relation:     deam-essentia-features-arousal-valence-weka.filters.unsupervised.attribute.Remove-R472-weka.filters.unsupervised.attribute.Remove-R458-466
     // Instances:    1743
+
+    // Note, above missed -R 425 and 427 (ordinal vals)
     
     public static void main(String[] args)
     {
+    /*
     if (args.length != 2) {
         System.err.println("Error: incorrect number of command-line arguments");
         System.err.println("Usage: input_training_data.arff output-model.{model|ser}");
         System.exit(1);
+        }*/
+    
+    WekaUtil.checkUsageTraining(args);
+    
+    String input_data_filename = args[0];
+    String output_model_filename = args[1];
+
+    // knock out 472 (valance) from dataset
+    Instances filtered_data_instances = WekaUtil.loadAndFilterDataInstances(input_data_filename, "472");
+    Classifier classifier = WekaUtil.trainREPTree(filtered_data_instances);
+    System.out.println(classifier);
+
+    Evaluation eval = WekaUtil.evaluateClassifier(classifier,filtered_data_instances);
+    System.out.println(eval.toSummaryString());
+
+    try {
+        System.out.println("Saving REPTree classifier model as: " + output_model_filename);
+        weka.core.SerializationHelper.write(output_model_filename, classifier);
     }
-    String input_arff_filename = args[0];
-    String output_model_filename = args[1];
+    catch (Exception e) {
+        e.printStackTrace();
+    }
     
+
+    /*
         System.out.println("Training on ARFF file: " + input_arff_filename);
 
@@ -49 +71 @@
         DataSource data_source = new DataSource(input_arff_filename);
         Instances data_instances = data_source.getDataSet();
-        
+
+        // *********
         Instances filtered_data_instances = WekaUtil.applyFilter(data_instances,"472"); // top-up with removal of 'valance'
 
@@ -65 +88 @@
         System.out.println(classifier);
 
+        / *
         // Evaluate     
         Evaluation eval = new Evaluation(filtered_data_instances);
@@ -71 +95 @@
         eval.crossValidateModel(classifier, filtered_data_instances, folds, rand);
         System.out.println(eval.toSummaryString());
+        * /
+        
+        Evaluation eval = WekaUtil.evaluateClassifier(classifier,filtered_data_instances);
+        System.out.println(eval.toSummaryString());
 
         System.out.println("Saving REPTree classifier model as: " + output_model_filename);
@@ -80 +108 @@
         e.printStackTrace();
     }
- 
+    */
     }
 }

main/trunk/model-sites-dev/mars/src/java/org/greenstone/mars/WekaUtil.java

@@ -8 +8 @@
 import java.io.FileReader;
 import java.io.FileWriter;
+
+import java.util.Random;
 
 import weka.core.converters.ConverterUtils.DataSource;
@@ -19 +21 @@
 
 import weka.classifiers.Classifier;
-
+import weka.classifiers.Evaluation;
+
+import weka.classifiers.trees.REPTree;
 
 // Based on:
@@ -27 +31 @@
 {
     public final static String AROUSAL_ATTRIBUTE_NAME = "arousal_sample_26500ms";
-    public final static String VALANCE_ATTRIBUTE_NAME = "valance_sample_26500ms";
-
-
+    public final static String VALANCE_ATTRIBUTE_NAME = "valence_sample_26500ms";
+
+
+    public static void checkUsageTraining(String[] args)
+    {
+    if (args.length != 2) {
+        System.err.println("Error: incorrect number of command-line arguments");
+        System.err.println("Usage: input_training_data.arff output-model.{model|ser}");
+        System.exit(1);
+    }
+    
+    }
+    
+    public static void checkUsageApplyModel(String[] args)
+    {
+        if (args.length != 3) {
+        System.err.println("Error: incorrect number of command-line arguments");
+        System.err.println("Usage: trained-model.{model|ser} unclassified-data.{arff|csv} classified-data.{arff|csv}");
+        System.exit(1);
+    }
+    }
+    
     public static Instances applyFilter(Instances data_instances, String additional_remove)
     {
@@ -43 +66 @@
     // The following filtering produces as tree with 41 nodes
     
-    String remove_option_args = ("-R 425,427,458-466");
+    String remove_option_args = ("-R 425,427,458-466"); // knock out 11 attributes (472 -> 461)
 
     
@@ -51 +74 @@
 
     if (additional_remove != null) {
-        // top up, e.g. '472' representing valance in ground-truth files
+        // top up,
+        //   e.g. '471' representing arousal in ground-truth files
+        //   e.g. '472' representing valance in ground-truth files
         remove_option_args += "," + additional_remove;
     }
@@ -58 +83 @@
     Instances filtered_data_instances = null;
     try {
-        // remove ordinal attributes and any additional topups, such as 'valance' (when predicting 'arousal')
+        // remove ordinal attributes and any additional topups,
+        // such as 'valance' (when predicting 'arousal') and vice versa
         
         String[] filter_options = weka.core.Utils.splitOptions(remove_option_args); 
@@ -75 +101 @@
 
     
-    public static void checkDatasetInstancesCompatible(Instances new_instances)
+    public static void checkDatasetInstancesCompatible(Instances new_instances, String additional_remove)
     {
 
@@ -83 +109 @@
         DataSource gt_data_source = new DataSource(gt_datasource_filename);
         Instances gt_instances = gt_data_source.getDataSet();
-        gt_instances = applyFilter(gt_instances,"472"); // top up with removing 'valance'
+        gt_instances = applyFilter(gt_instances,additional_remove); // remove 'valance' or 'arousal'
         
         gt_instances.setClassIndex(gt_instances.numAttributes() - 1);
@@ -101 +127 @@
 
     }
+
+
+    public static Instances loadAndFilterDataInstances(String input_filename, String additional_attribute_remove)
+    {
+        System.out.println("Training on file: " + input_filename);
+    Instances filtered_data_instances = null;
+    
+    try {
+        DataSource data_source = new DataSource(input_filename);
+        Instances data_instances = data_source.getDataSet();
+
+        // Training dataset has two ground-truth attributes: 'arousal' and 'valance'.
+        // When training for one, need to knock out the other.  This is the purpose
+        // of 'additional_attribute_remove'
+        filtered_data_instances = applyFilter(data_instances,additional_attribute_remove); 
+
+        // With the 'other' ground-truth attribute taken out, the column to predict
+        // will always be the last column
+        filtered_data_instances.setClassIndex(filtered_data_instances.numAttributes()-1);       
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+        System.exit(1);
+    }
+    
+    return filtered_data_instances;
+    }
+
+    public static Classifier trainREPTree(Instances data_instances)
+    {
+    REPTree classifier = null;
+    
+    try {
+        // Build classifier
+        classifier = new REPTree();
+        String[] reptree_options = weka.core.Utils.splitOptions("-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0");
+        classifier.setOptions(reptree_options);
+
+        classifier.buildClassifier(data_instances);
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+        System.exit(1);
+    }
+
+    return classifier;
+    }
+
+
+    public static Evaluation evaluateClassifier(Classifier classifier, Instances data_instances)
+    {
+    Evaluation eval = null;
+    try {
+        eval = new Evaluation(data_instances);
+        Random rand = new Random(1);
+        int folds = 10;
+        
+        eval.crossValidateModel(classifier, data_instances, folds, rand);
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+        System.exit(1);
+    }
+    
+    return eval;
+    }
+
+    /* Apply Model Specific Methods */
+
+    public static Classifier loadClassifierModel(String classifier_input_filename
+
+                           )
+    {
+        System.out.println("Loading Weka saved Classifier: " + classifier_input_filename);
+    Classifier classifier = null;
+    try {
+        FileInputStream fis = new FileInputStream(classifier_input_filename);   
+        BufferedInputStream bis= new BufferedInputStream(fis);
+        classifier = (Classifier)SerializationHelper.read(bis);
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+        System.exit(1);
+    }
+
+    return classifier;
+    }
+
+
+    public static Instances loadInstancesForClassification(String unlabeled_input_filename)
+    {
+    System.out.println("Loading unlabeled instances: " + unlabeled_input_filename);
+    Instances unlabeled_instances = null;
+
+    try {
+        DataSource data_source = new DataSource(unlabeled_input_filename);
+        unlabeled_instances = data_source.getDataSet();
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+        System.exit(1);
+    }
+
+    return unlabeled_instances;
+    }
+
+    public static boolean instancesHavePredictAttribute(Instances data_instances, String predict_attribute_name)
+    {
+    Attribute predict_attribute = data_instances.attribute(predict_attribute_name);
+
+    return predict_attribute != null;
+    }
+
+    
+
+    public static Instances filterInstancesForApplying(Instances unlabeled_instances, boolean has_groundtruth_data,
+                               String predict_attribute_name, String additional_attribute_remove)
+    {
+    Instances filtered_unlabeled_instances = null;
+
+        
+    // Work out if we're dealing with a ground-truth ARFF file or not
+    // (i.e. already has the desired attribute)
+
+    //Attribute predict_attribute = unlabeled_instances.attribute(predict_attribute_name);
+
+    if (!has_groundtruth_data) {
+
+        filtered_unlabeled_instances = WekaUtil.applyFilter(unlabeled_instances,null); // no additional top-up to remove        
+        int num_attributes = filtered_unlabeled_instances.numAttributes();
+        
+        Attribute new_predict_attribute = new Attribute(predict_attribute_name);
+        filtered_unlabeled_instances.insertAttributeAt(new_predict_attribute,num_attributes);
+        // ******
+        //num_attributes++;     
+    }
+    else {
+        // Dealing with ground-truth data:
+        //   => already has 'arousal' and 'valance' attributes
+        //   => need to keep the 'predict_attribute_name' and remove the other one
+        //   => (its -R value of which is specified in 'additional_attribute_remove')
+        
+        // Need to massage instances into same form as an unclassified data input file
+        filtered_unlabeled_instances = WekaUtil.applyFilter(unlabeled_instances,additional_attribute_remove); 
+        
+        // reference share this as 'groundtruth_instances' to trigger error calculation and output
+        // ******
+        // groundtruth_instances = filtered_unlabeled_instances;
+    }
+    
+    int num_attributes = filtered_unlabeled_instances.numAttributes();
+
+    // Set class attribute
+    filtered_unlabeled_instances.setClassIndex(num_attributes - 1);
+    
+    // ***** Do I still want to run the check????
+    WekaUtil.checkDatasetInstancesCompatible(filtered_unlabeled_instances, additional_attribute_remove);
+    
+    return filtered_unlabeled_instances;
+    }
+
+
+    public static Instances makePredictions(Classifier classifier, Instances unlabeled_instances, Instances groundtruth_instances)
+    {
+        
+    // Create copy where the predictions are to be made
+    Instances labeled_instances = new Instances(unlabeled_instances);
+
+    try {
+        // Label instances
+    
+        final int num_instances = unlabeled_instances.numInstances();       
+        for (int i=0; i<num_instances; i++) {
+        Instance unlabeled_instance = unlabeled_instances.instance(i);
+        
+        System.out.print("Making prediction for: " + i + "/" + num_instances);
+        double classified_value = classifier.classifyInstance(unlabeled_instance);
+        labeled_instances.instance(i).setClassValue(classified_value);
+        
+        String formatted_classified_value = String.format("% 06.3f", classified_value);
+        
+        System.out.print(" value = " + formatted_classified_value);
+        
+        if (groundtruth_instances != null) {
+            Instance gt_instance = groundtruth_instances.instance(i);
+            double gt_class_value = gt_instance.classValue();
+            double error = Math.abs(classified_value - gt_class_value);
+            
+            String formatted_error = String.format("%.3f", error);
+            System.out.print("  [error: " + formatted_error + "]");
+        }
+        System.out.println();
+        }
+    }
+    catch (Exception e) {
+        e.printStackTrace();
+        System.exit(1);
+    }
+    
+    return labeled_instances;
+    }
     
 }