Changeset 17519 for branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters

Timestamp:

04/27/20 15:53:26 (4 years ago)

Author:

dpiringe

Message:

#3026:

• added error output for failed runner initialization
• reorganised some final view models
• TargetedJsonItemType (in JsonItemVMBase) now automatically returns the type of the defined JsonItem
• code cleanup
• refactored RegressionProblemDataConverter
• added lots of comments
• added new view for StringArrayJsonItem
• added new UI component for concrete restricted items and used it in JsonItemConcreteItemArrayControl and JsonItemValidValuesControl

Location:

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters

Files:

• RegressionProblemDataConverter.cs (modified) (2 diffs)
• ValueParameterConverter.cs (modified) (1 diff)

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/RegressionProblemDataConverter.cs

@@ -8 +8 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using Newtonsoft.Json.Linq;
 
 namespace HeuristicLab.JsonInterface {
   public class RegressionProblemDataConverter : BaseConverter {
+    #region Constants
     private const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+    private const string TestPartition = "TestPartition";
+    private const string TrainingPartition = "TrainingPartition";
+    private const string TargetVariable = "TargetVariable";
+    private const string AllowedInputVariables = "AllowedInputVariables";
+    private const string Dataset = "Dataset";
+    private const string VariableValues = "variableValues";
+    private const string VariableNames = "variableNames";
+    private const string InputVariables = "InputVariables";
+    private const string Rows = "rows";
+    private const string Value = "value";
+    private const string Parameters = "parameters";
+    private const string CheckedItemList = "CheckedItemList";
+    #endregion
+
     public override int Priority => 20;
+
+    // RegressionProblemData
     public override Type ConvertableType => HEAL.Attic.Mapper.StaticCache.GetType(new Guid("EE612297-B1AF-42D2-BF21-AF9A2D42791C"));
 
     public override void Inject(IItem item, IJsonItem data, IJsonItemConverter root) {
-      var dictTmp = new Dictionary<string, IList>();
-      DoubleMatrixJsonItem matrix = data.Children[0] as DoubleMatrixJsonItem;
-      if(matrix != null) {
-        int c = 0;
-        foreach(var col in matrix.RowNames) {
-          dictTmp.Add(col, new List<double>(matrix.Value[c]));
-          ++c;
-        }
-      }
-
-      dynamic val = (dynamic)item;
-      object dataset = (object)val.Dataset;
-      var rows = dataset.GetType().GetField("rows", flags);
-      rows.SetValue(dataset, matrix.Value[0].Length);
-
-      var variableNames = dataset.GetType().GetField("variableNames", flags);
-      variableNames.SetValue(dataset, matrix.RowNames);
-
-      var dataInfo = dataset.GetType().GetField("variableValues", flags);
-      dataInfo.SetValue(dataset, dictTmp);
-      val.TargetVariable = ((StringJsonItem)data.Children[3]).Value;
-      val.TrainingPartition.Start = ((IntRangeJsonItem)data.Children[2]).MinValue;
-      val.TrainingPartition.End = ((IntRangeJsonItem)data.Children[2]).MaxValue;
-      val.TestPartition.Start = ((IntRangeJsonItem)data.Children[1]).MinValue;
-      val.TestPartition.End = ((IntRangeJsonItem)data.Children[1]).MaxValue;
+
+      dynamic regressionProblemData = (dynamic)item;
+
+      DoubleMatrixJsonItem dataset = null;
+      StringJsonItem targetVariable = null;
+      IntRangeJsonItem testPartition = null;
+      IntRangeJsonItem trainingPartition = null;
+      StringArrayJsonItem allowedInputVariables = null;
+
+
+      // search first for the items (cache them, because the 
+      // order is important for injection)
+      foreach (var child in data.Children) {
+
+        if (child.Path.EndsWith(Dataset))
+          dataset = child as DoubleMatrixJsonItem;
+        else if (child.Path.EndsWith(TargetVariable))
+          targetVariable = child as StringJsonItem;
+        else if (child.Path.EndsWith(TestPartition))
+          testPartition = child as IntRangeJsonItem;
+        else if (child.Path.EndsWith(TrainingPartition))
+          trainingPartition = child as IntRangeJsonItem;
+        else if (child.Path.EndsWith(AllowedInputVariables))
+          allowedInputVariables = child as StringArrayJsonItem;
+
+      }
+
+      // check data
+      if(!dataset.RowNames.Any(x => x == targetVariable.Value)) {
+        throw new Exception($"The value of the target variable ('{targetVariable.Value}') has no matching row name value of the dataset.");
+      }
+
+      foreach(var v in allowedInputVariables.Value) {
+        if(!dataset.RowNames.Any(x => x == v))
+          throw new Exception($"The value of the input variable ('{v}') has no matching row name value of the dataset.");
+      }
+
+      // inject the value of the items
+      SetDataset(regressionProblemData, dataset);
+      SetTargetVariable(regressionProblemData, targetVariable);
+      SetAllowedInputVariables(regressionProblemData, allowedInputVariables, dataset);
+      SetTestPartition(regressionProblemData, testPartition);
+      SetTrainingPartition(regressionProblemData, trainingPartition);
+
     }
 
@@ -50 +87 @@
       };
 
-      dynamic val = (dynamic)value;
+      IJsonItem ds = GetDataset(value);
+      if(ds != null)
+        item.AddChildren(ds);
+
+      item.AddChildren(GetTestPartition(value));
+      item.AddChildren(GetTrainingPartition(value));
+      item.AddChildren(GetTargetVariable(value));
+      item.AddChildren(GetAllowedInputVariables(value));
+      return item;
+    }
+
+    #region Inject Helper
+    private void SetDataset(dynamic regressionProblemData, DoubleMatrixJsonItem item) {
+      if (item != null) {
+        var dictTmp = new Dictionary<string, IList>();
+        int c = 0;
+        foreach (var col in item.RowNames) {
+          dictTmp.Add(col, new List<double>(item.Value[c]));
+          ++c;
+        }
+
+        object dataset = (object)regressionProblemData.Dataset;
+        var rows = dataset.GetType().GetField(Rows, flags);
+        rows.SetValue(dataset, item.Value[0].Length);
+
+        var variableNames = dataset.GetType().GetField(VariableNames, flags);
+        variableNames.SetValue(dataset, item.RowNames);
+
+        var dataInfo = dataset.GetType().GetField(VariableValues, flags);
+        dataInfo.SetValue(dataset, dictTmp);
+      }
+    }
+
+    private void SetTestPartition(dynamic regressionProblemData, IntRangeJsonItem item) {
+      if (item != null) {
+        regressionProblemData.TestPartition.Start = item.MinValue;
+        regressionProblemData.TestPartition.End = item.MaxValue;
+      }
+    }
+
+    private void SetTrainingPartition(dynamic regressionProblemData, IntRangeJsonItem item) {
+      if (item != null) {
+        regressionProblemData.TrainingPartition.Start = item.MinValue;
+        regressionProblemData.TrainingPartition.End = item.MaxValue;
+      }
+    }
+
+    private void SetTargetVariable(dynamic regressionProblemData, StringJsonItem item) {
+      if (item != null) {
+        var param = (IConstrainedValueParameter<StringValue>)regressionProblemData.TargetVariableParameter;
+        StringValue v = param.Value;
+        FieldInfo fi = v.GetType().GetField(Value, flags);
+        fi.SetValue(v, item.Value);
+      }
+    }
+
+    private void SetAllowedInputVariables(dynamic regressionProblemData, StringArrayJsonItem item, IMatrixJsonItem matrix) {
+      if (item != null && regressionProblemData is IParameterizedItem p) {
+        var regProbDataType = ((ParameterizedNamedItem)regressionProblemData).GetType(); //RegressionProblemData
+
+        var parameterizedNamedItemType = regProbDataType.BaseType.BaseType;
+
+        // reset parameter
+        var parametersInfo = parameterizedNamedItemType.GetField(Parameters, flags);
+        ParameterCollection col = (ParameterCollection)parametersInfo.GetValue((object)regressionProblemData);
+        var oldParam = (FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>)col[InputVariables];
+        var value = oldParam.Value;
+        PropertyInfo listInfo = value.GetType().GetProperty(CheckedItemList, flags);
+        CheckedItemList<StringValue> checkedItemList = (CheckedItemList<StringValue>)listInfo.GetValue(value);
+        checkedItemList.Clear();
+
+        // add list items and set their check state (based on allowed input variables)
+        foreach(var i in matrix.RowNames) {
+          bool isChecked = false;
+          foreach(var x in item.Value)
+            isChecked = isChecked || (x == i);
+          checkedItemList.Add(new StringValue(i).AsReadOnly(), isChecked);
+        }
+      }
+    }
+    #endregion
+
+    #region Extract Helper
+    private IJsonItem GetDataset(IItem item) {
+      dynamic val = (dynamic)item;
       object dataset = (object)val.Dataset;
-      dynamic targetVariable = val.TargetVariable;
-      
-      FieldInfo dataInfo = dataset.GetType().GetField("variableValues", flags);
-      
-      if(dataInfo.GetValue(dataset) is Dictionary<string, IList> dict) {
-        int cols = dict.Count;
-        int rows = 0;
-        IList<string> rowNames = new List<string>();
-        double[][] mat = new double[cols][];
-        int c = 0;
-        foreach(var x in dict) {
-          rows = Math.Max(rows, x.Value.Count);
-          rowNames.Add(x.Key);
-          mat[c] = new double[rows];
-          int r = 0;
-          foreach(var rowValue in x.Value) {
-            // TODO: for integers and bools aswell
-            mat[c][r] = (double)rowValue; 
-            ++r;
+      FieldInfo dataInfo = dataset.GetType().GetField(VariableValues, flags);
+
+      if (dataInfo.GetValue(dataset) is Dictionary<string, IList> dict) {
+        IEnumerator it = dict.Values.First()?.GetEnumerator();
+
+        if(it != null) {
+          if(it.MoveNext() && it.Current is double) {
+            CreateMatrix(dict, out IList<string> rowNames, out double[][] mat);
+            return new DoubleMatrixJsonItem() {
+              Name = Dataset,
+              Value = mat,
+              RowNames = rowNames,
+              Minimum = double.MinValue,
+              Maximum = double.MaxValue
+            };
+          } else if(it.Current is int) {
+            CreateMatrix(dict, out IList<string> rowNames, out int[][] mat);
+            return new IntMatrixJsonItem() {
+              Name = Dataset,
+              Value = mat,
+              RowNames = rowNames,
+              Minimum = int.MinValue,
+              Maximum = int.MaxValue
+            };
+          } else if (it.Current is bool) {
+            CreateMatrix(dict, out IList<string> rowNames, out bool[][] mat);
+            return new BoolMatrixJsonItem() {
+              Name = Dataset,
+              Value = mat,
+              RowNames = rowNames
+            };
           }
-          ++c;
-        }
-        item.AddChildren(new DoubleMatrixJsonItem() {
-          Name = "Dataset",
-          Value = mat,
-          RowNames = rowNames,
-          Minimum = double.MinValue,
-          Maximum = double.MaxValue
-        });
-      }
-
-      var trainingPartition = ((IntRange)val.TrainingPartition);
-      var testPartition = ((IntRange)val.TestPartition);
-
-      item.AddChildren(new IntRangeJsonItem() {
-        Name = "TestPartition",
-        MinValue = testPartition.Start, 
+        }
+      }
+      return null;
+    }
+    
+    private void CreateMatrix<T>(Dictionary<string, IList> dict, out IList<string> rowNames, out T[][] matrix) {
+      int cols = dict.Count, rows = 0, c = 0;
+      rowNames = new List<string>();
+      matrix = new T[cols][];
+      foreach (var x in dict) {
+        rows = Math.Max(rows, x.Value.Count);
+        rowNames.Add(x.Key);
+
+        matrix[c] = new T[rows];
+        int r = 0;
+
+        foreach (var rowValue in x.Value) {
+          matrix[c][r] = (T)rowValue;
+          ++r;
+        }
+        ++c;
+      }
+    }
+
+    private IJsonItem GetTestPartition(IItem item) {
+      dynamic val = (dynamic)item;
+      var trainingPartition = (IntRange)val.TrainingPartition;
+      var testPartition = (IntRange)val.TestPartition;
+      return new IntRangeJsonItem() {
+        Name = TestPartition,
+        MinValue = testPartition.Start,
         MaxValue = testPartition.End,
-        Minimum = 0, 
+        Minimum = 0,
         Maximum = Math.Max(testPartition.End, trainingPartition.End)
-      });
-
-      
-      item.AddChildren(new IntRangeJsonItem() {
-        Name = "TrainingPartition",
+      };
+    }
+
+    private IJsonItem GetTrainingPartition(IItem item) {
+      dynamic val = (dynamic)item;
+      var trainingPartition = (IntRange)val.TrainingPartition;
+      var testPartition = (IntRange)val.TestPartition;
+      return new IntRangeJsonItem() {
+        Name = TrainingPartition,
         MinValue = trainingPartition.Start,
         MaxValue = trainingPartition.End,
         Minimum = 0,
         Maximum = Math.Max(testPartition.End, trainingPartition.End)
-      });
-
-      IEnumerable<StringValue> variables = (IEnumerable<StringValue>)val.InputVariables;
-      item.AddChildren(new StringJsonItem() {
-        Name = "TargetVariable",
-        Value = (string)targetVariable,
-        ConcreteRestrictedItems = variables.Select(x => x.Value)
-      });
-
-      /*
-      item.AddChildren(new StringArrayJsonItem() {
-        Name = "AllowedInputVariables",
-        Value = (string[])val.AllowedInputVariables,
-        Range = variables.Select(x => x.Value)
-      });*/
-      return item;
-    }
+      };
+    }
+      
+
+    private IJsonItem GetTargetVariable(IItem item) =>
+      new StringJsonItem() {
+        Name = TargetVariable,
+        Value = (string)((dynamic)item).TargetVariable,
+        //ConcreteRestrictedItems = variables.Select(x => x.Value)
+      };
+
+    private IJsonItem GetAllowedInputVariables(IItem item) =>
+      new StringArrayJsonItem() {
+        Name = AllowedInputVariables,
+        Value = ((IEnumerable<string>)((dynamic)item).AllowedInputVariables).ToArray(),
+        //ConcreteRestrictedItems = variables.Select(x => x.Value)
+      };
+    #endregion
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueParameterConverter.cs

@@ -18 +18 @@
 
       if(parameter.ActualValue != null) {
-          if (data.Children == null || data.Children.Count == 0)
+          if (data.Children == null || data.Children.Count() == 0)
             root.Inject(parameter.ActualValue, data, root);
           else