Free cookie consent management tool by TermsFeed Policy Generator

Changeset 5682


Ignore:
Timestamp:
03/15/11 09:51:22 (12 years ago)
Author:
svonolfe
Message:

Implemented review comments from swagner (#1392)

Location:
branches/SuccessProgressAnalysis
Files:
1 added
1 deleted
7 edited
1 copied

Legend:

Unmodified
Added
Removed
  • branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3.csproj

    r5379 r5682  
    116116    <Compile Include="OffspringSelectionGeneticAlgorithmMainOperator.cs" />
    117117    <Compile Include="Properties\AssemblyInfo.cs" />
    118     <Compile Include="SuccessProgressAnalysis\SuccessProgressAnalyzer.cs" />
     118    <Compile Include="SuccessfulOffspringAnalysis\SuccessfulOffspringAnalyzer.cs" />
    119119  </ItemGroup>
    120120  <ItemGroup>
  • branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs

    r5366 r5682  
    249249    [Storable]
    250250    private ValueAnalyzer selectionPressureAnalyzer;
     251    [Storable]
     252    private SuccessfulOffspringAnalyzer successfulOffspringAnalyzer;
    251253    #endregion
    252254
     
    255257    [StorableHook(HookType.AfterDeserialization)]
    256258    private void AfterDeserialization() {
     259      #region Backwards Compatibility
     260      if (successfulOffspringAnalyzer == null)
     261        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
     262      #endregion
     263     
    257264      Initialize();
    258265    }
     
    263270      islandSelectionPressureAnalyzer = cloner.Clone(original.islandSelectionPressureAnalyzer);
    264271      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
     272      successfulOffspringAnalyzer = cloner.Clone(original.successfulOffspringAnalyzer);
    265273      Initialize();
    266274    }
     
    386394      selectionPressureAnalyzer = new ValueAnalyzer();
    387395      islandSelectionPressureAnalyzer = new ValueAnalyzer();
     396      successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
    388397      ParameterizeAnalyzers();
    389398      UpdateAnalyzers();
     
    554563      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
    555564
     565      successfulOffspringAnalyzer.ResultsParameter.ActualName = "Results";
     566      successfulOffspringAnalyzer.GenerationsParameter.ActualName = "Generations";
     567      successfulOffspringAnalyzer.SuccessfulOffspringFlag.Value.Value = "SuccessfulOffspring";
     568      successfulOffspringAnalyzer.DepthParameter.Value = new IntValue(2);
     569
    556570      if (Problem != null) {
    557571        islandQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
     
    616630      Analyzer.Operators.Add(qualityAnalyzer);
    617631      Analyzer.Operators.Add(selectionPressureAnalyzer);
     632      Analyzer.Operators.Add(successfulOffspringAnalyzer);
     633      Analyzer.Operators.SetItemCheckedState(successfulOffspringAnalyzer, false);
    618634    }
    619635    private IslandOffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {
  • branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithm.cs

    r5366 r5682  
    197197    [Storable]
    198198    private ValueAnalyzer selectionPressureAnalyzer;
     199    [Storable]
     200    private SuccessfulOffspringAnalyzer successfulOffspringAnalyzer;
    199201    #endregion
    200202
     
    203205    [StorableHook(HookType.AfterDeserialization)]
    204206    private void AfterDeserialization() {
     207      #region Backwards Compatibility
     208      if (successfulOffspringAnalyzer == null)
     209        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
     210      #endregion
     211     
    205212      Initialize();
    206213    }
     
    209216      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
    210217      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
     218      successfulOffspringAnalyzer = cloner.Clone(original.successfulOffspringAnalyzer);
    211219      Initialize();
    212220    }
     
    291299      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
    292300      selectionPressureAnalyzer = new ValueAnalyzer();
     301      successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
    293302      ParameterizeAnalyzers();
    294303      UpdateAnalyzers();
     
    407416      selectionPressureAnalyzer.ValueParameter.Depth = 0;
    408417      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
     418      successfulOffspringAnalyzer.ResultsParameter.ActualName = "Results";
     419      successfulOffspringAnalyzer.GenerationsParameter.ActualName = "Generations";
     420      successfulOffspringAnalyzer.SuccessfulOffspringFlag.Value.Value = "SuccessfulOffspring";
     421      successfulOffspringAnalyzer.DepthParameter.Value = new IntValue(1);
    409422      if (Problem != null) {
    410423        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
     
    462475      Analyzer.Operators.Add(qualityAnalyzer);
    463476      Analyzer.Operators.Add(selectionPressureAnalyzer);
     477      Analyzer.Operators.Add(successfulOffspringAnalyzer);
     478      Analyzer.Operators.SetItemCheckedState(successfulOffspringAnalyzer, false);
    464479    }
    465480    private OffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {
  • branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASA.cs

    r5366 r5682  
    225225    [Storable]
    226226    private ValueAnalyzer selectionPressureAnalyzer;
     227    [Storable]
     228    private SuccessfulOffspringAnalyzer successfulOffspringAnalyzer;
    227229    #endregion
    228230
     
    231233    [StorableHook(HookType.AfterDeserialization)]
    232234    private void AfterDeserialization() {
     235      #region Backwards Compatibility
     236      if (successfulOffspringAnalyzer == null)
     237        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
     238      #endregion
     239
    233240      Initialize();
    234241    }
     
    239246      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
    240247      villageSelectionPressureAnalyzer = cloner.Clone(original.villageSelectionPressureAnalyzer);
     248      successfulOffspringAnalyzer = cloner.Clone(original.successfulOffspringAnalyzer);
    241249      Initialize();
    242250    }
     
    344352      selectionPressureAnalyzer = new ValueAnalyzer();
    345353      villageSelectionPressureAnalyzer = new ValueAnalyzer();
     354      successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
    346355      ParameterizeAnalyzers();
    347356      UpdateAnalyzers();
     
    492501      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
    493502
     503      successfulOffspringAnalyzer.ResultsParameter.ActualName = "Results";
     504      successfulOffspringAnalyzer.GenerationsParameter.ActualName = "Generations";
     505      successfulOffspringAnalyzer.SuccessfulOffspringFlag.Value.Value = "SuccessfulOffspring";
     506      successfulOffspringAnalyzer.DepthParameter.Value = new IntValue(2);
     507
    494508      if (Problem != null) {
    495509        villageQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
     
    554568      Analyzer.Operators.Add(qualityAnalyzer);
    555569      Analyzer.Operators.Add(selectionPressureAnalyzer);
     570      Analyzer.Operators.Add(successfulOffspringAnalyzer);
     571      Analyzer.Operators.SetItemCheckedState(successfulOffspringAnalyzer, false);
    556572    }
    557573    private SASEGASAMainLoop FindMainLoop(IOperator start) {
  • branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessfulOffspringAnalysis/SuccessfulOffspringAnalyzer.cs

    r5674 r5682  
    3333using HeuristicLab.Analysis;
    3434
    35 namespace HeuristicLab.Algorithms.OffspringSelectionAlgorithm.SuccessProgressAnalysis {
     35namespace HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm {
    3636  /// <summary>
    3737  /// An operator for analyzing the solution diversity in a population.
    3838  /// </summary>
    39   [Item("SuccessProgressAnalyzer", "An operator for analyzing the success progress in a population.")]
     39  [Item("SuccessfulOffspringAnalyzer", "An operator for analyzing certain properties in the successful offspring. The properties to be analyzed can be specified in the CollectedValues parameter.")]
    4040  [StorableClass]
    41   public sealed class SuccessProgressAnalyzer: SingleSuccessorOperator, IAnalyzer {
     41  public sealed class SuccessfulOffspringAnalyzer : SingleSuccessorOperator, IAnalyzer {
    4242    public ValueParameter<StringValue> SuccessfulOffspringFlag {
    4343      get { return (ValueParameter<StringValue>)Parameters["SuccessfulOffspringFlag"]; }
     
    5252    }
    5353
    54     public LookupParameter<IntValue> Generations {
     54    public ILookupParameter<IntValue> GenerationsParameter {
    5555      get { return (LookupParameter<IntValue>)Parameters["Generations"]; }
     56    }
     57
     58    public ValueParameter<IntValue> DepthParameter {
     59      get { return (ValueParameter<IntValue>)Parameters["Depth"]; }
    5660    }
    5761   
    5862    public override IDeepCloneable Clone(Cloner cloner) {
    59       return new SuccessProgressAnalyzer(this, cloner);
     63      return new SuccessfulOffspringAnalyzer(this, cloner);
    6064    }   
    6165    [StorableConstructor]
    62     private SuccessProgressAnalyzer(bool deserializing) : base(deserializing) { }
    63     private SuccessProgressAnalyzer(SuccessProgressAnalyzer original, Cloner cloner) : base(original, cloner) { }
    64     public SuccessProgressAnalyzer()
     66    private SuccessfulOffspringAnalyzer(bool deserializing) : base(deserializing) { }
     67    private SuccessfulOffspringAnalyzer(SuccessfulOffspringAnalyzer original, Cloner cloner) : base(original, cloner) { }
     68    public SuccessfulOffspringAnalyzer()
    6569      : base() {
    66         Parameters.Add(new ValueParameter<StringValue>("SuccessfulOffspringFlag", "Indicates if the individual was successful.", new StringValue("SuccessfulOffspring")));
    67         Parameters.Add(new ValueParameter<ItemCollection<StringValue>>("CollectedValues", "The values that should be collected.", new ItemCollection<StringValue>()));
     70        Parameters.Add(new ValueParameter<StringValue>("SuccessfulOffspringFlag", "The name of the flag which indicates if the individual was successful.", new StringValue("SuccessfulOffspring")));
     71        Parameters.Add(new ValueParameter<ItemCollection<StringValue>>("CollectedValues", "The properties of the successful offspring that should be collected.", new ItemCollection<StringValue>()));
    6872        Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the succedd progress analysis results should be stored."));
    6973        Parameters.Add(new LookupParameter<IntValue>("Generations", "The current number of generations."));
     74        Parameters.Add(new ValueParameter<IntValue>("Depth", "The depth of the individuals in the scope tree.", new IntValue(1)));
    7075    }
    7176
    7277    public override IOperation Apply() {
    7378      ResultCollection results = ResultsParameter.ActualValue;
    74      
     79
     80      List<IScope> scopes = new List<IScope>() { ExecutionContext.Scope };
     81      for (int i = 0; i < DepthParameter.Value.Value; i++)
     82        scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b)).ToList();
     83
    7584      ItemCollection<StringValue> collectedValues = CollectedValues.Value;
    7685        foreach (StringValue collected in collectedValues) {
     86          //collect the values of the successful offspring
    7787          Dictionary<String, int> counts = new Dictionary<String, int>();
    78           for (int i = 0; i < ExecutionContext.Scope.SubScopes.Count; i++) {
    79             IScope child = ExecutionContext.Scope.SubScopes[i];
     88          for (int i = 0; i < scopes.Count; i++) {
     89            IScope child = scopes[i];
    8090            string successfulOffspringFlag = SuccessfulOffspringFlag.Value.Value;
    8191            if (child.Variables.ContainsKey(collected.Value) &&
     
    92102          }
    93103
     104          //create a data table containing the collected values
    94105          DataTable successProgressAnalysis;
    95106          string resultKey = "Success Progress " + collected.Value;
     
    111122            if (!successProgressAnalysis.Rows.ContainsKey(value)) {
    112123              row = new DataRow(value);
    113               int iterations = Generations.ActualValue.Value;
     124              int iterations = GenerationsParameter.ActualValue.Value;
    114125
     126              //fill up all values seen the first time
    115127              for (int i = 1; i < iterations; i++)
    116128                row.Values.Add(0);
     
    124136          }
    125137
     138          //fill up all values that are not present in the current generation
    126139          foreach (DataRow row in successProgressAnalysis.Rows) {
    127140            if (!counts.ContainsKey(row.Name))
  • branches/SuccessProgressAnalysis/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs

    r5492 r5682  
    4949      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
    5050    }
    51     public ValueParameter<BoolValue> ReportExecutedOperatorParameter {
    52       get { return (ValueParameter<BoolValue>)Parameters["ReportExecutedOperator"]; }
     51    public ValueParameter<BoolValue> TraceSelectedOperatorParameter {
     52      get { return (ValueParameter<BoolValue>)Parameters["TraceSelectedOperator"]; }
    5353    }
    54     public ValueLookupParameter<StringValue> ExecutedOperatorParameter {
    55       get { return (ValueLookupParameter<StringValue>)Parameters["ExecutedOperator"]; }
     54    public ValueLookupParameter<StringValue> SelectedOperatorParameter {
     55      get { return (ValueLookupParameter<StringValue>)Parameters["SelectedOperator"]; }
    5656    }
    5757
     
    6464    private void AfterDeserializationHook() {
    6565      #region Backwards Compatibility
    66       if (!Parameters.ContainsKey("ExecutedOperator")) {
    67         Parameters.Add(new ValueLookupParameter<StringValue>("ExecutedOperator", "The operator that was executed."));
     66      if (!Parameters.ContainsKey("SelectedOperator")) {
     67        Parameters.Add(new ValueLookupParameter<StringValue>("SelectedOperator", "If the TraceSelectedOperator flag is set, the name of the operator is traced in this parameter."));
    6868      }
    69       if (!Parameters.ContainsKey("ReportExecutedOperator")) {
    70         Parameters.Add(new ValueParameter<BoolValue>("ReportExecutedOperator", "Report the executed operator", new BoolValue(false)));
     69      if (!Parameters.ContainsKey("TraceSelectedOperator")) {
     70        Parameters.Add(new ValueParameter<BoolValue>("TraceSelectedOperator", "Indicates, if the selected operator should be traced.", new BoolValue(false)));
    7171      }
    7272      #endregion
     
    8686      Parameters.Add(new ValueLookupParameter<DoubleArray>("Probabilities", "The array of relative probabilities for each operator.", new DoubleArray()));
    8787      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
    88       Parameters.Add(new ValueLookupParameter<StringValue>("ExecutedOperator", "The operator that was executed."));
    89       Parameters.Add(new ValueParameter<BoolValue>("ReportExecutedOperator", "Report the executed operator", new BoolValue(false)));
     88      Parameters.Add(new ValueLookupParameter<StringValue>("SelectedOperator", "If the TraceSelectedOperator flag is set, the name of the operator is traced in this parameter."));
     89      Parameters.Add(new ValueParameter<BoolValue>("TraceSelectedOperator", "Indicates, if the selected operator should be traced.", new BoolValue(false)));
    9090    }
    9191
     
    136136      }
    137137      IOperator successor = null;
     138      int index = -1;
    138139      var checkedOperators = Operators.CheckedItems;
    139140      if (checkedOperators.Count() > 0) {
     
    147148          if (sum > r) {
    148149            successor = indexedItem.Value;
     150            index = indexedItem.Index;
    149151            break;
    150152          }
     
    153155      OperationCollection next = new OperationCollection(base.Apply());
    154156      if (successor != null) {
    155         if(ReportExecutedOperatorParameter.Value.Value)
    156           ExecutedOperatorParameter.ActualValue = new StringValue(successor.Name);
     157        if (TraceSelectedOperatorParameter.Value.Value)
     158          SelectedOperatorParameter.ActualValue = new StringValue(index + ": " + successor.Name);
    157159
    158160        if (CreateChildOperation)
     
    160162        else next.Insert(0, ExecutionContext.CreateOperation(successor));
    161163      } else {
    162         if (ReportExecutedOperatorParameter.Value.Value)
    163           ExecutedOperatorParameter.ActualValue = new StringValue("");
     164        if (TraceSelectedOperatorParameter.Value.Value)
     165          SelectedOperatorParameter.ActualValue = new StringValue("");
    164166      }
    165167      return next;
  • branches/SuccessProgressAnalysis/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs

    r5493 r5682  
    156156      OperationCollection next = new OperationCollection(successorOp);
    157157      if (successor != null) {
    158         ExecutedOperatorParameter.ActualValue = new StringValue(successor.GetType().Name);
     158        SelectedOperatorParameter.ActualValue = new StringValue(successor.GetType().Name);
    159159
    160160        if (CreateChildOperation)
     
    162162        else next.Insert(0, ExecutionContext.CreateOperation(successor));
    163163      } else {
    164         ExecutedOperatorParameter.ActualValue = new StringValue("");
     164        SelectedOperatorParameter.ActualValue = new StringValue("");
    165165      }
    166166
  • branches/SuccessProgressAnalysis/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs

    r5493 r5682  
    156156      OperationCollection next = new OperationCollection(successorOp);
    157157      if (successor != null) {
    158         ExecutedOperatorParameter.ActualValue = new StringValue(successor.GetType().Name);
     158        SelectedOperatorParameter.ActualValue = new StringValue(successor.GetType().Name);
    159159
    160160        if (CreateChildOperation)
     
    162162        else next.Insert(0, ExecutionContext.CreateOperation(successor));
    163163      } else {
    164         ExecutedOperatorParameter.ActualValue = new StringValue("");
     164        SelectedOperatorParameter.ActualValue = new StringValue("");
    165165      }
    166166
Note: See TracChangeset for help on using the changeset viewer.