Changeset 17918 for branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4

Timestamp:

03/29/21 09:54:58 (3 years ago)

Author:

mkommend

Message:

#3105: Merge trunk changes into branch.

Location:

branches/3105_PythonFormatter

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4 (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs (modified) (5 diffs, 1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraintsParser.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraintsParser.cs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/ShapeConstraints.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/ShapeConstraints.cs)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs (modified) (3 diffs)

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs

@@ -96 +96 @@
     }
 
+    public static IntervalCollection GetIntervals(this IDataset dataset) {
+      IntervalCollection intervalCollection = new IntervalCollection();
+      foreach (var variable in dataset.DoubleVariables) { // intervals are only possible for double variables
+        var variableInterval = Interval.GetInterval(dataset.GetDoubleValues(variable));
+        intervalCollection.AddInterval(variable, variableInterval);
+      }
+
+      return intervalCollection;
+    }
+
     public static IEnumerable<KeyValuePair<string, IEnumerable<string>>> GetFactorVariableValues(
       this IDataset ds, IEnumerable<string> factorVariables, IEnumerable<int> rows) {

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

@@ -142 +142 @@
     <Compile Include="Implementation\Interval\Interval.cs" />
     <Compile Include="Implementation\Interval\IntervalCollection.cs" />
+    <Compile Include="Implementation\Interval\ShapeConstraint.cs" />
+    <Compile Include="Implementation\Interval\ShapeConstraintsParser.cs" />
     <Compile Include="Implementation\Regression\ConfidenceBoundRegressionSolution.cs" />
     <Compile Include="Implementation\Regression\ConstantRegressionModel.cs" />
     <Compile Include="Implementation\Regression\ConstantRegressionSolution.cs" />
+    <Compile Include="Implementation\Regression\ShapeConstraints.cs" />
     <Compile Include="Implementation\Regression\RegressionEnsembleProblemData.cs" />
     <Compile Include="Implementation\Regression\RegressionEnsembleModel.cs">

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs

@@ -306 +306 @@
         classNamesCache.Add(ClassNamesParameter.Value[i, 0]);
     }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       if (this == emptyProblemData) return emptyProblemData;
@@ -314 +315 @@
 
     public ClassificationProblemData(IClassificationProblemData classificationProblemData)
-      : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable, classificationProblemData.ClassNames, classificationProblemData.PositiveClass) {
-      
+      : this(classificationProblemData, classificationProblemData.Dataset) {
+    }
+
+    /// <summary>
+    /// This method satisfies a common use case: making a copy of the problem but providing a different dataset.
+    /// One must be careful here that the dataset passed is not modified, as that would invalidate the problem data internals.
+    /// Passing a ModifiableDataset to this constructor is therefore discouraged.
+    /// </summary>
+    /// <param name="classificationProblemData">The original instance of classification problem data.</param>
+    /// <param name="dataset">The new dataset.</param>
+    public ClassificationProblemData(IClassificationProblemData classificationProblemData, IDataset dataset)
+    : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable, classificationProblemData.ClassNames, classificationProblemData.PositiveClass) {
+
       TrainingPartition.Start = classificationProblemData.TrainingPartition.Start;
       TrainingPartition.End = classificationProblemData.TrainingPartition.End;
       TestPartition.Start = classificationProblemData.TestPartition.Start;
       TestPartition.End = classificationProblemData.TestPartition.End;
-      
+
       for (int i = 0; i < Classes; i++) {
         for (int j = 0; j < Classes; j++) {
@@ -328 +340 @@
     }
 
-    public ClassificationProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
-      : this(dataset, allowedInputVariables, targetVariable, Enumerable.Empty<string>(), null, transformations) { }
-
     public ClassificationProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable,
-      IEnumerable<string> classNames,
+      IEnumerable<string> classNames = null,
       string positiveClass = null, // can be null in which case it's set as the first class name
       IEnumerable<ITransformation> transformations = null)
@@ -348 +357 @@
 
       // set the class names
-      if (classNames.Any()) {
+      if (classNames != null && classNames.Any()) {
         // better to allocate lists because we use these multiple times below
         var names = classNames.ToList();
-        var values = ClassValues.ToList();
+        var values = ClassValuesCache;
 
         if (names.Count != values.Count) {

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs

@@ -33 +33 @@
     [Storable]
     public double UpperBound { get; private set; }
+
+    public double Width => UpperBound - LowerBound;
 
     [StorableConstructor]
@@ -67 +69 @@
     }
 
+    private Interval(double v) : this(v, v) { }
+
     public bool Contains(double value) {
       return LowerBound <= value && value <= UpperBound;
@@ -126 +130 @@
         return false;
 
-      return (UpperBound.IsAlmost(other.UpperBound) || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
-        && (LowerBound.IsAlmost(other.LowerBound) || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
+      return (UpperBound==other.UpperBound || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
+        && (LowerBound==other.LowerBound || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
     }
 
@@ -267 +271 @@
     }
 
-    public static Interval AnalyticalQuotient(Interval a, Interval b) {
+    public static Interval AnalyticQuotient(Interval a, Interval b) {
       var dividend = a;
       var divisor = Add(Square(b), new Interval(1.0, 1.0));
@@ -276 +280 @@
     }
     #endregion
+
+    #region arithmetic overloads
+    public static Interval operator +(Interval a, Interval b) => Add(a, b);
+    public static Interval operator +(Interval a, double b) => Add(a, new Interval(b));
+    public static Interval operator +(double a, Interval b) => Add(new Interval(a), b);
+    public static Interval operator -(Interval a, Interval b) => Subtract(a, b);
+    public static Interval operator -(Interval a, double b) => Subtract(a, new Interval(b));
+    public static Interval operator -(double a, Interval b) => Subtract(new Interval(a), b);
+    public static Interval operator -(Interval a) => Subtract(new Interval(0), a);
+    public static Interval operator *(Interval a, Interval b) => Multiply(a, b);
+    public static Interval operator *(Interval a, double b) => Multiply(a, new Interval(b));
+    public static Interval operator *(double a, Interval b) => Multiply(new Interval(a), b);
+    public static Interval operator /(Interval a, Interval b) => Divide(a, b);
+    public static Interval operator /(Interval a, double b) => Divide(a, new Interval(b));
+    public static Interval operator /(double a, Interval b) => Divide(new Interval(a), b);
+    public static Interval Exponential(double a) { return Exponential(new Interval(a)); }
+    public static Interval Logarithm(double a) { return Logarithm(new Interval(a)); }
+    public static Interval Sine(double a) { return Sine(new Interval(a)); }
+    public static Interval Cosine(double a) { return Cosine(new Interval(a)); }
+    public static Interval Tangens(double a) { return Tangens(new Interval(a)); }
+    public static Interval HyperbolicTangent(double a) { return HyperbolicTangent(new Interval(a)); }
+    public static Interval Square(double a) { return Square(new Interval(a)); }
+    public static Interval Cube(double a) { return Cube(new Interval(a)); }
+    public static Interval SquareRoot(double a) { return SquareRoot(new Interval(a)); }
+    public static Interval CubicRoot(double a) { return CubicRoot(new Interval(a)); }
+    public static Interval Absolute(double a) { return Absolute(new Interval(a)); }
+    public static Interval AnalyticQuotient(Interval a, double b) { return AnalyticQuotient(a, new Interval(b)); }
+    public static Interval AnalyticQuotient(double a, Interval b) { return AnalyticQuotient(new Interval(a), b); }
+    public static Interval AnalyticQuotient(double a, double b) { return AnalyticQuotient(new Interval(a), new Interval(b)); }
+    #endregion
   }
 }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -34 +34 @@
       get => HeuristicLab.Common.Resources.VSImageLibrary.Object;
     }
-    private IDictionary<string, Interval> intervals { get; } = new Dictionary<string, Interval>();
 
-    [Storable(Name = "StorableIntervalInformation")]
+    private IDictionary<string, Interval> intervals { get; set; } = new Dictionary<string, Interval>();
+
+    [Storable(OldName = "StorableIntervalInformation")]
     private KeyValuePair<string, double[]>[] StorableIntervalInformation {
+      set {
+        foreach (var varInt in value)
+          intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
+      }
+    }
+
+    [Storable]
+    private object[] StorableIntervals {
       get {
-        var l = new List<KeyValuePair<string, double[]>>();
-        foreach (var varInt in intervals)
+        var names = intervals.Keys.ToArray();
+        var lowerBounds = intervals.Values.Select(i => i.LowerBound).ToArray();
+        var upperBounds = intervals.Values.Select(i => i.UpperBound).ToArray();
 
-          l.Add(new KeyValuePair<string, double[]>(varInt.Key,
-            new double[] { varInt.Value.LowerBound, varInt.Value.UpperBound }));
-        return l.ToArray();
+        return new object[] { names, lowerBounds, upperBounds };
       }
 
       set {
-        foreach (var varInt in value)
-          intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
+        var names = (string[])value[0];
+        var lowerBounds = (double[])value[1];
+        var upperBounds = (double[])value[2];
+
+        for (int i = 0; i < names.Length; i++) {
+          intervals.Add(names[i], new Interval(lowerBounds[i], upperBounds[i]));
+        }
       }
     }
@@ -80 +93 @@
     public void SetInterval(string identifier, Interval interval) {
       intervals[identifier] = interval;
+      RaiseChanged();
     }
 
     public void AddInterval(string identifier, Interval interval) {
       intervals.Add(identifier, interval);
+      RaiseChanged();
     }
 
     public void DeleteInterval(string identifier) {
       intervals.Remove(identifier);
+      RaiseChanged();
     }
 
     public IReadOnlyDictionary<string, Interval> GetReadonlyDictionary() {
+      return intervals.ToDictionary(pair => pair.Key, pair => pair.Value);
+    }
+
+    public IDictionary<string, Interval> GetDictionary() {
       return intervals.ToDictionary(pair => pair.Key, pair => pair.Value);
     }
@@ -98 +118 @@
         yield return Tuple.Create(variableInterval.Key, variableInterval.Value);
     }
+
+    public event EventHandler Changed;
+    private void RaiseChanged() {
+      var handler = Changed;
+      if (handler != null)
+        handler(this, EventArgs.Empty);
+    }
+
   }
 }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

@@ -35 +35 @@
     protected const string TargetVariableParameterName = "TargetVariable";
     protected const string VariableRangesParameterName = "VariableRanges";
-    protected const string IntervalConstraintsParameterName = "IntervalConstraints";
+    protected const string ShapeConstraintsParameterName = "ShapeConstraints";
     public string Filename { get; set; }
 
@@ -94 +94 @@
       problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
       problemData.Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, "", new IntervalCollection()));
+      problemData.Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, "", new ShapeConstraints()));
       emptyProblemData = problemData;
     }
     #endregion
 
-    public IConstrainedValueParameter<StringValue> TargetVariableParameter {
-      get { return (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
-    }
-
+    #region parameter properties
+    public IConstrainedValueParameter<StringValue> TargetVariableParameter => (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName];
+    public IFixedValueParameter<ShapeConstraints> ShapeConstraintsParameter => (IFixedValueParameter<ShapeConstraints>)Parameters[ShapeConstraintsParameterName];
     public IFixedValueParameter<IntervalCollection> VariableRangesParameter => (IFixedValueParameter<IntervalCollection>)Parameters[VariableRangesParameterName];
-
+    #endregion
+
+    #region properties
     public IntervalCollection VariableRanges {
       get => VariableRangesParameter.Value;
     }
+
+
+    public ShapeConstraints ShapeConstraints => ShapeConstraintsParameter.Value;
 
 
@@ -120 +125 @@
       }
     }
-
-    public IEnumerable<double> TargetVariableValues {
-      get { return Dataset.GetDoubleValues(TargetVariable); }
-    }
-    public IEnumerable<double> TargetVariableTrainingValues {
-      get { return Dataset.GetDoubleValues(TargetVariable, TrainingIndices); }
-    }
-    public IEnumerable<double> TargetVariableTestValues {
-      get { return Dataset.GetDoubleValues(TargetVariable, TestIndices); }
-    }
+    public IEnumerable<double> TargetVariableValues => Dataset.GetDoubleValues(TargetVariable);
+    public IEnumerable<double> TargetVariableTrainingValues => Dataset.GetDoubleValues(TargetVariable, TrainingIndices);
+    public IEnumerable<double> TargetVariableTestValues => Dataset.GetDoubleValues(TargetVariable, TestIndices);
+    #endregion
+
 
 
@@ -137 +137 @@
     private void AfterDeserialization() {
       if (!Parameters.ContainsKey(VariableRangesParameterName)) {
-        var intervalCollection = CalculateDatasetIntervals(this.Dataset);
+        var intervalCollection = Dataset.GetIntervals();
         Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
       }
+      if (Parameters.ContainsKey("IntervalConstraints")) {
+        var param = (IFixedValueParameter<ShapeConstraints>)Parameters["IntervalConstraints"];
+        Parameters.Remove(param);
+        Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, param.Value));
+      }
+      if (!Parameters.ContainsKey(ShapeConstraintsParameterName)) {
+        Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, new ShapeConstraints()));
+      }
+
       RegisterParameterEvents();
     }
@@ -163 +172 @@
     }
 
-    public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
+    public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable,
+      IEnumerable<ITransformation> transformations = null,
+      IntervalCollection variableRanges = null,
+      ShapeConstraints shapeConstraints = null)
       : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
-      var intervalCollection = CalculateDatasetIntervals(this.Dataset);
-      Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
+      if (variableRanges == null) {
+        variableRanges = Dataset.GetIntervals();
+      }
+      Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, variableRanges));
+
+      if (shapeConstraints == null) {
+        shapeConstraints = new ShapeConstraints();
+      }
+      Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, shapeConstraints));
       RegisterParameterEvents();
     }
-
-    private static IntervalCollection CalculateDatasetIntervals(IDataset dataset) {
-      IntervalCollection intervalCollection = new IntervalCollection();
-      foreach (var variable in dataset.DoubleVariables) {// intervals are only possible for double variables
-        var variableInterval = Interval.GetInterval(dataset.GetDoubleValues(variable));
-        intervalCollection.AddInterval(variable, variableInterval);
-      }
-
-      return intervalCollection;
-    }
-
     private void RegisterParameterEvents() {
-      TargetVariableParameter.ValueChanged += new EventHandler(TargetVariableParameter_ValueChanged);
-    }
-    private void TargetVariableParameter_ValueChanged(object sender, EventArgs e) {
+      TargetVariableParameter.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      // VariableRanges and ShapeConstraints are fixed parameters
+    }
+    private void Parameter_ValueChanged(object sender, EventArgs e) {
       OnChanged();
     }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs

@@ -1 +1 @@
 #region License Information
+
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18 +19 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #endregion
 
@@ -28 +30 @@
     string TargetVariable { get; set; }
 
-    IntervalCollection VariableRanges { get;}
+    IntervalCollection VariableRanges { get; }
+    ShapeConstraints ShapeConstraints { get; }
 
     IEnumerable<double> TargetVariableValues { get; }