Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs @ 3651

Last change on this file since 3651 was 3651, checked in by gkronber, 14 years ago

Implemented analyzers for symbolic expression tree encoding, artificial ant problem and symbolic regression problem. #999 (Refactor algorithm analysis and tracing)
File size: 15.6 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
28using HeuristicLab.Parameters;
29using HeuristicLab.Data;
30using HeuristicLab.Problems.DataAnalysis;
31using System.Drawing;
32using System.IO;
33
34namespace HeuristicLab.Problems.DataAnalysis {
35  [Item("DataAnalysisProblemData", "Represents an item containing all data defining a data analysis problem.")]
36  [StorableClass]
37  public class DataAnalysisProblemData : ParameterizedNamedItem {
38    private bool suppressEvents = false;
39    #region parameter properties
40    public IValueParameter<Dataset> DatasetParameter {
41      get { return (IValueParameter<Dataset>)Parameters["Dataset"]; }
42    }
43
44    public IValueParameter<StringValue> TargetVariableParameter {
45      get { return (IValueParameter<StringValue>)Parameters["TargetVariable"]; }
46    }
47
48    public IValueParameter<ICheckedItemList<StringValue>> InputVariablesParameter {
49      get { return (IValueParameter<ICheckedItemList<StringValue>>)Parameters["InputVariables"]; }
50    }
51
52    public IValueParameter<IntValue> TrainingSamplesStartParameter {
53      get { return (IValueParameter<IntValue>)Parameters["TrainingSamplesStart"]; }
54    }
55    public IValueParameter<IntValue> TrainingSamplesEndParameter {
56      get { return (IValueParameter<IntValue>)Parameters["TrainingSamplesEnd"]; }
57    }
58    public IValueParameter<IntValue> TestSamplesStartParameter {
59      get { return (IValueParameter<IntValue>)Parameters["TestSamplesStart"]; }
60    }
61    public IValueParameter<IntValue> TestSamplesEndParameter {
62      get { return (IValueParameter<IntValue>)Parameters["TestSamplesEnd"]; }
63    }
64    #endregion
65
66    #region properties
67    public Dataset Dataset {
68      get { return (Dataset)DatasetParameter.Value; }
69      set {
70        if (value != Dataset) {
71          if (value == null) throw new ArgumentNullException();
72          if (Dataset != null) DeregisterDatasetEventHandlers();
73          DatasetParameter.Value = value;
74        }
75      }
76    }
77    public StringValue TargetVariable {
78      get { return (StringValue)TargetVariableParameter.Value; }
79      set {
80        if (value != TargetVariableParameter.Value) {
81          if (value == null) throw new ArgumentNullException();
82          if (TargetVariable != null) DeregisterStringValueEventHandlers(TargetVariable);
83          TargetVariableParameter.Value = value;
84        }
85      }
86    }
87    public ICheckedItemList<StringValue> InputVariables {
88      get { return (ICheckedItemList<StringValue>)InputVariablesParameter.Value; }
89      set {
90        if (value != InputVariables) {
91          if (value == null) throw new ArgumentNullException();
92          if (InputVariables != null) DeregisterInputVariablesEventHandlers();
93          InputVariablesParameter.Value = value;
94        }
95      }
96    }
97    public IntValue TrainingSamplesStart {
98      get { return (IntValue)TrainingSamplesStartParameter.Value; }
99      set {
100        if (value != TrainingSamplesStart) {
101          if (value == null) throw new ArgumentNullException();
102          if (TrainingSamplesStart != null) DeregisterValueTypeEventHandlers(TrainingSamplesStart);
103          TrainingSamplesStartParameter.Value = value;
104        }
105      }
106    }
107    public IntValue TrainingSamplesEnd {
108      get { return (IntValue)TrainingSamplesEndParameter.Value; }
109      set {
110        if (value != TrainingSamplesEnd) {
111          if (value == null) throw new ArgumentNullException();
112          if (TrainingSamplesEnd != null) DeregisterValueTypeEventHandlers(TrainingSamplesEnd);
113          TrainingSamplesEndParameter.Value = value;
114        }
115      }
116    }
117    public IntValue TestSamplesStart {
118      get { return (IntValue)TestSamplesStartParameter.Value; }
119      set {
120        if (value != TestSamplesStart) {
121          if (value == null) throw new ArgumentNullException();
122          if (TestSamplesStart != null) DeregisterValueTypeEventHandlers(TestSamplesStart);
123          TestSamplesStartParameter.Value = value;
124        }
125      }
126    }
127    public IntValue TestSamplesEnd {
128      get { return (IntValue)TestSamplesEndParameter.Value; }
129      set {
130        if (value != TestSamplesEnd) {
131          if (value == null) throw new ArgumentNullException();
132          if (TestSamplesEnd != null) DeregisterValueTypeEventHandlers(TestSamplesEnd);
133          TestSamplesEndParameter.Value = value;
134        }
135      }
136    }
137    #endregion
138
139    public DataAnalysisProblemData()
140      : base() {
141      Parameters.Add(new ValueParameter<Dataset>("Dataset", new Dataset()));
142      Parameters.Add(new ValueParameter<ICheckedItemList<StringValue>>("InputVariables", new CheckedItemList<StringValue>()));
143      Parameters.Add(new ConstrainedValueParameter<StringValue>("TargetVariable"));
144      Parameters.Add(new ValueParameter<IntValue>("TrainingSamplesStart", new IntValue()));
145      Parameters.Add(new ValueParameter<IntValue>("TrainingSamplesEnd", new IntValue()));
146      Parameters.Add(new ValueParameter<IntValue>("TestSamplesStart", new IntValue()));
147      Parameters.Add(new ValueParameter<IntValue>("TestSamplesEnd", new IntValue()));
148      RegisterParameterEventHandlers();
149      RegisterParameterValueEventHandlers();
150    }
151
152
153    [StorableConstructor]
154    private DataAnalysisProblemData(bool deserializing) : base() { }
155
156    [StorableHook(HookType.AfterDeserialization)]
157    private void AfterDeserializationHook() {
158      RegisterParameterEventHandlers();
159      RegisterParameterValueEventHandlers();
160    }
161
162    #region events
163    public event EventHandler ProblemDataChanged;
164    protected virtual void OnProblemDataChanged(EventArgs e) {
165      if (!suppressEvents) {
166        var listeners = ProblemDataChanged;
167        if (listeners != null) listeners(this, e);
168      }
169    }
170
171    private void RegisterParameterEventHandlers() {
172      DatasetParameter.ValueChanged += new EventHandler(DatasetParameter_ValueChanged);
173      InputVariablesParameter.ValueChanged += new EventHandler(InputVariablesParameter_ValueChanged);
174      TargetVariableParameter.ValueChanged += new EventHandler(TargetVariableParameter_ValueChanged);
175      TrainingSamplesStartParameter.ValueChanged += new EventHandler(TrainingSamplesStartParameter_ValueChanged);
176      TrainingSamplesEndParameter.ValueChanged += new EventHandler(TrainingSamplesEndParameter_ValueChanged);
177      TestSamplesStartParameter.ValueChanged += new EventHandler(TestSamplesStartParameter_ValueChanged);
178      TestSamplesEndParameter.ValueChanged += new EventHandler(TestSamplesEndParameter_ValueChanged);
179    }
180
181    private void RegisterParameterValueEventHandlers() {
182      RegisterDatasetEventHandlers();
183      RegisterInputVariablesEventHandlers();
184      if (TargetVariable != null) RegisterStringValueEventHandlers(TargetVariable);
185      RegisterValueTypeEventHandlers(TrainingSamplesStart);
186      RegisterValueTypeEventHandlers(TrainingSamplesEnd);
187      RegisterValueTypeEventHandlers(TestSamplesStart);
188      RegisterValueTypeEventHandlers(TestSamplesEnd);
189    }
190
191
192    #region parameter value changed event handlers
193    void DatasetParameter_ValueChanged(object sender, EventArgs e) {
194      RegisterDatasetEventHandlers();
195      OnProblemDataChanged(EventArgs.Empty);
196    }
197    void InputVariablesParameter_ValueChanged(object sender, EventArgs e) {
198      RegisterInputVariablesEventHandlers();
199      OnProblemDataChanged(EventArgs.Empty);
200    }
201    void TargetVariableParameter_ValueChanged(object sender, EventArgs e) {
202      if (TargetVariable != null) {
203        RegisterStringValueEventHandlers(TargetVariable);
204        OnProblemDataChanged(EventArgs.Empty);
205      }
206    }
207    void TrainingSamplesStartParameter_ValueChanged(object sender, EventArgs e) {
208      RegisterValueTypeEventHandlers(TrainingSamplesStart);
209      OnProblemDataChanged(EventArgs.Empty);
210    }
211    void TrainingSamplesEndParameter_ValueChanged(object sender, EventArgs e) {
212      RegisterValueTypeEventHandlers(TrainingSamplesEnd);
213      OnProblemDataChanged(EventArgs.Empty);
214    }
215    void TestSamplesStartParameter_ValueChanged(object sender, EventArgs e) {
216      RegisterValueTypeEventHandlers(TestSamplesStart);
217      OnProblemDataChanged(EventArgs.Empty);
218    }
219    void TestSamplesEndParameter_ValueChanged(object sender, EventArgs e) {
220      RegisterValueTypeEventHandlers(TestSamplesEnd);
221      OnProblemDataChanged(EventArgs.Empty);
222    }
223    #endregion
224
225
226    private void RegisterDatasetEventHandlers() {
227      Dataset.DataChanged += new EventHandler<EventArgs<int, int>>(Dataset_DataChanged);
228      Dataset.Reset += new EventHandler(Dataset_Reset);
229      Dataset.ColumnNamesChanged += new EventHandler(Dataset_ColumnNamesChanged);
230    }
231
232    private void DeregisterDatasetEventHandlers() {
233      Dataset.DataChanged -= new EventHandler<EventArgs<int, int>>(Dataset_DataChanged);
234      Dataset.Reset -= new EventHandler(Dataset_Reset);
235      Dataset.ColumnNamesChanged -= new EventHandler(Dataset_ColumnNamesChanged);
236    }
237
238    void Dataset_ColumnNamesChanged(object sender, EventArgs e) {
239      OnProblemDataChanged(e);
240    }
241
242    void Dataset_Reset(object sender, EventArgs e) {
243      OnProblemDataChanged(e);
244    }
245
246    void Dataset_DataChanged(object sender, EventArgs<int, int> e) {
247      OnProblemDataChanged(e);
248    }
249
250    private void RegisterInputVariablesEventHandlers() {
251      InputVariables.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CollectionReset);
252      InputVariables.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsAdded);
253      InputVariables.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsRemoved);
254      InputVariables.CheckedItemsChanged += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CheckedItemsChanged);
255      foreach (var item in InputVariables)
256        item.ValueChanged += new EventHandler(InputVariable_ValueChanged);
257    }
258
259    private void DeregisterInputVariablesEventHandlers() {
260      InputVariables.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CollectionReset);
261      InputVariables.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsAdded);
262      InputVariables.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsRemoved);
263      InputVariables.CheckedItemsChanged -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CheckedItemsChanged);
264      foreach (var item in InputVariables) {
265        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
266      }
267    }
268
269    private void InputVariables_CheckedItemsChanged(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
270      OnProblemDataChanged(e);
271    }
272
273    private void InputVariables_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
274      foreach (var indexedItem in e.Items)
275        indexedItem.Value.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
276      OnProblemDataChanged(e);
277    }
278
279    private void InputVariables_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
280      foreach (var indexedItem in e.Items)
281        indexedItem.Value.ValueChanged += new EventHandler(InputVariable_ValueChanged);
282      OnProblemDataChanged(e);
283    }
284
285    private void InputVariables_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
286      foreach (var indexedItem in e.OldItems)
287        indexedItem.Value.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
288      OnProblemDataChanged(e);
289    }
290
291    void InputVariable_ValueChanged(object sender, EventArgs e) {
292      OnProblemDataChanged(e);
293    }
294    #region helper
295
296    private void RegisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
297      value.ValueChanged += new EventHandler(value_ValueChanged);
298    }
299
300    private void DeregisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
301      value.ValueChanged -= new EventHandler(value_ValueChanged);
302    }
303
304    void value_ValueChanged(object sender, EventArgs e) {
305      OnProblemDataChanged(e);
306    }
307
308    private void RegisterStringValueEventHandlers(StringValue value) {
309      value.ValueChanged += new EventHandler(value_ValueChanged);
310    }
311
312    private void DeregisterStringValueEventHandlers(StringValue value) {
313      value.ValueChanged -= new EventHandler(value_ValueChanged);
314    }
315
316    #endregion
317    #endregion
318
319    public virtual void ImportFromFile(string fileName) {
320      var csvFileParser = new CsvFileParser();
321      csvFileParser.Parse(fileName);
322      suppressEvents = true;
323      Name = "Data imported from " + Path.GetFileName(fileName);
324      Dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
325      Dataset.Name = Path.GetFileName(fileName);
326      var variableNames = Dataset.VariableNames.Select(x => new StringValue(x).AsReadOnly()).ToList();
327      ((ConstrainedValueParameter<StringValue>)TargetVariableParameter).ValidValues.Clear();
328      foreach (var variableName in variableNames)
329        ((ConstrainedValueParameter<StringValue>)TargetVariableParameter).ValidValues.Add(variableName);
330      TargetVariable = variableNames.First();
331      InputVariables = new CheckedItemList<StringValue>(variableNames).AsReadOnly();
332      InputVariables.SetItemCheckedState(variableNames.First(), false);
333      int middle = (int)(csvFileParser.Rows * 0.5);
334      TrainingSamplesStart = new IntValue(0);
335      TrainingSamplesEnd = new IntValue(middle);
336      TestSamplesStart = new IntValue(middle);
337      TestSamplesEnd = new IntValue(csvFileParser.Rows);
338      suppressEvents = false;
339      OnProblemDataChanged(EventArgs.Empty);
340    }
341
342    public override IDeepCloneable Clone(Cloner cloner) {
343      DataAnalysisProblemData clone = (DataAnalysisProblemData)base.Clone(cloner);
344      clone.RegisterParameterEventHandlers();
345      clone.RegisterParameterValueEventHandlers();
346      return clone;
347    }
348  }
349}
Note: See TracBrowser for help on using the repository browser.