Changeset 14029 for branches/crossvalidation-2434/HeuristicLab.Optimization.Operators

Timestamp:

07/08/16 14:40:02 (8 years ago)

Author:

gkronber

Message:

#2434: merged trunk changes r12934:14026 from trunk to branch

Location:

branches/crossvalidation-2434

Files:

• . (modified) (1 prop)
• HeuristicLab.Optimization.Operators/3.3/ChildrenCopyCreator.cs (copied) (copied from trunk/sources/HeuristicLab.Optimization.Operators/3.3/ChildrenCopyCreator.cs)
• HeuristicLab.Optimization.Operators/3.3/HeuristicLab.Optimization.Operators-3.3.csproj (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/MultiObjective/RankAndCrowdingSorter.cs (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/Plugin.cs.frame (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/Properties/AssemblyInfo.cs.frame (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs (modified) (4 diffs)
• HeuristicLab.Optimization.Operators/3.3/UnidirectionalRingMigrator.cs (modified) (5 diffs)

branches/crossvalidation-2434/HeuristicLab.Optimization.Operators/3.3/HeuristicLab.Optimization.Operators-3.3.csproj

@@ -115 +115 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ChildrenCopyCreator.cs" />
     <Compile Include="ExpressionCalculator.cs" />
     <Compile Include="NoSimilarityCalculator.cs" />

branches/crossvalidation-2434/HeuristicLab.Optimization.Operators/3.3/MultiObjective/RankAndCrowdingSorter.cs

@@ -29 +29 @@
 
 namespace HeuristicLab.Optimization.Operators {
+  [StorableClass]
   public class RankAndCrowdingSorter : AlgorithmOperator, IMultiObjectiveOperator {
     #region Parameter properties

branches/crossvalidation-2434/HeuristicLab.Optimization.Operators/3.3/Plugin.cs.frame

@@ -26 +26 @@
   /// Plugin class for HeuristicLab.Optimization.Operators plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Optimization.Operators", "3.3.12.$WCREV$")]
+  [Plugin("HeuristicLab.Optimization.Operators", "3.3.13.$WCREV$")]
   [PluginFile("HeuristicLab.Optimization.Operators-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]

branches/crossvalidation-2434/HeuristicLab.Optimization.Operators/3.3/Properties/AssemblyInfo.cs.frame

@@ -54 +54 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.12.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.13.$WCREV$")]

branches/crossvalidation-2434/HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs

@@ -22 +22 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -41 +42 @@
     [Storable]
     public string QualityVariableName { get; set; }
+    [Storable]
+    public bool ExecuteInParallel { get; set; }
+    [Storable]
+    public int MaxDegreeOfParallelism { get; set; }
     #endregion
 
@@ -48 +53 @@
     protected SolutionSimilarityCalculator(SolutionSimilarityCalculator original, Cloner cloner)
       : base(original, cloner) {
-      this.SolutionVariableName = original.SolutionVariableName;
-      this.QualityVariableName = original.QualityVariableName;
-    }
-    protected SolutionSimilarityCalculator() : base() { }
+      SolutionVariableName = original.SolutionVariableName;
+      QualityVariableName = original.QualityVariableName;
+      ExecuteInParallel = original.ExecuteInParallel;
+      MaxDegreeOfParallelism = original.MaxDegreeOfParallelism;
+    }
+
+    protected SolutionSimilarityCalculator() : base() {
+      ExecuteInParallel = false;
+      MaxDegreeOfParallelism = -1;
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (MaxDegreeOfParallelism == 0) {
+        ExecuteInParallel = false;
+        MaxDegreeOfParallelism = -1;
+      }
+    }
 
     public double[][] CalculateSolutionCrowdSimilarity(IScope leftSolutionCrowd, IScope rightSolutionCrowd) {
@@ -75 +94 @@
 
     public double[][] CalculateSolutionCrowdSimilarity(IScope solutionCrowd) {
-      if (solutionCrowd == null)
+      if (solutionCrowd == null) {
         throw new ArgumentException("Cannot calculate similarity because the provided crowd is null.");
-
+      }
       var individuals = solutionCrowd.SubScopes;
 
-      if (!individuals.Any())
+      if (!individuals.Any()) {
         throw new ArgumentException("Cannot calculate similarity because the provided crowd is empty.");
+      }
 
       var similarityMatrix = new double[individuals.Count][];
-      for (int i = 0; i < individuals.Count; i++) similarityMatrix[i] = new double[individuals.Count];
-
-      if (IsCommutative) {
-        for (int i = 0; i < individuals.Count; i++) {
-          for (int j = i; j < individuals.Count; j++) {
-            similarityMatrix[i][j] = similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+      for (int i = 0; i < individuals.Count; i++) {
+        similarityMatrix[i] = new double[individuals.Count];
+      }
+
+      if (ExecuteInParallel) {
+        var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = MaxDegreeOfParallelism };
+        if (IsCommutative) {
+          Parallel.For(0, individuals.Count, parallelOptions, i => {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] =
+                similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+            }
+          });
+        } else {
+          Parallel.For(0, individuals.Count, parallelOptions, i => {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+              if (i == j) continue;
+              similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+            }
+          });
+        }
+      } else {
+        if (IsCommutative) {
+          for (int i = 0; i < individuals.Count; i++) {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] =
+                similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+            }
           }
-        }
-      } else {
-        for (int i = 0; i < individuals.Count; i++) {
-          for (int j = i; j < individuals.Count; j++) {
-            similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
-            if (i == j) continue;
-            similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+        } else {
+          for (int i = 0; i < individuals.Count; i++) {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+              if (i == j) continue;
+              similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+            }
           }
         }

branches/crossvalidation-2434/HeuristicLab.Optimization.Operators/3.3/UnidirectionalRingMigrator.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -33 +35 @@
   [StorableClass]
   public class UnidirectionalRingMigrator : SingleSuccessorOperator, IMigrator {
+    public IValueLookupParameter<BoolValue> ClockwiseMigrationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["ClockwiseMigration"]; }
+    }
+
     [StorableConstructor]
     protected UnidirectionalRingMigrator(bool deserializing) : base(deserializing) { }
     protected UnidirectionalRingMigrator(UnidirectionalRingMigrator original, Cloner cloner) : base(original, cloner) { }
-    public UnidirectionalRingMigrator() : base() { }
 
+    public UnidirectionalRingMigrator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ClockwiseMigration", "True to migrate individuals clockwise, false to migrate individuals counterclockwise.", new BoolValue(true)));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code (remove with 3.4)
+      if (!Parameters.ContainsKey("ClockwiseMigration")) {
+        Parameters.Add(new ValueLookupParameter<BoolValue>("ClockwiseMigration", "True to migrate individuals clockwise, false to migrate individuals counterclockwise.", new BoolValue(false)));
+      }
+      #endregion
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new UnidirectionalRingMigrator(this, cloner);
@@ -43 +62 @@
 
     /// <summary>
-    /// Migrates every first sub scope of each child to its left neighbour (like a ring).
-    /// <pre>                                                               
+    /// Migrates every first sub scope of each child to its right or left neighbour (like a ring).
+    /// If clockwise migration (default) is used the selected scopes A D G becomes G A D, contrary to counterclockwise where A D G becomes D G A.
+    /// <pre>
     ///          __ scope __              __ scope __
     ///         /     |     \            /     |     \
@@ -56 +76 @@
     /// <returns>The next operation.</returns>
     public override IOperation Apply() {
+      bool clockwise = ClockwiseMigrationParameter.ActualValue.Value;
       IScope scope = ExecutionContext.Scope;
       List<IScope> emigrantsList = new List<IScope>();
@@ -65 +86 @@
       }
 
-      // shift first emigrants to end of list
-      emigrantsList.Add(emigrantsList[0]);
-      emigrantsList.RemoveAt(0);
+      if (clockwise) {
+        // shift last emigrants to start of list
+        emigrantsList.Insert(0, emigrantsList[emigrantsList.Count - 1]);
+        emigrantsList.RemoveAt(emigrantsList.Count - 1);
+      } else {
+        // shift first emigrants to end of list
+        emigrantsList.Add(emigrantsList[0]);
+        emigrantsList.RemoveAt(0);
+      }
 
       for (int i = 0; i < scope.SubScopes.Count; i++)