source: main/trunk/model-sites-dev/mars/WekaApplyArousalModel.java@ 34778

//import java.util.Random;

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 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;


// Based on:
//   https://waikato.github.io/weka-wiki/use_weka_in_your_java_code/

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 = "arousal_sample_26500ms";
    

    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");
        System.err.println("Usage: trained-model.{model|ser} unclassified-data.{arff|csv} classified-data.{arff|csv}");
        System.exit(1);
    }
        
    String classifier_input_filename        = args[0];
    String unclassified_data_input_filename = args[1];
    String classified_data_output_filename  = args[2];

        System.out.println("Loading Weka saved Classifier: " + classifier_input_filename);

    try {
        FileInputStream fis = new FileInputStream(classifier_input_filename);   
        BufferedInputStream bis= new BufferedInputStream(fis);
        Classifier classifier = (Classifier)SerializationHelper.read(bis);

        //
        // Load in unlabeled data
        //
        
        System.out.println("Loading unlabeled instances: " + unclassified_data_input_filename);

        //FileReader fr = new FileReader(unclassified_data_input_filename);
        //BufferedReader br = new BufferedReader(fr);
        //Instances unlabeled_instances = new Instances(br);
        //br.close();

        DataSource data_source = new DataSource(unclassified_data_input_filename);
        Instances unlabeled_instances = data_source.getDataSet();

        // Work out if we're dealing with a ground-truth ARFF file or not
        // (i.e. already has the desired attribute)

        Instances groundtruth_instances = null;     
        Attribute predict_attribute = unlabeled_instances.attribute(PREDICT_ATTRIBUTE_NAME);
        
        if (predict_attribute == null) {

        unlabeled_instances = applyFilter(unlabeled_instances,null); // no additional top-up to remove      
        int num_attributes = unlabeled_instances.numAttributes();

        Attribute arousal_attribute = new Attribute(AROUSAL_ATTRIBUTE_NAME);
        unlabeled_instances.insertAttributeAt(arousal_attribute,num_attributes);
        num_attributes++;
        
        //Attribute valance_attribute = new Attribute(VALANCE_ATTRIBUTE_NAME);
        //unlabeled_instances.insertAttributeAt(valance_attribute,num_attributes);
        //num_attributes++;

        //predict_attribute = new Attribute(PREDICT_ATTRIBUTE_NAME);
        //unlabeled_instances.insertAttributeAt(predict_attribute,num_attributes);
        //unlabeled_instances.setClassIndex(num_attributes);
        //num_attributes++;

        //predict_attribute = unlabeled_instances.attribute(PREDICT_ATTRIBUTE_NAME);
        //unlabeled_instances.setClass(predict_attribute);

        //unlabeled_instances.setClassIndex(num_attributes - 1);
        }
        else {
        // Dealing with ground-truth data:
        //   => already has 'arousal' attribute
        //   => in fact has 'valance' attribute too, which we want to remove
        
        unlabeled_instances = applyFilter(unlabeled_instances,"472"); // top-up with removal of 'valance'
        //unlabeled_instances.setClass(predict_attribute);
        
        // reference share this as 'groundtruth_instances' to trigger error calculation and output
        groundtruth_instances = unlabeled_instances;
        }

        int num_attributes = unlabeled_instances.numAttributes();
        unlabeled_instances.setClassIndex(num_attributes - 1);
        
        checkDatasetInstancesCompatible(unlabeled_instances);
        
        // Set class attribute
        //unlabeled_instances.setClassIndex(gt_instances.numAttributes() - 2);


        // Create copy where the predictions are to be made
        Instances labeled_instances = new Instances(unlabeled_instances);

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

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