Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs @ 5087

Last change on this file since 5087 was 5087, checked in by cneumuel, 13 years ago

#1215

  • enabled multiple problems
  • enabled n repetitions
  • improved results output
  • reduced memory footprint significantly
  • removed viewhost icons for less screen space waste
File size: 12.0 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using HeuristicLab.Common;
5using HeuristicLab.Core;
6using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
7using HeuristicLab.PluginInfrastructure;
8using HeuristicLab.Parameters;
9using HeuristicLab.Data;
10using System.Collections;
11
12namespace HeuristicLab.Problems.MetaOptimization {
13  [StorableClass]
14  public class ParameterConfiguration : Item, IParameterConfiguration, IStorableContent {
15    public bool IsOptimizable {
16      get { return true; }
17    }
18
19    [Storable]
20    public string Filename { get; set; }
21
22    [Storable]
23    protected bool optimize;
24    public bool Optimize {
25      get { return optimize; }
26      set {
27        if (optimize != value) {
28          optimize = value;
29          if (optimize) {
30            PopulateValueConfigurations();
31          } else {
32            this.ValueConfigurations.Clear();
33          }
34          OnOptimizeChanged();
35          OnToStringChanged();
36        }
37      }
38    }
39
40    [Storable]
41    protected string parameterName;
42    public string ParameterName {
43      get { return parameterName; }
44      set {
45        if (parameterName != value) {
46          parameterName = value;
47          OnToStringChanged();
48        }
49      }
50    }
51
52    [Storable]
53    protected Type parameterDataType;
54    public Type ParameterDataType {
55      get { return this.parameterDataType; }
56    }
57
58    [Storable]
59    protected IItemSet<IItem> validValues;
60    public IItemSet<IItem> ValidValues {
61      get { return validValues; }
62      protected set {
63        if (this.validValues != value) {
64          this.validValues = value;
65        }
66      }
67    }
68
69    [Storable]
70    protected Type valueDataType;
71    public Type ValueDataType {
72      get { return valueDataType; }
73      protected set { this.valueDataType = value; }
74    }
75
76    [Storable]
77    protected ICheckedValueConfigurationCollection valueConfigurations;
78    public ICheckedValueConfigurationCollection ValueConfigurations {
79      get { return this.valueConfigurations; }
80      protected set {
81        if (this.valueConfigurations != value) {
82          if (this.valueConfigurations != null) DeregisterValueConfigurationEvents();
83          this.valueConfigurations = value;
84          if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
85        }
86      }
87    }
88
89    [Storable]
90    protected int actualValueConfigurationIndex = 0;
91
92    [Storable]
93    protected ConstrainedValue actualValue;
94    public ConstrainedValue ActualValue {
95      get { return actualValue; }
96      set { actualValue = value; }
97    }
98   
99    // store parameter reference only for name/description/image/...
100    //[Storable]
101    //private IValueParameter parameter;
102
103    #region Constructors and Cloning
104    public ParameterConfiguration(string parameterName, IValueParameter valueParameter) {
105      this.ParameterName = parameterName;
106      this.parameterDataType = valueParameter.GetType();
107      //this.parameter = valueParameter;
108      this.valueDataType = valueParameter.DataType;
109      this.validValues = GetValidValues(valueParameter);
110      this.ValueConfigurations = new CheckedValueConfigurationCollection(this.valueDataType);
111      this.ActualValue = new ConstrainedValue(valueParameter.Value, valueParameter.DataType);
112      if (Optimize) {
113        PopulateValueConfigurations();
114      }
115    }
116
117    public ParameterConfiguration() { }
118    [StorableConstructor]
119    protected ParameterConfiguration(bool deserializing) { }
120    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner) : base(original, cloner) {
121      this.parameterName = original.ParameterName;
122      this.parameterDataType = original.parameterDataType;
123      //this.parameter = cloner.Clone(original.parameter);
124      this.valueDataType = original.ValueDataType;
125      this.validValues = cloner.Clone(original.ValidValues);
126      this.valueConfigurations = cloner.Clone(original.ValueConfigurations);
127      this.ActualValue = cloner.Clone(original.ActualValue);
128      this.optimize = original.optimize;
129      this.actualValueConfigurationIndex = original.actualValueConfigurationIndex;
130      if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
131    }
132    public override IDeepCloneable Clone(Cloner cloner) {
133      return new ParameterConfiguration(this, cloner);
134    }
135    [StorableHook(HookType.AfterDeserialization)]
136    private void AfterDeserialization() {
137      if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
138    }
139    #endregion
140
141    private void RegisterValueConfigurationEvents() {
142      this.ValueConfigurations.CheckedItemsChanged += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_CheckedItemsChanged);
143      this.ValueConfigurations.ItemsAdded += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsAdded);
144      this.ValueConfigurations.ItemsRemoved += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsRemoved);
145    }
146
147    private void DeregisterValueConfigurationEvents() {
148      this.ValueConfigurations.CheckedItemsChanged -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_CheckedItemsChanged);
149      this.ValueConfigurations.ItemsAdded -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsAdded);
150      this.ValueConfigurations.ItemsRemoved -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsRemoved);
151    }
152
153    private void PopulateValueConfigurations() {
154      foreach (IItem validValue in this.validValues) {
155        IItem val;
156        if (ActualValue.Value != null && ActualValue.ValueDataType == validValue.GetType()) {
157          val = ActualValue.Value; // use existing value for that type (if available)
158        } else {
159          val = validValue;
160        }
161        this.ValueConfigurations.Add(new ValueConfiguration(val, val.GetType()), true);
162      }
163    }
164
165    private IItemSet<IItem> GetValidValues(IValueParameter parameter) {
166      if (IsSubclassOfRawGeneric(typeof(OptionalConstrainedValueParameter<>), parameter.GetType())) {
167        var x = (IEnumerable)parameter.GetType().GetProperty("ValidValues").GetValue(parameter, new object[] { });
168        return new ItemSet<IItem>(x.Cast<IItem>());
169      } else {
170        return new ItemSet<IItem>(ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName));
171      }
172    }
173
174    private static bool IsSubclassOfRawGeneric(Type generic, Type toCheck) {
175      while (toCheck != typeof(object)) {
176        var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
177        if (generic == cur) {
178          return true;
179        }
180        toCheck = toCheck.BaseType;
181      }
182      return false;
183    }
184
185    void ValueConfigurations_CheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
186      OnToStringChanged();
187    }
188    void ValueConfigurations_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
189      OnToStringChanged();
190    }
191    void ValueConfigurations_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
192      OnToStringChanged();
193    }
194
195    #region INamedItem Properties
196    public virtual string Name {
197      get { return ParameterName; }
198      set { throw new NotSupportedException(); }
199    }
200    public virtual string Description {
201      get { return base.ItemDescription; }
202      set { throw new NotSupportedException(); }
203    }
204    public virtual bool CanChangeDescription {
205      get { return false; }
206    }
207    public virtual bool CanChangeName {
208      get { return false; }
209    }
210    public override string ItemDescription {
211      //get { return parameter != null ? parameter.Description : base.ItemDescription; }
212      get { return base.ItemDescription; }
213    }
214    public override System.Drawing.Image ItemImage {
215      //get { return parameter != null ? parameter.ItemImage : base.ItemImage; }
216      get { return base.ItemImage; }
217    }
218    public override string ItemName {
219      //get { return parameter != null ?parameter.ItemName : base.ItemName; }
220      get { return base.ItemName; }
221    }
222    #endregion
223
224    #region Events
225    public virtual event EventHandler NameChanged;
226    protected virtual void OnNameChanged(object sender, EventArgs e) {
227      var handler = NameChanged;
228      if (handler != null) handler(sender, e);
229    }
230
231    public virtual event EventHandler<CancelEventArgs<string>> NameChanging;
232    protected virtual void OnNameChanging(object sender, CancelEventArgs<string> e) {
233      var handler = NameChanging;
234      if (handler != null) handler(sender, e);
235    }
236
237    public virtual event EventHandler DescriptionChanged;
238    protected virtual void OnDescriptionChanged(object sender, EventArgs e) {
239      var handler = DescriptionChanged;
240      if (handler != null) handler(sender, e);
241    }
242   
243    public virtual event EventHandler IsOptimizableChanged;
244    private void OnIsOptimizableChanged() {
245      var handler = IsOptimizableChanged;
246      if (handler != null) handler(this, EventArgs.Empty);
247    }
248
249    public virtual event EventHandler OptimizeChanged;
250    protected virtual void OnOptimizeChanged() {
251      var handler = OptimizeChanged;
252      if (handler != null) handler(this, EventArgs.Empty);
253    }
254    #endregion
255
256    public override string ToString() {
257      if (Optimize) {
258        return string.Format("{0}: (Optimize: {1})", ParameterName, ValueConfigurations.CheckedItems.Count());
259      } else {
260        return string.Format("{0}: {1}", ParameterName, ActualValue.Value);
261      }
262    }
263
264    public static IParameterConfiguration Create(IParameterizedNamedItem parent, IParameter parameter) {
265      if (parameter is IValueParameter) {
266        IValueParameter valueParameter = parameter as IValueParameter;
267        return new ParameterConfiguration(parameter.Name, valueParameter);
268      }
269      return null;
270    }
271
272    public void Parameterize(IValueParameter parameter) {
273      if (Optimize) {
274        if (this.ActualValue.Value is IParameterizedItem) {
275          this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Parameterize((IParameterizedItem)this.ActualValue.Value);
276        }
277      }
278      parameter.Value = this.ActualValue.Value;
279    }
280
281    public void Randomize(IRandom random) {
282      if (Optimize) {
283        foreach (var vc in this.ValueConfigurations.CheckedItems) {
284          vc.Randomize(random);
285        }
286        actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
287        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
288      }
289    }
290
291    public void Mutate(IRandom random) {
292      if (Optimize) {
293        foreach (IValueConfiguration vc in this.ValueConfigurations.CheckedItems) {
294          vc.Mutate(random);
295        }
296        actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
297        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
298      }
299    }
300
301    public void Cross(IOptimizable other, IRandom random) {
302      if (Optimize) {
303        IParameterConfiguration otherPc = (IParameterConfiguration)other;
304        for (int i = 0; i < this.ValueConfigurations.Count; i++) {
305          this.ValueConfigurations.ElementAt(i).Cross(otherPc.ValueConfigurations.ElementAt(i), random);
306        }
307        if (random.NextDouble() > 0.5) {
308          actualValueConfigurationIndex = ((ParameterConfiguration)other).actualValueConfigurationIndex;
309        }
310        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
311      }
312    }
313  }
314}
Note: See TracBrowser for help on using the repository browser.