Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
01/11/11 15:03:46 (13 years ago)
Author:
gkronber
Message:

Merged changes from trunk to data analysis exploration branch and added fractional distance metric evaluator. #1142

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs

    r4457 r5275  
    3434  [StorableClass]
    3535  public class DataAnalysisProblemData : ParameterizedNamedItem, IStorableContent {
    36     private bool suppressEvents = false;
    37 
     36    protected bool suppressEvents = false;
    3837    #region IStorableContent Members
    3938    public string Filename { get; set; }
    4039    #endregion
    41 
    4240    #region default data
    4341    // y = x^4 + x^3 + x^2 + x
     
    7169    #endregion
    7270    #region parameter properties
    73     public IValueParameter<Dataset> DatasetParameter {
    74       get { return (IValueParameter<Dataset>)Parameters["Dataset"]; }
     71    public ValueParameter<Dataset> DatasetParameter {
     72      get { return (ValueParameter<Dataset>)Parameters["Dataset"]; }
    7573    }
    7674    public IValueParameter<StringValue> TargetVariableParameter {
     
    9290      get { return (IValueParameter<IntValue>)Parameters["TestSamplesEnd"]; }
    9391    }
     92    public IValueParameter<PercentValue> ValidationPercentageParameter {
     93      get { return (IValueParameter<PercentValue>)Parameters["ValidationPercentage"]; }
     94    }
    9495    #endregion
    9596
    9697    #region properties
    9798    public Dataset Dataset {
    98       get { return (Dataset)DatasetParameter.Value; }
     99      get { return DatasetParameter.Value; }
    99100      set {
    100101        if (value != Dataset) {
     
    105106    }
    106107    public StringValue TargetVariable {
    107       get { return (StringValue)TargetVariableParameter.Value; }
     108      get { return TargetVariableParameter.Value; }
    108109      set {
    109110        if (value != TargetVariableParameter.Value) {
     
    115116    }
    116117    public ICheckedItemList<StringValue> InputVariables {
    117       get { return (ICheckedItemList<StringValue>)InputVariablesParameter.Value; }
     118      get { return InputVariablesParameter.Value; }
    118119      set {
    119120        if (value != InputVariables) {
     
    125126    }
    126127    public IntValue TrainingSamplesStart {
    127       get { return (IntValue)TrainingSamplesStartParameter.Value; }
     128      get { return TrainingSamplesStartParameter.Value; }
    128129      set {
    129130        if (value != TrainingSamplesStart) {
     
    135136    }
    136137    public IntValue TrainingSamplesEnd {
    137       get { return (IntValue)TrainingSamplesEndParameter.Value; }
     138      get { return TrainingSamplesEndParameter.Value; }
    138139      set {
    139140        if (value != TrainingSamplesEnd) {
     
    145146    }
    146147    public IntValue TestSamplesStart {
    147       get { return (IntValue)TestSamplesStartParameter.Value; }
     148      get { return TestSamplesStartParameter.Value; }
    148149      set {
    149150        if (value != TestSamplesStart) {
     
    155156    }
    156157    public IntValue TestSamplesEnd {
    157       get { return (IntValue)TestSamplesEndParameter.Value; }
     158      get { return TestSamplesEndParameter.Value; }
    158159      set {
    159160        if (value != TestSamplesEnd) {
     
    164165      }
    165166    }
    166     #endregion
    167 
     167    public PercentValue ValidationPercentage {
     168      get { return ValidationPercentageParameter.Value; }
     169      set {
     170        if (value != ValidationPercentage) {
     171          if (value == null) throw new ArgumentNullException();
     172          if (value.Value < 0 || value.Value > 1) throw new ArgumentException("ValidationPercentage must be between 0 and 1.");
     173          if (ValidationPercentage != null) DeregisterValueTypeEventHandlers(ValidationPercentage);
     174          ValidationPercentageParameter.Value = value;
     175        }
     176      }
     177    }
     178
     179    public IEnumerable<int> TrainingIndizes {
     180      get {
     181        return Enumerable.Range(TrainingSamplesStart.Value, TrainingSamplesEnd.Value - TrainingSamplesStart.Value)
     182                         .Where(i => i >= 0 && i < Dataset.Rows && (i < TestSamplesStart.Value || TestSamplesEnd.Value <= i));
     183      }
     184    }
     185    public IEnumerable<int> TestIndizes {
     186      get {
     187        return Enumerable.Range(TestSamplesStart.Value, TestSamplesEnd.Value - TestSamplesStart.Value)
     188           .Where(i => i >= 0 && i < Dataset.Rows);
     189      }
     190    }
     191    #endregion
     192
     193    [StorableConstructor]
     194    protected DataAnalysisProblemData(bool deserializing) : base(deserializing) { }
     195    protected DataAnalysisProblemData(DataAnalysisProblemData original, Cloner cloner)
     196      : base(original, cloner) {
     197      RegisterParameterEventHandlers();
     198      RegisterParameterValueEventHandlers();
     199    }
    168200    public DataAnalysisProblemData()
    169201      : base() {
     
    181213      Parameters.Add(new ValueParameter<IntValue>("TestSamplesStart", new IntValue(15)));
    182214      Parameters.Add(new ValueParameter<IntValue>("TestSamplesEnd", new IntValue(25)));
     215      Parameters.Add(new ValueParameter<PercentValue>("ValidationPercentage", "The relative amount of the training samples that should be used as validation set.", new PercentValue(0.5)));
     216
     217      DatasetParameter.ReactOnValueToStringChangedAndValueItemImageChanged = false;
    183218      RegisterParameterEventHandlers();
    184219      RegisterParameterValueEventHandlers();
     
    187222    public DataAnalysisProblemData(Dataset dataset, IEnumerable<string> inputVariables, string targetVariable,
    188223      int trainingSamplesStart, int trainingSamplesEnd, int testSamplesStart, int testSamplesEnd) {
    189       var inputVariablesList = new CheckedItemList<StringValue>(inputVariables.Select(x => new StringValue(x)));
     224      var inputVariablesList = new CheckedItemList<StringValue>(inputVariables.Select(x => new StringValue(x)).ToList());
    190225      StringValue targetVariableValue = new StringValue(targetVariable);
    191226      var validTargetVariables = new ItemSet<StringValue>();
     
    201236      Parameters.Add(new ValueParameter<IntValue>("TestSamplesStart", new IntValue(testSamplesStart)));
    202237      Parameters.Add(new ValueParameter<IntValue>("TestSamplesEnd", new IntValue(testSamplesEnd)));
     238      Parameters.Add(new ValueParameter<PercentValue>("ValidationPercentage", "The relative amount of the training samples that should be used as validation set.", new PercentValue(0.5)));
     239
     240      DatasetParameter.ReactOnValueToStringChangedAndValueItemImageChanged = false;
    203241      RegisterParameterEventHandlers();
    204242      RegisterParameterValueEventHandlers();
    205243    }
    206244
    207     [StorableConstructor]
    208     private DataAnalysisProblemData(bool deserializing) : base(deserializing) { }
     245    public override IDeepCloneable Clone(Cloner cloner) {
     246      return new DataAnalysisProblemData(this, cloner);
     247    }
    209248
    210249    [StorableHook(HookType.AfterDeserialization)]
    211     private void AfterDeserializationHook() {
     250    private void AfterDeserialization() {
     251      if (!Parameters.ContainsKey("ValidationPercentage"))
     252        Parameters.Add(new ValueParameter<PercentValue>("ValidationPercentage", "The relative amount of the training samples that should be used as validation set.", new PercentValue(0.5)));
     253
     254      DatasetParameter.ReactOnValueToStringChangedAndValueItemImageChanged = false;
    212255      RegisterParameterEventHandlers();
    213256      RegisterParameterValueEventHandlers();
     
    217260    public event EventHandler ProblemDataChanged;
    218261    protected virtual void OnProblemDataChanged(EventArgs e) {
    219       if (!suppressEvents) {
     262      if (TrainingSamplesStart.Value < 0) TrainingSamplesStart.Value = 0;
     263      else if (TestSamplesStart.Value < 0) TestSamplesStart.Value = 0;
     264      else if (TrainingSamplesEnd.Value > Dataset.Rows - 1) TrainingSamplesEnd.Value = Dataset.Rows - 1;
     265      else if (TestSamplesEnd.Value > Dataset.Rows - 1) TestSamplesEnd.Value = Dataset.Rows - 1;
     266      else if (TrainingSamplesStart.Value > TrainingSamplesEnd.Value) TrainingSamplesStart.Value = TestSamplesEnd.Value;
     267      else if (TestSamplesStart.Value > TestSamplesEnd.Value) TestSamplesStart.Value = TestSamplesEnd.Value;
     268      else if (ValidationPercentage.Value < 0) ValidationPercentage.Value = 0;
     269      else if (ValidationPercentage.Value > 1) ValidationPercentage.Value = 1;
     270      else if (!TrainingIndizes.Any()) throw new ArgumentException("No training samples are available.");
     271      else if (!suppressEvents) {
    220272        var listeners = ProblemDataChanged;
    221273        if (listeners != null) listeners(this, e);
     
    231283      TestSamplesStartParameter.ValueChanged += new EventHandler(TestSamplesStartParameter_ValueChanged);
    232284      TestSamplesEndParameter.ValueChanged += new EventHandler(TestSamplesEndParameter_ValueChanged);
     285      ValidationPercentageParameter.ValueChanged += new EventHandler(ValidationPercentageParameter_ValueChanged);
    233286    }
    234287
     
    240293      RegisterValueTypeEventHandlers(TestSamplesStart);
    241294      RegisterValueTypeEventHandlers(TestSamplesEnd);
     295      RegisterValueTypeEventHandlers(ValidationPercentage);
    242296    }
    243297
     
    271325    private void TestSamplesEndParameter_ValueChanged(object sender, EventArgs e) {
    272326      RegisterValueTypeEventHandlers(TestSamplesEnd);
     327      OnProblemDataChanged(EventArgs.Empty);
     328    }
     329    private void ValidationPercentageParameter_ValueChanged(object sender, EventArgs e) {
     330      RegisterValueTypeEventHandlers(ValidationPercentage);
    273331      OnProblemDataChanged(EventArgs.Empty);
    274332    }
     
    338396
    339397    public virtual void ImportFromFile(string fileName) {
    340       var csvFileParser = new CsvFileParser();
     398      var csvFileParser = new TableFileParser();
    341399      csvFileParser.Parse(fileName);
    342400      suppressEvents = true;
     
    352410      InputVariables.SetItemCheckedState(variableNames.First(), false);
    353411      int middle = (int)(csvFileParser.Rows * 0.5);
     412      TrainingSamplesEnd = new IntValue(middle);
    354413      TrainingSamplesStart = new IntValue(0);
    355       TrainingSamplesEnd = new IntValue(middle);
     414      TestSamplesEnd = new IntValue(csvFileParser.Rows);
    356415      TestSamplesStart = new IntValue(middle);
    357       TestSamplesEnd = new IntValue(csvFileParser.Rows);
    358416      suppressEvents = false;
    359417      OnProblemDataChanged(EventArgs.Empty);
    360     }
    361 
    362     public override IDeepCloneable Clone(Cloner cloner) {
    363       DataAnalysisProblemData clone = (DataAnalysisProblemData)base.Clone(cloner);
    364       clone.RegisterParameterEventHandlers();
    365       clone.RegisterParameterValueEventHandlers();
    366       return clone;
    367418    }
    368419  }
Note: See TracChangeset for help on using the changeset viewer.