source: branches/CEDMA-Exporter-715/tools/CedmaExporter/CedmaExporter.cs @ 2228

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SemWeb;
using HeuristicLab.GP;
using HeuristicLab.Core;
using HeuristicLab.GP.StructureIdentification;
using System.IO;
using HeuristicLab.Data;
using SVM;

namespace CedmaExporter {
  class CedmaExporter {

    public static void Export(string inputFileName, string outputFileName) {

      string rdfConnectionString = "sqlite:rdf:Data Source=\"" + inputFileName + "\"";
      using (StreamWriter writer = File.CreateText(outputFileName)) {
        using (Store store = Store.Create(rdfConnectionString)) {
          WriteColumnHeaders(store, writer);
          WriteModels(store, writer, new ModelExporter(Path.GetDirectoryName(outputFileName), true));
        }
      }
    }

    private static void WriteModels(Store store, StreamWriter writer, ModelExporter exporter) {
      var subjects = store.SelectSubjects(new Entity(Ontology.InstanceOf.Uri), new Entity(Ontology.TypeModel.Uri));
      int i = 0;
      foreach (var model in subjects) {
        writer.Write(i++); writer.Write("; ");
        string modelFileName = "model_" + i.ToString();
        writer.Write(modelFileName); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TargetVariable)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingMeanSquaredError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationMeanSquaredError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestMeanSquaredError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingCoefficientOfDetermination)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationCoefficientOfDetermination)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestCoefficientOfDetermination)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingMeanAbsolutePercentageError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationMeanAbsolutePercentageError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestMeanAbsolutePercentageError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingMeanAbsolutePercentageOfRangeError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationMeanAbsolutePercentageOfRangeError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestMeanAbsolutePercentageOfRangeError)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TrainingVarianceAccountedFor)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.ValidationVarianceAccountedFor)[0]).ToString()); writer.Write("; ");
        writer.Write(LiteralValue(store.SelectObjects(model, Ontology.TestVarianceAccountedFor)[0]).ToString()); writer.Write("; ");
        WriteVariableImpacts(writer, store, model);
        writer.WriteLine();
        var data = PersistenceManager.RestoreFromGZip(Convert.FromBase64String((string)LiteralValue(store.SelectObjects(model, Ontology.SerializedData)[0])));
        exporter.Export(modelFileName, data);
      }
    }

    private static void WriteVariableImpacts(StreamWriter writer, Store store, Entity model) {
      var inputVariables = store.SelectObjects(model, Ontology.HasInputVariable);
      Dictionary<string, List<double>> impacts = new Dictionary<string,List<double>>();
      foreach (Entity inputVariable in inputVariables) {
        var variableImpacts = new List<double>();
        impacts[inputVariable.ToString()] = variableImpacts;
        variableImpacts.Add((double)(LiteralValue(store.SelectObjects(inputVariable, Ontology.EvaluationImpact)[0])));
        variableImpacts.Add((double)(LiteralValue(store.SelectObjects(inputVariable, Ontology.QualityImpact)[0])));
      }

      foreach (string varName in impacts.Keys.OrderBy(x => x)) {
        writer.Write(impacts[varName][0]); writer.Write("; ");
        writer.Write(impacts[varName][1]); writer.Write("; ");
      }
    }

    private static void WriteColumnHeaders(Store store, StreamWriter writer) {
      writer.Write("Id; Filename; TargetVariable; " +
        "TrainingMSE; ValidationMSE; TestMSE; " +
        "TrainingR2; ValidationR2; TestR2; " +
        "TrainingMAPE; ValidationMAPE; TestMAPE; " +
        "TrainingMAPRE; ValidationMAPRE; TestMAPRE; " +
        "TrainingVAF; ValidationVAF; TestVAF; ");

      List<string> inputVarNames = new List<string>();
      Statement template = new Statement();
      template.Predicate = Ontology.HasInputVariable;
      var inputVars = store.Select(template).Select(x => x.Object);
      foreach (Entity inputVar in inputVars) {
        var inputVarName = ((Literal)store.SelectObjects(inputVar, Ontology.Name)[0]).Value;
        if (!inputVarNames.Contains(inputVarName)) inputVarNames.Add(inputVarName);
      }
      inputVarNames.Sort();
      foreach (string inputVarName in inputVarNames) {
        writer.Write(inputVarName); writer.Write(": EvaluationImpact; "); 
        writer.Write(inputVarName); writer.Write(": QualityImpact; ");
      }
      writer.WriteLine();
    }

    private static object LiteralValue(Resource resource) {
      return ((Literal)resource).ParseValue();
    }
  }

  class ModelExporter {
    private string outputDir;
    private bool debugging;
    IFunctionTreeExporter treeExporter = new SymbolicExpressionExporter();

    public ModelExporter(string outputDir, bool debugging) {
      this.outputDir = outputDir;
      this.debugging = debugging;
    }

    public void Export(string modelFileName, IStorable model) {
      if (debugging) return;
      if (model is IFunctionTree) {
        using (StreamWriter writer = File.CreateText(Path.Combine(outputDir, modelFileName + ".gp.txt"))) {
          writer.Write(treeExporter.Export((IFunctionTree)model));
        }
      } else if (model is SVMModel) {
        SVMModel svmModel = (SVMModel)model;
        RangeTransform.Write(Path.Combine(outputDir, modelFileName + ".svm.transform.txt"), svmModel.RangeTransform);
        SVM.Model.Write(Path.Combine(outputDir, modelFileName + ".svm.model.txt"), svmModel.Model);
      } else throw new NotSupportedException("This type of model is not supported by the CedmaExporter: " + model);
    }
  }
}