source: branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Problems.DynamicalSystemsModelling/3.3/ProblemInstanceProvider.cs @ 16954

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text.RegularExpressions;
using HeuristicLab.Data;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DynamicalSystemsModelling.Instances;
using HeuristicLab.Problems.Instances;
using HeuristicLab.Problems.Instances.DataAnalysis;

namespace HeuristicLab.Problems.DynamicalSystemsModelling {
  public class ProblemInstanceProvider : ProblemInstanceProvider<Problem> {
    public override string Name {
      get { return "Dynamic Systems"; }
    }
    public override string Description {
      get {
        return "A set of problem instances for dynamical modelling.";
      }
    }
    public override Uri WebLink {
      get { return null; }
    }
    public override string ReferencePublication {
      get { return ""; }
    }

    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
      List<DataDescriptor> descriptorList = new List<DataDescriptor>();
      descriptorList.Add(BacterialRespiration());
      descriptorList.Add(BarMagnets());
      descriptorList.Add(ChemicalReaction());
      descriptorList.Add(E_Cell());
      descriptorList.Add(Glider());
      descriptorList.Add(LotkaVolterra());
      descriptorList.Add(PredatorPrey());
      descriptorList.Add(S_System());
      descriptorList.Add(ShearFlow());
      descriptorList.Add(ThreeSpeciesLotkaVolterra());
      descriptorList.Add(VanDerPol());
      return descriptorList;
    }

    private DataDescriptor BacterialRespiration() {
      return new DataDescriptor {
        Name = "Bacterial Respiration",
        Description = "Publication: M. Schmidt, H. Lipson; Data-Mining Dynamical Systems: Automated Symbolic System Identification for Exploratory Analysis, ESDA 2008.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "bacterial_1.csv"
      };
    }


    private DataDescriptor BarMagnets() {
      return new DataDescriptor {
        Name = "Bar Magnets",
        Description = "Publication: M. Schmidt, H. Lipson; Data-Mining Dynamical Systems: Automated Symbolic System Identification for Exploratory Analysis, ESDA 2008.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "bar_magnets_1.csv"
      };
    }

    private DataDescriptor ChemicalReaction() {
      return new DataDescriptor {
        Name = "ChemicalReaction",
        Description = "Publication: H. Iba, E. Sakamoto: Inference of Differential Equation Models by Genetic Programming, Information Sciences Volume 178, Issue 23, 1 December 2008, Pages 4453 - 4468",
        TargetVariables = new[] { "y1", "y2", "y3" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "ChemicalReaction.csv"
      };
    }

    private DataDescriptor E_Cell() {
      return new DataDescriptor {
        Name = "E-CELL",
        Description = "Publication: H. Iba, E. Sakamoto: Inference of Differential Equation Models by Genetic Programming, Information Sciences Volume 178, Issue 23, 1 December 2008, Pages 4453 - 4468",
        TargetVariables = new[] { "y1", "y2", "y3" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 40) },
        TestEpisodes = new IntRange[] { },
        FileName = "E-CELL.csv"
      };
    }

    private DataDescriptor Glider() {
      return new DataDescriptor {
        Name = "Bar Magnets",
        Description = "Publication: M. Schmidt, H. Lipson; Data-Mining Dynamical Systems: Automated Symbolic System Identification for Exploratory Analysis, ESDA 2008.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "Glider_1.csv"
      };
    }

    private DataDescriptor LotkaVolterra() {
      return new DataDescriptor {
        Name = "Lotka-Volterra",
        Description = "Publication: Gaucel et al.: Learning Dynamical Systems using Standard Symbolic Regression, Evostar 2014.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 193) },
        TestEpisodes = new IntRange[] { },
        FileName = "LotkaVolterra.csv"
      };
    }

    private DataDescriptor PredatorPrey() {
      return new DataDescriptor {
        Name = "Predator Prey",
        Description = "Publication: M. Schmidt, H. Lipson; Data-Mining Dynamical Systems: Automated Symbolic System Identification for Exploratory Analysis, ESDA 2008.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "predator_prey_1.csv"
      };
    }

    private DataDescriptor ShearFlow() {
      return new DataDescriptor {
        Name = "Shear Flow",
        Description = "Publication: M. Schmidt, H. Lipson; Data-Mining Dynamical Systems: Automated Symbolic System Identification for Exploratory Analysis, ESDA 2008.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "shear_flow_1.csv"
      };
    }

    private DataDescriptor S_System() {
      return new DataDescriptor {
        Name = "S-System",
        Description = "Publication: H. Iba, E. Sakamoto: Inference of Differential Equation Models by Genetic Programming, Information Sciences Volume 178, Issue 23, 1 December 2008, Pages 4453 - 4468",
        TargetVariables = new[] { "y1", "y2", "y3", "y4", "y5" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 30), new IntRange(31, 61), new IntRange(62, 92) },
        TestEpisodes = new IntRange[] { },
        FileName = "S-System.csv"
      };
    }


    private DataDescriptor ThreeSpeciesLotkaVolterra() {
      return new DataDescriptor {
        Name = "Lotka Volterra (three species)",
        Description = "Publication: H. Iba, E. Sakamoto: Inference of Differential Equation Models by Genetic Programming, Information Sciences Volume 178, Issue 23, 1 December 2008, Pages 4453 - 4468",
        TargetVariables = new[] { "y1", "y2", "y3" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100)},
        TestEpisodes = new IntRange[] { },
        FileName = "ThreeLotkaVolterra.csv"
      };
    }


    private DataDescriptor VanDerPol() {
      return new DataDescriptor {
        Name = "Van der Pol Oscillator",
        Description = "Publication: M. Schmidt, H. Lipson; Data-Mining Dynamical Systems: Automated Symbolic System Identification for Exploratory Analysis, ESDA 2008.",
        TargetVariables = new[] { "y1", "y2" },
        InputVariables = new string[] { },
        TrainingEpisodes = new IntRange[] { new IntRange(0, 100) },
        TestEpisodes = new IntRange[] { },
        FileName = "van_der_pol_1.csv"
      };
    }

    public override Problem LoadData(IDataDescriptor id) {
      var descriptor = (DataDescriptor)id;

      var instanceArchiveName = GetResourceName(descriptor.FileName + @"\.zip");
      using (var instancesZipFile = new ZipArchive(GetType().Assembly.GetManifestResourceStream(instanceArchiveName), ZipArchiveMode.Read)) {
        var entry = instancesZipFile.GetEntry(descriptor.FileName);
        NumberFormatInfo numberFormat;
        DateTimeFormatInfo dateFormat;
        char separator;
        using (Stream stream = entry.Open()) {
          TableFileParser.DetermineFileFormat(stream, out numberFormat, out dateFormat, out separator);
        }

        TableFileParser csvFileParser = new TableFileParser();
        using (Stream stream = entry.Open()) {
          csvFileParser.Parse(stream, numberFormat, dateFormat, separator, true);
        }

        Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);


        // using a RegressionProblemData is suboptimal here --> TODO introduce a new datatype and refactor the whole problem 
        var problemData = new RegressionProblemData(dataset, descriptor.InputVariables, descriptor.TargetVariables.First());
        problemData.TrainingPartition.Start = 0;
        problemData.TrainingPartition.End = 0;
        problemData.TestPartition.Start = 0;
        problemData.TestPartition.End = 0;

        var problem = new Problem();
        problem.Name = descriptor.Name;
        problem.Description = descriptor.Description;
        problem.ProblemData = problemData;
        foreach (var ep in descriptor.TrainingEpisodes) problem.TrainingEpisodes.Add((IntRange)ep.Clone());
        foreach (var targetVar in problem.TargetVariables) {
          problem.TargetVariables.SetItemCheckedState(targetVar, descriptor.TargetVariables.Contains(targetVar.Value));
        }
        return problem;
      }
    }

    protected virtual string GetResourceName(string fileName) {
      return GetType().Assembly.GetManifestResourceNames()
              .Where(x => Regex.Match(x, @".*\.Instances\." + fileName).Success).SingleOrDefault();
    }
  }
}