Changeset 17928 for branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4

Timestamp:

04/06/21 13:13:32 (4 years ago)

Author:

dpiringe

Message:

#3026

• merged trunk into branch

Location:

branches/3026_IntegrationIntoSymSpace

Files:

• . (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4 (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GAM (copied) (copied from trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GAM)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModelSurrogate.cs (modified) (7 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/M5Regression (deleted)
• HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelSurrogate.cs (modified) (4 diffs)

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs

@@ -35 +35 @@
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Random;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Classification;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
@@ -338 +340 @@
               symbolicProblem.FitnessCalculationPartition.End = SamplesEnd.Value;
             }
+
+            // We need to set the estimation limits because they are recalculated by the problem
+            // whenever the data partitions change.
+            // Instead of explicitly handling all types we could also check the parameters-collection 
+            // for a parameter with name "EstimationLimits".
+            SetEstimationLimits(problem, new[] { typeof(SymbolicRegressionSingleObjectiveProblem),
+                                                 typeof(SymbolicRegressionMultiObjectiveProblem),
+                                                 typeof(SymbolicClassificationSingleObjectiveProblem),
+                                                 typeof(SymbolicClassificationMultiObjectiveProblem) });
+
             clonedAlgorithm.Prepare();
             clonedAlgorithms.Add(clonedAlgorithm);
@@ -509 +521 @@
       foreach (KeyValuePair<string, List<IClassificationSolution>> solutions in resultSolutions) {
         // at least one algorithm (GBT with logistic regression loss) produces a classification solution even though the original problem is a regression problem.
-        var targetVariable = solutions.Value.First().ProblemData.TargetVariable;
         var dataset = (Dataset)Problem.ProblemData.Dataset;
         if (ShuffleSamples.Value) {
@@ -515 +526 @@
           dataset = dataset.Shuffle(random);
         }
-        var problemDataClone = new ClassificationProblemData(dataset, Problem.ProblemData.AllowedInputVariables, targetVariable);
+        var problemData = (IClassificationProblemData)Problem.ProblemData;
+        var problemDataClone = new ClassificationProblemData(dataset, problemData.AllowedInputVariables, problemData.TargetVariable, problemData.ClassNames, problemData.PositiveClass);
         // set partitions of problem data clone correctly
         problemDataClone.TrainingPartition.Start = SamplesStart.Value; problemDataClone.TrainingPartition.End = SamplesEnd.Value;
@@ -809 +821 @@
     }
     #endregion
+
+    #region helper
+
+    private void SetEstimationLimits(IDataAnalysisProblem problem, Type[] types) {
+      foreach (var type in types) {
+        if (type.IsAssignableFrom(problem.GetType())) {
+          var originalLimits = (DoubleLimit)Problem.Parameters["EstimationLimits"].ActualValue;  // problem is a clone of Problem
+          var limits = (DoubleLimit)problem.Parameters["EstimationLimits"].ActualValue;
+          limits.Lower = originalLimits.Lower;
+          limits.Upper = originalLimits.Upper;
+        }
+      }
+    }
+
+    #endregion 
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs

@@ -22 +22 @@
 
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Algorithms.GradientDescent;
 using HeuristicLab.Common;
@@ -29 +30 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
+using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -57 +58 @@
 
     #region parameter properties
-    public IValueParameter<IMeanFunction> MeanFunctionParameter {
-      get { return (IValueParameter<IMeanFunction>)Parameters[MeanFunctionParameterName]; }
-    }
-    public IValueParameter<ICovarianceFunction> CovarianceFunctionParameter {
-      get { return (IValueParameter<ICovarianceFunction>)Parameters[CovarianceFunctionParameterName]; }
+    public IConstrainedValueParameter<IMeanFunction> MeanFunctionParameter {
+      get { return (IConstrainedValueParameter<IMeanFunction>)Parameters[MeanFunctionParameterName]; }
+    }
+    public IConstrainedValueParameter<ICovarianceFunction> CovarianceFunctionParameter {
+      get { return (IConstrainedValueParameter<ICovarianceFunction>)Parameters[CovarianceFunctionParameterName]; }
     }
     public IValueParameter<IntValue> MinimizationIterationsParameter {
@@ -106 +107 @@
       : base() {
       Problem = problem;
-      Parameters.Add(new ValueParameter<IMeanFunction>(MeanFunctionParameterName, "The mean function to use.", new MeanConst()));
-      Parameters.Add(new ValueParameter<ICovarianceFunction>(CovarianceFunctionParameterName, "The covariance function to use.", new CovarianceSquaredExponentialIso()));
+      Parameters.Add(new ConstrainedValueParameter<IMeanFunction>(MeanFunctionParameterName, "The mean function to use."));
+      Parameters.Add(new ConstrainedValueParameter<ICovarianceFunction>(CovarianceFunctionParameterName, "The covariance function to use."));
       Parameters.Add(new ValueParameter<IntValue>(MinimizationIterationsParameterName, "The number of iterations for likelihood optimization with LM-BFGS.", new IntValue(20)));
       Parameters.Add(new ValueParameter<IntValue>(SeedParameterName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
@@ -193 +194 @@
 
       solutionCreator.OperatorParameter.ActualName = SolutionCreatorParameterName;
+
+      foreach (var meanfunction in ApplicationManager.Manager.GetInstances<IMeanFunction>().OrderBy(s => s.ItemName))
+        MeanFunctionParameter.ValidValues.Add(meanfunction);
+
+      var defaultMeanFunction = MeanFunctionParameter.ValidValues.OfType<MeanConst>().FirstOrDefault();
+      if (defaultMeanFunction != null) {
+        MeanFunctionParameter.Value = defaultMeanFunction;
+      }
+
+      foreach (var covarianceFunction in ApplicationManager.Manager.GetInstances<ICovarianceFunction>().OrderBy(s => s.ItemName))
+        CovarianceFunctionParameter.ValidValues.Add(covarianceFunction);
+
+      var defaultCovarianceFunctionParameter = CovarianceFunctionParameter.ValidValues.OfType<CovarianceSquaredExponentialIso>().FirstOrDefault();
+      if (defaultCovarianceFunctionParameter != null) {
+        CovarianceFunctionParameter.Value = defaultCovarianceFunctionParameter;
+      }
     }
 

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs

@@ -281 +281 @@
             new AccuracyMaximizationThresholdCalculator());
           var classificationProblemData = new ClassificationProblemData(problemData.Dataset,
-            problemData.AllowedInputVariables, problemData.TargetVariable, problemData.Transformations);
+            problemData.AllowedInputVariables, problemData.TargetVariable, transformations: problemData.Transformations);
           classificationProblemData.TrainingPartition.Start = Problem.ProblemData.TrainingPartition.Start;
           classificationProblemData.TrainingPartition.End = Problem.ProblemData.TrainingPartition.End;

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModelSurrogate.cs

@@ -24 +24 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HEAL.Attic;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -38 +38 @@
     // don't store the actual model!
     // the actual model is only recalculated when necessary
+    private IGradientBoostedTreesModel fullModel;
     private readonly Lazy<IGradientBoostedTreesModel> actualModel;
     private IGradientBoostedTreesModel ActualModel {
@@ -48 +49 @@
     private readonly uint seed;
     [Storable]
-    private ILossFunction lossFunction;
+    private readonly ILossFunction lossFunction;
     [Storable]
-    private double r;
+    private readonly double r;
     [Storable]
-    private double m;
+    private readonly double m;
     [Storable]
-    private double nu;
+    private readonly double nu;
     [Storable]
-    private int iterations;
+    private readonly int iterations;
     [Storable]
-    private int maxSize;
+    private readonly int maxSize;
 
 
@@ -69 +70 @@
     [StorableConstructor]
     private GradientBoostedTreesModelSurrogate(StorableConstructorFlag _) : base(_) {
-      actualModel = new Lazy<IGradientBoostedTreesModel>(() => RecalculateModel());
+      actualModel = CreateLazyInitFunc();
     }
 
     private GradientBoostedTreesModelSurrogate(GradientBoostedTreesModelSurrogate original, Cloner cloner)
       : base(original, cloner) {
-      IGradientBoostedTreesModel clonedModel = null;
-      if (original.actualModel.IsValueCreated) clonedModel = cloner.Clone(original.ActualModel);
-      actualModel = new Lazy<IGradientBoostedTreesModel>(CreateLazyInitFunc(clonedModel)); // only capture clonedModel in the closure
-
+      // clone data which is necessary to rebuild the model
       this.trainingProblemData = cloner.Clone(original.trainingProblemData);
       this.lossFunction = cloner.Clone(original.lossFunction);
@@ -86 +84 @@
       this.m = original.m;
       this.nu = original.nu;
+
+      // clone full model if it has already been created
+      if (original.fullModel != null) this.fullModel = cloner.Clone(original.fullModel);
+      actualModel = CreateLazyInitFunc();
     }
 
-    private Func<IGradientBoostedTreesModel> CreateLazyInitFunc(IGradientBoostedTreesModel clonedModel) {
-      return () => {
-        return clonedModel ?? RecalculateModel();
-      };
+    private Lazy<IGradientBoostedTreesModel> CreateLazyInitFunc() {
+      return new Lazy<IGradientBoostedTreesModel>(() => {
+        if (fullModel == null) fullModel = RecalculateModel();
+        return fullModel;
+      });
     }
 
@@ -107 +110 @@
       this.nu = nu;
 
-      actualModel = new Lazy<IGradientBoostedTreesModel>(() => RecalculateModel());
+      actualModel = CreateLazyInitFunc();
     }
 
-    // wrap an actual model in a surrograte
+    // wrap an actual model in a surrogate
     public GradientBoostedTreesModelSurrogate(IGradientBoostedTreesModel model, IRegressionProblemData trainingProblemData, uint seed,
       ILossFunction lossFunction, int iterations, int maxSize, double r, double m, double nu)
       : this(trainingProblemData, seed, lossFunction, iterations, maxSize, r, m, nu) {
-      actualModel = new Lazy<IGradientBoostedTreesModel>(() => model);
+      fullModel = model;
     }
 
@@ -135 +138 @@
 
     public IEnumerable<IRegressionModel> Models {
-      get {
-        return ActualModel.Models;
-      }
+      get { return ActualModel.Models; }
     }
 
     public IEnumerable<double> Weights {
-      get {
-        return ActualModel.Weights;
-      }
+      get { return ActualModel.Weights; }
     }
   }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj

@@ -133 +133 @@
     <Compile Include="DoubleArrayExtensions.cs" />
     <Compile Include="FixedDataAnalysisAlgorithm.cs" />
+    <Compile Include="GAM\GeneralizedAdditiveModelAlgorithm.cs" />
+    <Compile Include="GAM\Spline1dModel.cs" />
     <Compile Include="GaussianProcess\CovarianceFunctions\CovarianceSpectralMixture.cs" />
     <Compile Include="GaussianProcess\CovarianceFunctions\CovariancePiecewisePolynomial.cs" />

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelSurrogate.cs

@@ -35 +35 @@
     #region parameters for recalculation of the model
     [Storable]
-    private int seed;
+    private readonly int seed;
     [Storable]
-    private IDataAnalysisProblemData originalTrainingData;
+    private readonly IDataAnalysisProblemData originalTrainingData;
     [Storable]
-    private double[] classValues;
+    private readonly double[] classValues;
     [Storable]
-    private int nTrees;
+    private readonly int nTrees;
     [Storable]
-    private double r;
+    private readonly double r;
     [Storable]
-    private double m;
+    private readonly double m;
     #endregion
+
 
     // don't store the actual model!
     // the actual model is only recalculated when necessary
+    private IRandomForestModel fullModel = null;
     private readonly Lazy<IRandomForestModel> actualModel;
+
     private IRandomForestModel ActualModel {
       get { return actualModel.Value; }
@@ -74 +77 @@
       this.m = m;
 
-      actualModel = new Lazy<IRandomForestModel>(() => RecalculateModel());
+      actualModel = CreateLazyInitFunc();
     }
 
-    // wrap an actual model in a surrograte
+    // wrap an actual model in a surrogate
     public RandomForestModelSurrogate(IRandomForestModel model, string targetVariable, IDataAnalysisProblemData originalTrainingData,
-      int seed, int nTrees, double r, double m, double[] classValues = null) : this(targetVariable, originalTrainingData, seed, nTrees, r, m, classValues) {
-      actualModel = new Lazy<IRandomForestModel>(() => model);
+      int seed, int nTrees, double r, double m, double[] classValues = null)
+      : this(targetVariable, originalTrainingData, seed, nTrees, r, m, classValues) {
+      fullModel = model;
     }
 
     [StorableConstructor]
     private RandomForestModelSurrogate(StorableConstructorFlag _) : base(_) {
-      actualModel = new Lazy<IRandomForestModel>(() => RecalculateModel());
+      actualModel = CreateLazyInitFunc();
     }
 
     private RandomForestModelSurrogate(RandomForestModelSurrogate original, Cloner cloner) : base(original, cloner) {
-      IRandomForestModel clonedModel = null;
-      if (original.actualModel.IsValueCreated) clonedModel = cloner.Clone(original.ActualModel);
-      actualModel = new Lazy<IRandomForestModel>(CreateLazyInitFunc(clonedModel)); // only capture clonedModel in the closure
-
       // clone data which is necessary to rebuild the model
       this.originalTrainingData = cloner.Clone(original.originalTrainingData);
@@ -100 +100 @@
       this.r = original.r;
       this.m = original.m;
-    }
 
-    private Func<IRandomForestModel> CreateLazyInitFunc(IRandomForestModel clonedModel) {
-      return () => {
-        return clonedModel ?? RecalculateModel();
-      };
+      // clone full model if it has already been created
+      if (original.fullModel != null) this.fullModel = cloner.Clone(original.fullModel);
+      actualModel = CreateLazyInitFunc();
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RandomForestModelSurrogate(this, cloner);
+    }
+
+    private Lazy<IRandomForestModel> CreateLazyInitFunc() {
+      return new Lazy<IRandomForestModel>(() => {
+        if (fullModel == null) fullModel = RecalculateModel();
+        return fullModel;
+      });
     }
 
@@ -128 +133 @@
       }
       return randomForestModel;
+    }
+
+    public override bool IsProblemDataCompatible(IDataAnalysisProblemData problemData, out string errorMessage) {
+      return ActualModel.IsProblemDataCompatible(problemData, out errorMessage);
     }