source: main/trunk/model-sites-dev/mars/src/java/org/greenstone/mars/WekaUtil.java@ 34797

package org.greenstone.mars;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

import java.util.Random;

import weka.core.converters.ConverterUtils.DataSource;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.SerializationHelper;

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:
//   https://waikato.github.io/weka-wiki/use_weka_in_your_java_code/

class WekaUtil
{
    public final static String AROUSAL_ATTRIBUTE_NAME = "arousal_sample_26500ms";
    public final static String VALENCE_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)
    {
    // Avoid ordinal values in dataset
    // (as tricky to work with in amc-essentia collection as essentia feature extractor
    //  on a single file is not guaranteed to generate the same set of ordinal vals in
    //  CSV file generated)

    // Note, for RepTree, with vals to algorithm, does produce some outlier rules
    // using spectral_spread.dvar with high int values, e.g.:
    //  lowlevel.spectral_spread.dvar < 3831853219840
    //
    // The following filtering produces as tree with 41 nodes
    
    String remove_option_args = ("-R 425,427,458-466"); // knock out 11 attributes (472 -> 461)

    
    // For 'arousal', filtering to the following produces a smaller REPTree
    // with only 27 nodes
    //String remove_option_args = ("-R 458-466"); 

    if (additional_remove != null) {
        // top up,
        //   e.g. '471' representing arousal in ground-truth files
        //   e.g. '472' representing valence in ground-truth files
        remove_option_args += "," + additional_remove;
    }


    Instances filtered_data_instances = null;
    try {
        // remove ordinal attributes and any additional topups,
        // such as 'valence' (when predicting 'arousal') and vice versa
        
        String[] filter_options = weka.core.Utils.splitOptions(remove_option_args); 
        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, String additional_remove)
    {

    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,additional_remove); // remove 'valence' or 'arousal'
        
        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 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 'valence'.
        // 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 'valence' 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;
    }
    
}