Free cookie consent management tool by TermsFeed Policy Generator

source: branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCGenerator.cs @ 17263

Last change on this file since 17263 was 17263, checked in by dpiringe, 5 years ago

#3026:

  • added first prototype for:
    • creating templates
    • initialize a optimizer out of a template
  • first attempts to create the option to extend the template generation and initialisation (with Transformers -> json To IItem, IItem to json) without serializing/deserializing the whole IItem
File size: 13.4 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.IO;
4using System.Linq;
5using HeuristicLab.Algorithms.GeneticAlgorithm;
6using HeuristicLab.Core;
7using HeuristicLab.Data;
8using HeuristicLab.Encodings.PermutationEncoding;
9using HeuristicLab.Optimization;
10using HeuristicLab.Problems.TravelingSalesman;
11using Newtonsoft.Json;
12using Newtonsoft.Json.Linq;
13
14namespace ParameterTest {
15  public class JCGenerator {
16
17    private JObject template = JObject.Parse(@"{
18      'Metadata': {},
19      'FreeParameters': {},
20      'StaticParameters': {
21        'Algorithm':{},
22        'Problem':{},
23        'TypeList':{}
24      }
25    }");
26
27   
28    private Dictionary<string, string> TypeList = new Dictionary<string, string>();
29
30    public string GenerateTemplate(IAlgorithm algorithm, IProblem problem) {
31      algorithm.Problem = problem;
32      foreach(var x in BJCO(algorithm)) {
33        Console.WriteLine(x.ToString());
34      }
35      /*
36      JCObject algorithmData = BuildJCObject(algorithm);
37      JCObject problemData = BuildJCObject(problem);
38
39      ProcessStaticParameters(algorithmData, problemData);
40      ProcessFreeParameters(algorithmData, problemData);
41      ProcessTypeList();
42
43      return template.ToString(Formatting.Indented);
44      */
45      return "";
46    }
47
48    #region Helper
49    private JCObject BuildJCObject(IItem item) {
50      JCObject obj = new JCObject();
51      obj.Name = item.ItemName;
52      obj.Parameters = BuildJCParameter(item).Parameters;
53      return obj;
54    }
55
56    private IList<JCObject> BJCO(IParameterizedItem item) {
57      List<JCObject> list = new List<JCObject>();
58      JCObject obj = new JCObject();
59      obj.Name = item.ItemName;
60      obj.StaticParameters = new List<ParameterData>();
61      obj.FreeParameters = new List<ParameterData>();
62
63      list.Add(obj);
64
65      foreach (var param in item.Parameters) {
66        if(!param.Hidden) {
67          ParameterData newParam = new ParameterData();
68          newParam.Name = param.Name;
69          if (!Util.IsTypeOf(param, typeof(ILookupParameter<>))) {
70            if (param.ActualValue is IntValue) {
71              SetParameterValueStats(newParam, ((IntValue)param.ActualValue).Value, 0, int.MaxValue);
72            } else if (param.ActualValue is BoolValue) {
73              SetParameterValueStats(newParam, ((BoolValue)param.ActualValue).Value, false, true);
74            } else if (param.ActualValue is PercentValue) {
75              SetParameterValueStats(newParam, ((PercentValue)param.ActualValue).Value, 0d, 1d);
76            } else if (param.ActualValue is DoubleValue) {
77              SetParameterValueStats(newParam, ((DoubleValue)param.ActualValue).Value, 0d, double.MaxValue);
78            } else if (Util.IsTypeOf(param.ActualValue, typeof(EnumValue<>))) {
79              var enumType = ((dynamic)param.ActualValue).Value.GetType();
80              SetParameterValueStats(newParam,
81                Enum.GetName(enumType, ((dynamic)param.ActualValue).Value),
82                Enum.GetNames(enumType));
83            } else if (param.ActualValue is StringValue) {
84              SetParameterValueStats(newParam, ((StringValue)param.ActualValue).Value);
85            } else if (Util.IsTypeOf(param.ActualValue, typeof(ValueTypeMatrix<>))) {
86              SetParameterValueStats(newParam, ((dynamic)param.ActualValue).CloneAsMatrix());
87            } else if (Util.IsTypeOf(param.ActualValue, typeof(ValueTypeArray<>))) {
88              SetParameterValueStats(newParam, ((dynamic)param.ActualValue).CloneAsArray());
89            } else {
90              AddType(param.ActualValue);
91              //newParam.Path = newParam.Path.Substring(0, newParam.Path.Length - 6);
92              SetParameterValueStats(newParam, param.ActualValue?.GetType().Name, ExtractPossibleValues(item, param.DataType));
93            }
94          }
95
96
97          obj.StaticParameters.Add(newParam);
98
99          if (param is IParameterizedItem) {
100            list.AddRange(BJCO((IParameterizedItem)param));
101          }
102          if (Util.IsTypeOf(param, typeof(IConstrainedValueParameter<>))) {
103            foreach (var validValue in ((dynamic)param).ValidValues) {
104              if (newParam.Range == null) newParam.Range = new List<object>();
105              object v = (object)validValue;
106              try {
107                if (!newParam.Range.Contains(v))
108                  newParam.Range.Add(v);
109              } catch { }
110              if (validValue is IParameterizedItem) {
111                list.AddRange(BJCO((IParameterizedItem)validValue));
112              }
113            }
114          }
115        }
116      }
117      return list;
118    }
119
120
121
122    private IEnumerable<IParameterizedItem> GetIParameterItems(IParameterizedItem item) {
123      List<IParameterizedItem> items = new List<IParameterizedItem>();
124      items.Add(item);
125      foreach(var param in item.Parameters) {
126        if(param is IParameterizedItem) {
127          items.AddRange(GetIParameterItems((IParameterizedItem)param));
128        }
129        if(Util.IsTypeOf(param, typeof(IConstrainedValueParameter<>))){
130          foreach(var validValue in ((dynamic)param).ValidValues) {
131            if(validValue is IParameterizedItem) {
132              items.AddRange(GetIParameterItems((IParameterizedItem)validValue));
133            }
134          }
135        }
136      }
137      return items;
138    }
139
140    private JsonSerializer Settings() => new JsonSerializer() {
141      TypeNameHandling = TypeNameHandling.None,
142      NullValueHandling = NullValueHandling.Ignore
143    };
144
145    private void ProcessFreeParameters(JCObject algorithmData, JCObject problemData) {
146      JObject freeParams = new JObject();
147      JToken alg = JToken.FromObject(algorithmData.Parameters, Settings());
148      JToken prob = JToken.FromObject(problemData.Parameters, Settings());
149     
150      IList<JObject> objToRemove = new List<JObject>();
151      TransformNodes(x => {
152        var p = x.ToObject<ParameterData>();
153        if (p.Default == null || (p.Default != null && p.Default.GetType() == typeof(string) && p.Range == null)) {
154          objToRemove.Add(x);
155        } else {
156          x.Property("Path")?.Remove();
157          x.Property("Type")?.Remove();
158        }
159      },alg, prob);
160      foreach (var x in objToRemove) x.Remove();
161
162      freeParams.Add(algorithmData.Name, alg);
163      freeParams.Add(problemData.Name, prob);
164      template["FreeParameters"] = freeParams;
165    }
166
167    private void ProcessStaticParameters(JCObject algorithmData, JCObject problemData) {
168      template["StaticParameters"]["Algorithm"] = JObject.FromObject(algorithmData, Settings());
169      template["StaticParameters"]["Problem"] = JObject.FromObject(problemData, Settings());
170      TransformNodes(x => x.Property("Range")?.Remove(),
171        template["StaticParameters"]["Algorithm"]["Parameters"],
172        template["StaticParameters"]["Problem"]["Parameters"]);
173    }
174
175    private void ProcessTypeList() {
176      template["StaticParameters"]["TypeList"] = JObject.FromObject(TypeList);
177    }
178
179    private void TransformNodes(Action<JObject> action, params JToken[] tokens) {
180      foreach(JObject obj in tokens.SelectMany(x => x.Children<JObject>())) {
181        action(obj);
182      }
183    }
184    #endregion
185
186   
187    private ParameterData BuildJCParameter(IItem item, string startPath = "") {
188      ParameterData obj = new ParameterData();
189      obj.Name = item.ItemName;
190      obj.Path = startPath;
191
192      AddType(item, obj.Name);
193
194      try {
195        ExtractParameterInfo(item, obj);
196      } catch { }
197      ExtractOperatorInfo(item, obj);
198      return obj;
199    }
200
201    private bool ProcessValueTypeParameters(ParameterData jCParameter, IParameter parameter) {
202      if (parameter.ActualValue is IntValue)
203        SetParameterValueStats(jCParameter,
204          ((IntValue)parameter.ActualValue).Value,
205          0, int.MaxValue);
206      else if (parameter.ActualValue is BoolValue)
207        SetParameterValueStats(jCParameter,
208          ((BoolValue)parameter.ActualValue).Value,
209          false, true);
210      else if (parameter.ActualValue is PercentValue)
211        SetParameterValueStats(jCParameter,
212          ((PercentValue)parameter.ActualValue).Value,
213          0d, 1d);
214      else if (parameter.ActualValue is DoubleValue)
215        SetParameterValueStats(jCParameter,
216          ((DoubleValue)parameter.ActualValue).Value,
217          0d, double.MaxValue);
218      else return false;
219      return true;
220    }
221
222    private bool ProcessEnumTypeParameters(ParameterData jCParameter, IParameter parameter) {
223      if (Util.IsTypeOf(parameter.ActualValue, typeof(EnumValue<>))) {
224        var enumType = ((dynamic)parameter.ActualValue).Value.GetType();
225        SetParameterValueStats(jCParameter,
226          Enum.GetName(enumType, ((dynamic)parameter.ActualValue).Value),
227          Enum.GetNames(enumType));
228      } else return false;
229      return true;
230    }
231
232    private bool ProcessMatrixTypeParameters(ParameterData jCParameter, IParameter parameter) {
233      if (Util.IsTypeOf(parameter.ActualValue, typeof(ValueTypeMatrix<>))) {
234        SetParameterValueStats(jCParameter, ((dynamic)parameter.ActualValue).CloneAsMatrix());
235      } else return false;
236      return true;
237    }
238
239    private bool ProcessArrayTypeParameters(ParameterData jCParameter, IParameter parameter) {
240      if (Util.IsTypeOf(parameter.ActualValue, typeof(ValueTypeArray<>))) {
241        SetParameterValueStats(jCParameter, ((dynamic)parameter.ActualValue).CloneAsArray());
242      } else return false;
243      return true;
244    }
245
246    private void SetParameterValueStats(ParameterData parameter, object value, params object[] range) {
247      parameter.Default = value;
248      parameter.Range = range.Length == 0 ? null : range;
249    }
250
251   
252    private void ExtractParameterInfo(IItem item, ParameterData obj) {
253      if (item is IParameterizedItem) {
254        foreach (var param in ((IParameterizedItem)item).Parameters) {
255          if (!param.Hidden) {
256
257            ParameterData newParam = BuildJCParameter(param);
258            newParam.Name = param.Name;
259            var tmpType = param.GetType();
260            newParam.Path = (obj.Path != "" ? obj.Path + "." : "") + param.Name + ".Value.Value";
261
262            if (obj.Parameters == null)
263              obj.Parameters = new List<ParameterData>();
264            obj.Parameters.Add(newParam);
265
266
267            if (param.ActualValue is IntValue) {
268              SetParameterValueStats(newParam, ((IntValue)param.ActualValue).Value, 0, int.MaxValue);
269            } else if (param.ActualValue is BoolValue) {
270              SetParameterValueStats(newParam, ((BoolValue)param.ActualValue).Value, false, true);
271            } else if (param.ActualValue is PercentValue) {
272              SetParameterValueStats(newParam, ((PercentValue)param.ActualValue).Value, 0d, 1d);
273            } else if (param.ActualValue is DoubleValue) {
274              SetParameterValueStats(newParam, ((DoubleValue)param.ActualValue).Value, 0d, double.MaxValue);
275            } else if (Util.IsTypeOf(param.ActualValue, typeof(EnumValue<>))) {
276              var enumType = ((dynamic)param.ActualValue).Value.GetType();
277              SetParameterValueStats(newParam,
278                Enum.GetName(enumType, ((dynamic)param.ActualValue).Value),
279                Enum.GetNames(enumType));
280            } else if (param.ActualValue is StringValue) {
281              SetParameterValueStats(newParam, ((StringValue)param.ActualValue).Value);
282            } else if (Util.IsTypeOf(param.ActualValue, typeof(ValueTypeMatrix<>))) {
283              SetParameterValueStats(newParam, ((dynamic)param.ActualValue).CloneAsMatrix());
284            } else if (Util.IsTypeOf(param.ActualValue, typeof(ValueTypeArray<>))) {
285              SetParameterValueStats(newParam, ((dynamic)param.ActualValue).CloneAsArray());
286            } else {
287              AddType(param.ActualValue);
288              newParam.Path = newParam.Path.Substring(0, newParam.Path.Length - 6);
289              SetParameterValueStats(newParam, param.ActualValue?.GetType().Name, ExtractPossibleValues(item, param.DataType));
290            }
291          }
292        }
293      }
294    }
295
296    private object[] ExtractPossibleValues(IItem item, Type paramType) {
297      IList<object> list = new List<object>();
298      if (item is Algorithm) {
299        IEnumerable<IItem> items = ((Algorithm)item).Problem.Operators.Where(x => paramType.IsAssignableFrom(x.GetType()));
300        foreach (var op in items) {
301          string name = op.GetType().Name;
302          list.Add(name);
303          AddType(op, name);
304        }
305      }
306      return list.ToArray();
307    }
308
309    private void AddType(object obj, string key = null) {
310      if (obj != null) {
311        if (key == null) key = obj.GetType().Name;
312        try {
313          if (!TypeList.ContainsKey(key))
314            TypeList.Add(key, obj.GetType().AssemblyQualifiedName);
315        } catch { }
316      }
317    }
318
319    private void ExtractOperatorInfo(IItem item, ParameterData obj) {
320      if (item is IMultiOperator) {
321        foreach (var op in ((IMultiOperator)item).Operators) {
322          ParameterData newOperator = BuildJCParameter(op);
323          if (obj.Operators == null)
324            obj.Operators = new List<ParameterData>();
325          obj.Operators.Add(newOperator);
326          newOperator.Name = op.GetType().Name;
327
328          newOperator.Path = obj.Path + ".Operators." + op.Name;
329          MultiPermutationManipulator manipulator = new MultiPermutationManipulator();
330        }
331      }
332    }
333  }
334}
Note: See TracBrowser for help on using the repository browser.