Changeset 637

Timestamp:

10/08/08 12:39:51 (16 years ago)

Author:

abeham

Message:

[trunk] Redesigned and simplified SimOpt according to ticket #291

Location:

trunk/sources/HeuristicLab.SimOpt

Files:

• DefaultInitializer.cs (deleted)
• DefaultManipulator.cs (deleted)
• HeuristicLab.SimOpt.csproj (modified) (3 diffs)
• HeuristicLabSimOptPlugin.cs (modified) (1 diff)
• NormalDoubleManipulator.cs (deleted)
• NormalIntManipulator.cs (deleted)
• PermutationParameterCyclicCrossover.cs (deleted)
• PermutationParameterOrderCrossover.cs (deleted)
• PermutationParameterPartiallyMatchedCrossover.cs (deleted)
• RandomDoubleInitializer.cs (deleted)
• RandomPermutationInitializer.cs (deleted)
• SimOptCrossoverBase.cs (deleted)
• SimOptCrossoverPreparator.cs (added)
• SimOptDiscreteMultiCrossover.cs (modified) (1 diff)
• SimOptInitializationOperatorBase.cs (deleted)
• SimOptManipulationOperatorBase.cs (deleted)
• SimOptParameterExtractor.cs (modified) (1 diff)
• SimOptParameterPacker.cs (modified) (1 diff)
• SimOptSequentialSubOperatorProcessor.cs (modified) (3 diffs)
• SimOptSinglePointCrossover.cs (modified) (1 diff)
• SimOptSquentialSubOperatorCrossover.cs (modified) (2 diffs)
• Swap2PermutationManipulator.cs (deleted)
• TranslocationPermutationAdaptiveManipulator.cs (deleted)
• TranslocationPermutationManipulator.cs (deleted)
• UniformIntInitializer.cs (deleted)

trunk/sources/HeuristicLab.SimOpt/HeuristicLab.SimOpt.csproj

@@ -50 +50 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="DefaultInitializer.cs" />
-    <Compile Include="DefaultManipulator.cs" />
-    <Compile Include="NormalDoubleManipulator.cs" />
-    <Compile Include="NormalIntManipulator.cs" />
-    <Compile Include="PermutationParameterCyclicCrossover.cs" />
-    <Compile Include="PermutationParameterOrderCrossover.cs" />
-    <Compile Include="PermutationParameterPartiallyMatchedCrossover.cs" />
-    <Compile Include="SimOptCrossoverBase.cs" />
+    <Compile Include="SimOptCrossoverPreparator.cs" />
     <Compile Include="SimOptSequentialSubOperatorProcessor.cs" />
     <Compile Include="SimOptSquentialSubOperatorCrossover.cs" />
-    <Compile Include="Swap2PermutationManipulator.cs" />
-    <Compile Include="RandomDoubleInitializer.cs" />
-    <Compile Include="RandomPermutationInitializer.cs" />
-    <Compile Include="SimOptInitializationOperatorBase.cs" />
-    <Compile Include="SimOptManipulationOperatorBase.cs" />
     <Compile Include="DoubleParameterBoundConstraint.cs" />
     <Compile Include="DoubleParameterBoundConstraintView.cs">
@@ -87 +75 @@
     </Compile>
     <Compile Include="SimOptSinglePointCrossover.cs" />
-    <Compile Include="TranslocationPermutationAdaptiveManipulator.cs" />
-    <Compile Include="TranslocationPermutationManipulator.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="UniformIntInitializer.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -127 +110 @@
       <Name>HeuristicLab.Operators</Name>
     </ProjectReference>
-    <ProjectReference Include="..\HeuristicLab.Permutation\HeuristicLab.Permutation.csproj">
-      <Project>{55FDCFB3-3E8C-4FB0-837C-0CF06BEDED39}</Project>
-      <Name>HeuristicLab.Permutation</Name>
-    </ProjectReference>
     <ProjectReference Include="..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
       <Name>HeuristicLab.PluginInfrastructure</Name>
     </ProjectReference>
-    <ProjectReference Include="..\HeuristicLab.Random\HeuristicLab.Random.csproj">
-      <Project>{47019A74-F7F7-482E-83AA-D3F4F777E879}</Project>
-      <Name>HeuristicLab.Random</Name>
+    <ProjectReference Include="..\HeuristicLab.Selection\HeuristicLab.Selection.csproj">
+      <Project>{F7CF0571-25CB-43D5-8443-0843A1E2861A}</Project>
+      <Name>HeuristicLab.Selection</Name>
     </ProjectReference>
   </ItemGroup>

trunk/sources/HeuristicLab.SimOpt/HeuristicLabSimOptPlugin.cs

@@ -32 +32 @@
   [Dependency(Dependency = "HeuristicLab.Data-3.2")]
   [Dependency(Dependency = "HeuristicLab.Operators-3.2")]
-  [Dependency(Dependency = "HeuristicLab.Random-3.2")]
   [Dependency(Dependency = "HeuristicLab.Constraints-3.2")]
   [Dependency(Dependency = "HeuristicLab.Evolutionary-3.2")]
-  [Dependency(Dependency = "HeuristicLab.Permutation-3.2")]
+  [Dependency(Dependency = "HeuristicLab.Selection-3.2")]
   public class HeuristicLabSimOptPlugin : PluginBase {
   }

trunk/sources/HeuristicLab.SimOpt/SimOptDiscreteMultiCrossover.cs

@@ -26 +26 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
-using HeuristicLab.Random;
 using HeuristicLab.Evolutionary;
 

trunk/sources/HeuristicLab.SimOpt/SimOptParameterExtractor.cs

@@ -31 +31 @@
   public class SimOptParameterExtractor : OperatorBase {
     public override string Description {
-      get { return @"Injects the contents of a ConstrainedItemList into the scope"; }
+      get { return @"Appends each parameter as subscope to the current scope."; }
     }
 
     public SimOptParameterExtractor()
       : base() {
-      AddVariableInfo(new VariableInfo("Items", "The ConstrainedItemList to be extracted", typeof(ConstrainedItemList), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Items", "The ConstrainedItemList to be extracted", typeof(ConstrainedItemList), VariableKind.In | VariableKind.Deleted));
+      AddVariableInfo(new VariableInfo("DeleteItems", "Whether or not to remove items from the current scope", typeof(BoolData), VariableKind.In));
+      AddVariable(new Variable("DeleteItems", new BoolData(false)));
+      GetVariableInfo("DeleteItems").Local = true;
     }
 
     public override IOperation Apply(IScope scope) {
       ConstrainedItemList cil = GetVariableValue<ConstrainedItemList>("Items", scope, false);
+      bool delete = GetVariableValue<BoolData>("DeleteItems", scope, true).Data;
       for (int i = 0; i < cil.Count; i++) {
-        IVariable var = scope.GetVariable(((Variable)cil[i]).Name);
-        if (var == null) scope.AddVariable((IVariable)cil[i].Clone());
-        else var.Value = (IItem)((Variable)cil[i]).Value.Clone();
+        IScope tmp = new Scope(scope.Name + "_Param" + i.ToString());
+        try {
+          scope.AddVariable(cil[i].Clone() as Variable);
+        } catch (InvalidCastException ice) {
+          throw new InvalidCastException("Parameters in the constrained item list have to be encapsulated in a variable!\r\n\r\n" + ice.Message);
+        }
+        scope.AddSubScope(tmp);
+      }
+      if (delete) {
+        IVariableInfo info = GetVariableInfo("Items");
+        if (info.Local) RemoveVariable(info.ActualName);
+        else scope.RemoveVariable(info.ActualName);
       }
       return null;

trunk/sources/HeuristicLab.SimOpt/SimOptParameterPacker.cs

@@ -31 +31 @@
   public class SimOptParameterPacker : OperatorBase {
     public override string Description {
-      get { return @"Updates a ConstrainedItemList with the variables in the scope and removes them afterwards."; }
+      get { return @"Takes the parameters in the subscope and creates or a updates a parameter vector. The order of the subscopes is assumed to be the same as the parameters appear in the vector.
+If the parameter vector could not be updated due to a constraint violation, the first suboperator is returned as the next operation."; }
     }
 
     public SimOptParameterPacker()
       : base() {
-      AddVariableInfo(new VariableInfo("Items", "The ConstrainedItemList to be updated", typeof(ConstrainedItemList), VariableKind.In | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("Items", "The ConstrainedItemList to be updated or created", typeof(ConstrainedItemList), VariableKind.New | VariableKind.In | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("DeleteParameters", "Whether or not the subscopes containing the parameters should be removed afterwards", typeof(BoolData), VariableKind.In));
+      AddVariable(new Variable("DeleteParameters", new BoolData(true)));
+      GetVariableInfo("DeleteParameters").Local = true;
     }
 
     public override IOperation Apply(IScope scope) {
-      ConstrainedItemList cil = GetVariableValue<ConstrainedItemList>("Items", scope, false);
-      for (int i = 0; i < cil.Count; i++) {
-        IVariable var = scope.GetVariable(((Variable)cil[i]).Name);
-        if (var == null) throw new InvalidOperationException("ERROR in SimOptParameterPacker: Cannot find variable " + ((Variable)cil[i]).Name + " in scope");
-        else {
-          ((Variable)cil[i]).Value = (IItem)var.Value.Clone();
-          scope.RemoveVariable(var.Name);
+      // ----- FETCH THE PARAMETER VECTOR ----- //
+      bool updateVector = true;
+      ConstrainedItemList cil;
+      try {
+        cil = GetVariableValue<ConstrainedItemList>("Items", scope, false);
+      } catch (ArgumentException) {
+        updateVector = false;
+        // the parameter vector is fetched from a higher scope and added locally
+        cil = GetVariableValue<ConstrainedItemList>("Items", scope, true);
+      }
+      ConstrainedItemList tempcil = (ConstrainedItemList)cil.Clone();
+      bool delete = GetVariableValue<BoolData>("DeleteParameters", scope, true).Data;
+
+      ICollection<IConstraint> violatedConstraints;
+
+      tempcil.BeginCombinedOperation();
+      // ----- FETCH PARAMETERS AND UPDATE TEMPORARY VECTOR ----- //
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        IVariable var = scope.SubScopes[i].GetVariable(((IVariable)tempcil[i]).Name);
+        if (var == null) throw new ArgumentNullException(scope.SubScopes[i].Name, "Could not find parameter " + ((IVariable)tempcil[i]).Name + " in this scope");
+        tempcil.TrySetAt(i, var, out violatedConstraints);
+      }
+
+      // ----- CONSTRAINT HANDLING ----- //
+      IVariableInfo info = GetVariableInfo("Items");
+      bool error = tempcil.EndCombinedOperation(out violatedConstraints);
+      if (!error) {
+        if (!updateVector) {
+          if (info.Local) AddVariable(new Variable(info.ActualName, tempcil));
+          else scope.AddVariable(new Variable(scope.TranslateName("Items"), tempcil));
+        } else {
+          if (info.Local) GetVariable(info.ActualName).Value = tempcil;
+          else scope.GetVariable(scope.TranslateName("Items")).Value = tempcil;
         }
+      } else if (!updateVector) { // in case there was an error and the parameter vector is not in the current scope, add it
+        if (info.Local) AddVariable(new Variable(info.ActualName, cil));
+        else scope.AddVariable(new Variable(scope.TranslateName("Items"), cil));
       }
-      return null;
+
+      // ----- DELETE SUBSCOPES ----- //
+      if (delete) {
+        scope.SubScopes.Clear();
+      }
+
+      if (error) return new AtomicOperation(SubOperators[0], scope);
+      else return null;
     }
   }

trunk/sources/HeuristicLab.SimOpt/SimOptSequentialSubOperatorProcessor.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Operators;
 
 namespace HeuristicLab.SimOpt {
@@ -31 +32 @@
     public override string Description {
       get {
-        return @"Applies its suboperators on the parameter vector one for each index, afterwards it checks if the parameter vector satisfies all the constraints. If not it restores the old parameter vector and tries again until a maximum amount of tries (default: 100) has been reached.";
+        return @"This operator encapsulates the functionality of processing the parameters of a simulation parameter vector. It works as follows:
+1. The parameters are extracted [SimOptParameterExtractor]
+2. The parameters are processed [SequentialSubScopeProcessor which applies the SubOperators of this operator on each parameter]
+3. The parameters are updated again [SimOptParameterPacker]
+
+Should the packing fail due to constraint violations, the operator will retry as often as specified in the variable MaximumTries.";
       }
     }
@@ -42 +48 @@
       GetVariableInfo("MaximumTries").Local = true;
       AddVariable(new Variable("MaximumTries", new IntData(100)));
-      AddVariable(new Variable("Tries", new IntData(0)));
+      AddVariable(new Variable("Tries", new IntData(1)));
     }
 
     public override IOperation Apply(IScope scope) {
-      ConstrainedItemList parameterVector = GetVariableValue<ConstrainedItemList>("Items", scope, false, false);
-      // Mode: The parameter vector does not yet exist in the current scope
-      if (parameterVector == null) { // the parameter does not yet exist in the current scope
-        parameterVector = GetVariableValue<ConstrainedItemList>("Items", scope, true); // search for it
-        parameterVector = (ConstrainedItemList)parameterVector.Clone(); // clone it
-        scope.AddVariable(new Variable(scope.TranslateName("Items"), parameterVector)); // and add it to the current scope
+
+      int tries = (GetVariable("Tries").Value as IntData).Data;
+      int maxTries = GetVariableValue<IntData>("MaximumTries", scope, true).Data;
+
+      IVariableInfo itemsInfo = GetVariableInfo("Items");
+      SimOptParameterExtractor extractor = new SimOptParameterExtractor();
+      extractor.GetVariableInfo("Items").ActualName = itemsInfo.ActualName;
+
+      SequentialSubScopesProcessor sssp = new SequentialSubScopesProcessor();
+      foreach (IOperator op in SubOperators)
+        sssp.AddSubOperator(op);
+
+      SimOptParameterPacker packer = new SimOptParameterPacker();
+      packer.GetVariableInfo("Items").ActualName = itemsInfo.ActualName;
+      if (tries < maxTries) {
+        SimOptSequentialSubOperatorProcessor sssop = (SimOptSequentialSubOperatorProcessor)this.Clone();
+        (sssop.GetVariable("Tries").Value as IntData).Data = tries + 1;
+        packer.AddSubOperator(this);
       }
-      // Mode: The parameter vector is marked for manipulation/initialization (constraint check is suspended)
-      if (parameterVector.ConstraintCheckSuspended) {
-        ICollection<IConstraint> violatedConstraints;
-        if (parameterVector.EndCombinedOperation(out violatedConstraints)) {
-          ((IntData)GetVariable("Tries").Value).Data = 0;
-          GetVariable("ItemsBackup").Value = new NullData();
-          return null; // manipulation/initialization was successful
-        } else { // restore old vector
-          int maximumTries = GetVariableValue<IntData>("MaximumTries", scope, true).Data;
-          IntData tries = (GetVariable("Tries").Value as IntData);
-          if (tries.Data >= maximumTries) throw new InvalidOperationException("ERROR: no valid solution in " + maximumTries.ToString() + " tries");
-          parameterVector = (ConstrainedItemList)GetVariable("ItemsBackup").Value;
-          scope.GetVariable(scope.TranslateName("Items")).Value = parameterVector;
-          ((IntData)GetVariable("Tries").Value).Data++;
-        }
-      }
-      // perform the sub operators in sequential order on the indices of the parameter vector
-      GetVariable("ItemsBackup").Value = (ConstrainedItemList)parameterVector.Clone();
-      CompositeOperation co = new CompositeOperation();
-      for (int i = 0; i < SubOperators.Count; i++) {
-        if (SubOperators[i].GetVariable("Index") != null) {
-          SubOperators[i].GetVariable("Index").Value = new IntData(i);
-        }
-        if (SubOperators[i].GetVariableInfo("Items") != null) {
-          SubOperators[i].GetVariableInfo("Items").ActualName = GetVariableInfo("Items").ActualName;
-        }
-      }
-      for (int i = 0; i < SubOperators.Count; i++)
-        co.AddOperation(new AtomicOperation(SubOperators[i], scope));
-      // add self to check if the manipulation/initialization did not violate any constraints
-      co.AddOperation(new AtomicOperation(this, scope));
-      parameterVector.BeginCombinedOperation();
-      return co;
+
+      CompositeOperation operation = new CompositeOperation();
+      operation.AddOperation(new AtomicOperation(extractor, scope));
+      operation.AddOperation(new AtomicOperation(sssp, scope));
+      operation.AddOperation(new AtomicOperation(packer, scope));
+
+      return operation;
     }
   }

trunk/sources/HeuristicLab.SimOpt/SimOptSinglePointCrossover.cs

@@ -26 +26 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
-using HeuristicLab.Random;
 using HeuristicLab.Evolutionary;
 

trunk/sources/HeuristicLab.SimOpt/SimOptSquentialSubOperatorCrossover.cs

@@ -24 +24 @@
 using System.Linq;
 using System.Text;
+using System.Xml;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Evolutionary;
+using HeuristicLab.Operators;
+using HeuristicLab.Selection;
 
 namespace HeuristicLab.SimOpt {
   public class SimOptSquentialSubOperatorCrossover : OperatorBase {
+    private UniformSequentialSubScopesProcessor usssp, usssp2, usssp3, usssp4;
+    private SequentialSubScopesProcessor sssp;
+    private SimOptParameterExtractor extractor;
+    private SimOptParameterPacker packer;
+    private SimOptCrossoverPreparator preparator;
+    private MergingReducer merger;
+    private bool uptodate;
+
     public override string Description {
-      get { return @"Takes the parameter vector of two items and on each index applies the respectively indexed suboperator"; }
+      get {
+        return @"This operator encapsulates the functionality of crossing the parameters of a simulation parameter vector. It works as follows:
+1. The parameters of all parents are extracted [UniformSequentialSubScopeProcessor which applies a SimOptParameterExtractor]
+2. The parents are prepared for crossing by grouping the respective parameters [SimOptCrossoverPreparator]
+3. The parameters are crossed [UniformSequentialSubScopeProcessor which applies SequentialSubScopeProcessor which applies the SubOperators of this operator on each parameter group (except for the last one)]
+4. Assigning the crossed parameters to the respective children [MergingReducer]
+5. Update the parameters [UniformSequentialSubScopeProcessor which applies SimOptParameterPacker]
+
+Should the packing fail due to constraint violations, the operator will execute the last of its suboperators.";
+      }
     }
 
@@ -38 +57 @@
       AddVariableInfo(new VariableInfo("Items", "The parameter vector", typeof(ConstrainedItemList), VariableKind.In | VariableKind.New));
       AddVariableInfo(new VariableInfo("Parents", "The number of parents per child", typeof(IntData), VariableKind.In));
+      uptodate = false;
     }
 
     public override IOperation Apply(IScope scope) {
-      int parents = GetVariableValue<IntData>("Parents", scope, true).Data;
+      string itemsActualName = GetVariableInfo("Items").ActualName;
+      string parentsActualName = GetVariableInfo("Parents").ActualName;
+      int parameters = SubOperators.Count - 1;
 
-      int subScopesCount = scope.SubScopes.Count;
-      if (subScopesCount < parents || (subScopesCount % parents) != 0)
-        throw new InvalidOperationException("Size of mating pool is not a multiple (>1) of the number of parents per child");
-      int children = subScopesCount / parents;
+      if (!uptodate) {
+        usssp = new UniformSequentialSubScopesProcessor();
+        extractor = new SimOptParameterExtractor();
+        usssp.AddSubOperator(extractor);
+
+        preparator = new SimOptCrossoverPreparator();
+
+        usssp2 = new UniformSequentialSubScopesProcessor();
+        sssp = new SequentialSubScopesProcessor();
+        for (int i = 0; i < parameters; i++) {
+          sssp.AddSubOperator(SubOperators[i]);
+        }
+        usssp2.AddSubOperator(sssp);
+
+        usssp3 = new UniformSequentialSubScopesProcessor();
+        merger = new MergingReducer();
+        usssp3.AddSubOperator(merger);
+
+        usssp4 = new UniformSequentialSubScopesProcessor();
+        packer = new SimOptParameterPacker();
+        packer.AddSubOperator(SubOperators[SubOperators.Count - 1]);
+        usssp4.AddSubOperator(packer);
+        uptodate = true;
+      }
+      // Setting the actual names is necessary as the operator does not know if they've changed
+      extractor.GetVariableInfo("Items").ActualName = itemsActualName;
+      preparator.GetVariableInfo("Parents").ActualName = parentsActualName;
+      packer.GetVariableInfo("Items").ActualName = itemsActualName;
 
       CompositeOperation co = new CompositeOperation();
-      for (int i = 0; i < SubOperators.Count; i++) {
-        if (SubOperators[i].GetVariable("Index") != null) {
-          SubOperators[i].GetVariable("Index").Value = new IntData(i);
-        }
-        if (SubOperators[i].GetVariableInfo("Items") != null) {
-          SubOperators[i].GetVariableInfo("Items").ActualName = GetVariableInfo("Items").ActualName;
-        }
-      }
-      for (int i = 0; i < children; i++) {
-        IScope child = (IScope)scope.SubScopes[0].Clone();
-        for (int j = 0; j < parents; j++) {
-          IScope parent = scope.SubScopes[0];
-          child.AddSubScope(parent);
-          scope.RemoveSubScope(parent);
-        }
-        scope.AddSubScope(child);
-        for (int n = 0 ; n < SubOperators.Count ; n++)
-          co.AddOperation(new AtomicOperation(SubOperators[n], child));
-        co.AddOperation(new AtomicOperation(new Operators.SubScopesRemover(), child));
-      }
+      co.AddOperation(new AtomicOperation(usssp, scope));
+      co.AddOperation(new AtomicOperation(preparator, scope));
+      co.AddOperation(new AtomicOperation(usssp2, scope));
+      co.AddOperation(new AtomicOperation(usssp3, scope));
+      co.AddOperation(new AtomicOperation(usssp4, scope));
       return co;
+    }
+
+    protected override void OnSubOperatorAdded(IOperator subOperator, int index) {
+      base.OnSubOperatorAdded(subOperator, index);
+      uptodate = false;
+    }
+
+    protected override void OnSubOperatorRemoved(IOperator subOperator, int index) {
+      base.OnSubOperatorRemoved(subOperator, index);
+      uptodate = false;
+    }
+
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
+      base.Populate(node, restoredObjects);
+      uptodate = false;
     }
   }