Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/27/10 16:25:51 (14 years ago)
Author:
gkronber
Message:

Fixed bugs in wiring of data analysis and symbolic regression problems. #938 (Data types and operators for regression problems)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs

    r3442 r3545  
    3535  [Item("DataAnalysisProblemData", "Represents an item containing all data defining a data analysis problem.")]
    3636  [StorableClass]
    37   public class DataAnalysisProblemData : NamedItem {
    38     [Storable]
    39     private VariableCollection variables;
    40     public VariableCollection Variables {
    41       get { return variables; }
    42     }
    43 
    44     #region variable properties
    45     public IVariable DatasetVariable {
    46       get { return variables["Dataset"]; }
    47     }
    48 
    49     public IVariable TargetVariableVariable {
    50       get { return variables["TargetVariable"]; }
    51     }
    52 
    53     public IVariable InputVariablesVariable {
    54       get { return variables["InputVariables"]; }
    55     }
    56 
    57     public IVariable TrainingSamplesStartVariable {
    58       get { return variables["TrainingSamplesStart"]; }
    59     }
    60     public IVariable TrainingSamplesEndVariable {
    61       get { return variables["TrainingSamplesEnd"]; }
    62     }
    63 
    64     public IVariable TestSamplesStartVariable {
    65       get { return variables["TestSamplesStart"]; }
    66     }
    67     public IVariable TestSamplesEndVariable {
    68       get { return variables["TestSamplesEnd"]; }
     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<ItemSet<StringValue>> InputVariablesParameter {
     49      get { return (IValueParameter<ItemSet<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"]; }
    6963    }
    7064    #endregion
    … …  
    7266    #region properties
    7367    public Dataset Dataset {
    74       get { return (Dataset)DatasetVariable.Value; }
     68      get { return (Dataset)DatasetParameter.Value; }
    7569      set {
    7670        if (value != Dataset) {
    7771          if (value == null) throw new ArgumentNullException();
    7872          if (Dataset != null) DeregisterDatasetEventHandlers();
    79           DatasetVariable.Value = value;
    80           RegisterDatasetEventHandlers();
    81           OnProblemDataChanged(EventArgs.Empty);
     73          DatasetParameter.Value = value;
    8274        }
    8375      }
    8476    }
    8577    public StringValue TargetVariable {
    86       get { return (StringValue)TargetVariableVariable.Value; }
    87       set {
    88         if (value != TargetVariableVariable) {
     78      get { return (StringValue)TargetVariableParameter.Value; }
     79      set {
     80        if (value != TargetVariableParameter.Value) {
    8981          if (value == null) throw new ArgumentNullException();
    9082          if (TargetVariable != null) DeregisterStringValueEventHandlers(TargetVariable);
    91           TargetVariableVariable.Value = value;
    92           RegisterStringValueEventHandlers(TargetVariable);
    93           OnProblemDataChanged(EventArgs.Empty);
    94         }
    95       }
    96     }
    97     public ItemList<StringValue> InputVariables {
    98       get { return (ItemList<StringValue>)InputVariablesVariable.Value; }
     83          TargetVariableParameter.Value = value;
     84        }
     85      }
     86    }
     87    public ItemSet<StringValue> InputVariables {
     88      get { return (ItemSet<StringValue>)InputVariablesParameter.Value; }
    9989      set {
    10090        if (value != InputVariables) {
    10191          if (value == null) throw new ArgumentNullException();
    10292          if (InputVariables != null) DeregisterInputVariablesEventHandlers();
    103           InputVariablesVariable.Value = value;
    104           RegisterInputVariablesEventHandlers();
    105           OnProblemDataChanged(EventArgs.Empty);
     93          InputVariablesParameter.Value = value;
    10694        }
    10795      }
    10896    }
    10997    public IntValue TrainingSamplesStart {
    110       get { return (IntValue)TrainingSamplesStartVariable.Value; }
     98      get { return (IntValue)TrainingSamplesStartParameter.Value; }
    11199      set {
    112100        if (value != TrainingSamplesStart) {
    113101          if (value == null) throw new ArgumentNullException();
    114102          if (TrainingSamplesStart != null) DeregisterValueTypeEventHandlers(TrainingSamplesStart);
    115           TrainingSamplesStartVariable.Value = value;
    116           RegisterValueTypeEventHandlers(TrainingSamplesStart);
    117           OnProblemDataChanged(EventArgs.Empty);
     103          TrainingSamplesStartParameter.Value = value;
    118104        }
    119105      }
    120106    }
    121107    public IntValue TrainingSamplesEnd {
    122       get { return (IntValue)TrainingSamplesEndVariable.Value; }
     108      get { return (IntValue)TrainingSamplesEndParameter.Value; }
    123109      set {
    124110        if (value != TrainingSamplesEnd) {
    125111          if (value == null) throw new ArgumentNullException();
    126112          if (TrainingSamplesEnd != null) DeregisterValueTypeEventHandlers(TrainingSamplesEnd);
    127           TrainingSamplesEndVariable.Value = value;
    128           RegisterValueTypeEventHandlers(TrainingSamplesEnd);
    129           OnProblemDataChanged(EventArgs.Empty);
     113          TrainingSamplesEndParameter.Value = value;
    130114        }
    131115      }
    132116    }
    133117    public IntValue TestSamplesStart {
    134       get { return (IntValue)TestSamplesStartVariable.Value; }
     118      get { return (IntValue)TestSamplesStartParameter.Value; }
    135119      set {
    136120        if (value != TestSamplesStart) {
    137121          if (value == null) throw new ArgumentNullException();
    138122          if (TestSamplesStart != null) DeregisterValueTypeEventHandlers(TestSamplesStart);
    139           TestSamplesStartVariable.Value = value;
    140           RegisterValueTypeEventHandlers(TestSamplesStart);
    141           OnProblemDataChanged(EventArgs.Empty);
     123          TestSamplesStartParameter.Value = value;
    142124        }
    143125      }
    144126    }
    145127    public IntValue TestSamplesEnd {
    146       get { return (IntValue)TestSamplesEndVariable.Value; }
     128      get { return (IntValue)TestSamplesEndParameter.Value; }
    147129      set {
    148130        if (value != TestSamplesEnd) {
    149131          if (value == null) throw new ArgumentNullException();
    150132          if (TestSamplesEnd != null) DeregisterValueTypeEventHandlers(TestSamplesEnd);
    151           TestSamplesEndVariable.Value = value;
    152           RegisterValueTypeEventHandlers(TestSamplesEnd);
    153           OnProblemDataChanged(EventArgs.Empty);
     133          TestSamplesEndParameter.Value = value;
    154134        }
    155135      }
    … …  
    159139    public DataAnalysisProblemData()
    160140      : base() {
    161       variables = new VariableCollection();
    162       variables.Add(new Variable("Dataset", new Dataset()));
    163       variables.Add(new Variable("InputVariables", new ItemList<StringValue>()));
    164       variables.Add(new Variable("TargetVariable", new StringValue()));
    165       variables.Add(new Variable("TrainingSamplesStart", new IntValue()));
    166       variables.Add(new Variable("TrainingSamplesEnd", new IntValue()));
    167       variables.Add(new Variable("TestSamplesStart", new IntValue()));
    168       variables.Add(new Variable("TestSamplesEnd", new IntValue()));
    169       RegisterEventHandlers();
    170     }
     141      Parameters.Add(new ValueParameter<Dataset>("Dataset", new Dataset()));
     142      Parameters.Add(new ValueParameter<ItemSet<StringValue>>("InputVariables", new ItemSet<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
    171152
    172153    [StorableConstructor]
    … …  
    175156    [StorableHook(HookType.AfterDeserialization)]
    176157    private void AfterDeserializationHook() {
    177       RegisterEventHandlers();
     158      RegisterParameterEventHandlers();
     159      RegisterParameterValueEventHandlers();
    178160    }
    179161
    180162    #region events
    181     private void RegisterEventHandlers() {
     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() {
    182182      RegisterDatasetEventHandlers();
    183183      RegisterInputVariablesEventHandlers();
    184       RegisterStringValueEventHandlers(TargetVariable);
     184      if (TargetVariable != null) RegisterStringValueEventHandlers(TargetVariable);
    185185      RegisterValueTypeEventHandlers(TrainingSamplesStart);
    186186      RegisterValueTypeEventHandlers(TrainingSamplesEnd);
    … …  
    189189    }
    190190
    191     public event EventHandler ProblemDataChanged;
    192     protected virtual void OnProblemDataChanged(EventArgs e) {
    193       var listeners = ProblemDataChanged;
    194       if (listeners != null) listeners(this, e);
    195     }
    196 
    197 
    198     private void RegisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
    199       value.ValueChanged += new EventHandler(value_ValueChanged);
    200     }
    201 
    202     private void DeregisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
    203       value.ValueChanged -= new EventHandler(value_ValueChanged);
    204     }
    205 
    206     void value_ValueChanged(object sender, EventArgs e) {
    207       OnProblemDataChanged(e);
    208     }
    209 
    210     private void RegisterStringValueEventHandlers(StringValue value) {
    211       value.ValueChanged += new EventHandler(value_ValueChanged);
    212     }
    213 
    214     private void DeregisterStringValueEventHandlers(StringValue value) {
    215       value.ValueChanged -= new EventHandler(value_ValueChanged);
    216     }
     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
    217225
    218226    private void RegisterDatasetEventHandlers() {
    … …  
    241249
    242250    private void RegisterInputVariablesEventHandlers() {
    243       InputVariables.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CollectionReset);
    244       InputVariables.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsAdded);
    245       InputVariables.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsRemoved);
    246       InputVariables.ItemsReplaced += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsReplaced);
     251      InputVariables.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_CollectionReset);
     252      InputVariables.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsAdded);
     253      InputVariables.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsRemoved);
    247254      foreach (var item in InputVariables)
    248         item.ValueChanged += new EventHandler(InputVariables_Value_ValueChanged);
     255        item.ValueChanged += new EventHandler(InputVariable_ValueChanged);
     256    }
     257
     258    void InputVariables_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<StringValue> e) {
     259      foreach (var item in e.Items)
     260        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
     261      OnProblemDataChanged(e);
     262    }
     263
     264    void InputVariables_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<StringValue> e) {
     265      foreach (var item in e.OldItems)
     266        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
     267      OnProblemDataChanged(e);
     268    }
     269
     270    void InputVariables_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<StringValue> e) {
     271      foreach (var item in e.Items)
     272        item.ValueChanged += new EventHandler(InputVariable_ValueChanged);
     273      OnProblemDataChanged(e);
    249274    }
    250275
    251276    private void DeregisterInputVariablesEventHandlers() {
    252       InputVariables.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CollectionReset);
    253       InputVariables.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsAdded);
    254       InputVariables.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsRemoved);
    255       InputVariables.ItemsReplaced -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsReplaced);
     277      InputVariables.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_CollectionReset);
     278      InputVariables.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsAdded);
     279      InputVariables.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsRemoved);
    256280      foreach (var item in InputVariables) {
    257         item.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
    258       }
    259     }
    260 
    261     void InputVariables_ItemsReplaced(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
    262       foreach (var indexedItem in e.OldItems)
    263         indexedItem.Value.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
    264       foreach (var indexedItem in e.Items)
    265         indexedItem.Value.ValueChanged += new EventHandler(InputVariables_Value_ValueChanged);
    266       OnProblemDataChanged(e);
    267     }
    268 
    269     void InputVariables_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
    270       foreach (var indexedItem in e.Items)
    271         indexedItem.Value.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
    272       OnProblemDataChanged(e);
    273     }
    274 
    275     void InputVariables_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
    276       foreach (var indexedItem in e.Items)
    277         indexedItem.Value.ValueChanged += new EventHandler(InputVariables_Value_ValueChanged);
    278       OnProblemDataChanged(e);
    279     }
    280 
    281     void InputVariables_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
    282       foreach (var indexedItem in e.OldItems)
    283         indexedItem.Value.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
    284 
    285       OnProblemDataChanged(e);
    286     }
    287     void InputVariables_Value_ValueChanged(object sender, EventArgs e) {
    288       OnProblemDataChanged(e);
    289     }
    290 
     281        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
     282      }
     283    }
     284 
     285    void InputVariable_ValueChanged(object sender, EventArgs e) {
     286      OnProblemDataChanged(e);
     287    }
     288    #region helper
     289
     290    private void RegisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
     291      value.ValueChanged += new EventHandler(value_ValueChanged);
     292    }
     293
     294    private void DeregisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
     295      value.ValueChanged -= new EventHandler(value_ValueChanged);
     296    }
     297
     298    void value_ValueChanged(object sender, EventArgs e) {
     299      OnProblemDataChanged(e);
     300    }
     301
     302    private void RegisterStringValueEventHandlers(StringValue value) {
     303      value.ValueChanged += new EventHandler(value_ValueChanged);
     304    }
     305
     306    private void DeregisterStringValueEventHandlers(StringValue value) {
     307      value.ValueChanged -= new EventHandler(value_ValueChanged);
     308    }
     309
     310    #endregion
    291311    #endregion
    292312
    … …  
    294314      var csvFileParser = new CsvFileParser();
    295315      csvFileParser.Parse(fileName);
     316      suppressEvents = true;
    296317      Name = "Data imported from " + Path.GetFileName(fileName);
    297318      Dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
    298319      Dataset.Name = Path.GetFileName(fileName);
    299       TargetVariable = new StringValue(Dataset.VariableNames.First());
    300       InputVariables = new ItemList<StringValue>(Dataset.VariableNames.Skip(1).Select(s => new StringValue(s)));
     320      var variableNames = Dataset.VariableNames.Select(x => new StringValue(x).AsReadOnly()).ToList();
     321      ((ConstrainedValueParameter<StringValue>)TargetVariableParameter).ValidValues.Clear();
     322      foreach (var variableName in variableNames)
     323        ((ConstrainedValueParameter<StringValue>)TargetVariableParameter).ValidValues.Add(variableName);
     324      TargetVariable = variableNames.First();
     325      InputVariables = new ItemSet<StringValue>(variableNames.Skip(1));
    301326      int middle = (int)(csvFileParser.Rows * 0.5);
    302327      TrainingSamplesStart = new IntValue(0);
    … …  
    304329      TestSamplesStart = new IntValue(middle);
    305330      TestSamplesEnd = new IntValue(csvFileParser.Rows);
     331      suppressEvents = false;
     332      OnProblemDataChanged(EventArgs.Empty);
    306333    }
    307334
    308335    public override IDeepCloneable Clone(Cloner cloner) {
    309336      DataAnalysisProblemData clone = (DataAnalysisProblemData)base.Clone(cloner);
    310       clone.variables = (VariableCollection)variables.Clone(cloner);
    311 
    312       clone.RegisterEventHandlers();
     337      clone.RegisterParameterEventHandlers();
     338      clone.RegisterParameterValueEventHandlers();
    313339      return clone;
    314340    }
Note: See TracChangeset for help on using the changeset viewer.