Changeset 14555 for branches/jschiess

Timestamp:

01/10/17 18:03:16 (8 years ago)

Author:

jschiess

Message:

#1836 SA reheating strategies: Refactoring, Added Connolly Reheater Operator

Location:

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3

Files:

• AcceptanceRatioReheatingOperator.cs (added)
• ConnollyReheatingOperator.cs (added)
• ConsecutiveRejectionReheatingOperator.cs (added)
• ContinuousReheater.cs (deleted)
• FixedReheater.cs (deleted)
• HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj (modified) (1 diff)
• HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user (added)
• IReheatingOperator.cs (added)
• ISimulatedAnnealingHeatingStrategy.cs (deleted)
• NoReheatingOperator.cs (added)
• SimulatedAnnealing.cs (modified) (7 diffs)
• SimulatedAnnealingImprovementOperator.cs (modified) (1 diff)
• SimulatedAnnealingMainLoop.cs (modified) (4 diffs)
• TemperatureController.cs (modified) (4 diffs)

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj

@@ -114 +114 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ISimulatedAnnealingHeatingStrategy.cs" />
+    <Compile Include="AcceptanceRatioReheatingOperator.cs" />
+    <Compile Include="ConnollyReheatingOperator.cs" />
+    <Compile Include="ConsecutiveRejectionReheatingOperator.cs" />
+    <Compile Include="NoReheatingOperator.cs" />
+    <Compile Include="IReheatingOperator.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="FixedReheater.cs" />
-    <Compile Include="ContinuousReheater.cs" />
     <Compile Include="SimulatedAnnealingImprovementOperator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs

@@ -48 +48 @@
         private const string MoveMakerName = "MoveMaker";
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
         private const string MaximumIterationsName = "MaximumIterations";
         private const string InitialTemperatureName = "InitialTemperature";
@@ -105 +105 @@
             get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
         }
-        public OptionalConstrainedValueParameter<ISimulatedAnnealingHeatingStrategy> HeatingStrategyOperatorParameter
-        {
-            get { return (OptionalConstrainedValueParameter<ISimulatedAnnealingHeatingStrategy>)Parameters[HeatingStrategyOperatorName]; }
+
+        public IConstrainedValueParameter<IReheatingOperator> ReheatingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
         }
 
@@ -159 +160 @@
             set { AnnealingOperatorParameter.Value = value; }
         }
-        public ISimulatedAnnealingHeatingStrategy HeatingStrategyOperator
-        {
-            get { return HeatingStrategyOperatorParameter.Value; }
-            set { HeatingStrategyOperatorParameter.Value = value; }
+
+        public IReheatingOperator ReheatingOperator
+        {
+            get { return ReheatingOperatorParameter.Value; }
+            set { ReheatingOperatorParameter.Value = value; }
         }
 
@@ -215 +217 @@
             Parameters.Add(new ConstrainedValueParameter<IMoveMaker>(MoveMakerName, "The operator used to perform a move."));
             Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator used to cool the temperature."));
-            Parameters.Add(new OptionalConstrainedValueParameter<ISimulatedAnnealingHeatingStrategy>(HeatingStrategyOperatorName, "1The operator used to heat the temperature."));
+            Parameters.Add(new ConstrainedValueParameter<IReheatingOperator>(ReheatingOperatorName, "The operator used to reheat the temperature, if necessary."));
             Parameters.Add(new ValueParameter<IntValue>(MaximumIterationsName, "The maximum number of generations which should be processed.", new IntValue(10000)));
             Parameters.Add(new ValueParameter<DoubleValue>(InitialTemperatureName, "The initial temperature.", new DoubleValue(100)));
@@ -274 +276 @@
             mainLoop.EndTemperatureParameter.ActualName = EndTemperatureName;
             mainLoop.EvaluatedMovesParameter.ActualName = EvaluatedMovesName;
-            mainLoop.HeatingStrategyOperatorParameter.ActualName = HeatingStrategyOperatorParameter.Name;
 
             mainLoop.IterationsParameter.ActualName = IterationsName;
@@ -287 +288 @@
             mainLoop.TemperatureParameter.ActualName = TemperatureName;
 
+            foreach (var op in ApplicationManager.Manager.GetInstances<IReheatingOperator>().OrderBy(x => x.Name))
+            {
+               
+                ReheatingOperatorParameter.ValidValues.Add(op);
+            }
+
             foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
             {
                 AnnealingOperatorParameter.ValidValues.Add(op);
-            }
-
-            foreach (var op in ApplicationManager.Manager.GetInstances<ISimulatedAnnealingHeatingStrategy>().OrderBy(x => x.Name))
-            {
-                HeatingStrategyOperatorParameter.ValidValues.Add(op);
             }
 
@@ -568 +570 @@
                 op.EndValueParameter.Hidden = true;
             }
-            
-            foreach(var op in HeatingStrategyOperatorParameter.ValidValues)
+            foreach (var op in ReheatingOperatorParameter.ValidValues)
             {
                 op.Parameterize();
             }
-
             #endregion
 

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs

@@ -377 +377 @@
       VariableCreator variableCreator = new VariableCreator();
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(loop.IterationsParameter.ActualName, new IntValue(0)));
-
+        
       variableCreator.Successor = loop;
 

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs

@@ -39 +39 @@
         private const string MoveMakerName = "MoveMaker";
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
         private const string MaximumIterationsName = "MaximumIterations";
         private const string LowerTemperatureName = "LowerTemperature";
@@ -114 +114 @@
             get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
         }
-        public IValueLookupParameter<IOperator> HeatingStrategyOperatorParameter
-        {
-            get { return (IValueLookupParameter<IOperator>)Parameters[HeatingStrategyOperatorName]; }
+        public IValueLookupParameter<IOperator> ReheatingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[ReheatingOperatorName]; }
         }
         public IValueLookupParameter<IOperator> AnalyzerParameter
@@ -181 +181 @@
             Parameters.Add(new ValueLookupParameter<IOperator>(MoveMakerName, "The operator that performs a move and updates the quality."));
             Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
-            Parameters.Add(new ValueLookupParameter<IOperator>(HeatingStrategyOperatorName, "The operator that heats the temperature."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
 
             Parameters.Add(new ValueLookupParameter<IOperator>(AnalyzerName, "The operator used to analyze each generation."));
@@ -245 +245 @@
             temperatureController.CoolingParameter.ActualName = CoolingParameter.Name;
             temperatureController.EndTemperatureParameter.ActualName = EndTemperatureParameter.Name;
-            temperatureController.HeatingStrategyOperatorParameter.ActualName = HeatingStrategyOperatorParameter.Name;
+            temperatureController.ReheatingOperatorParameter.ActualName = ReheatingOperatorParameter.Name;
             temperatureController.IsAcceptedParameter.ActualName = IsAcceptedName;
             temperatureController.IterationsParameter.ActualName = IterationsParameter.Name;

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/TemperatureController.cs

@@ -38 +38 @@
     {
         #region Strings
+        private const string ReheatingOperatorName = "ReheatingOperator";
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
         private const string MaximumIterationsName = "MaximumIterations";
         private const string LowerTemperatureName = "LowerTemperature";
@@ -89 +89 @@
             get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
         }
-        public IValueLookupParameter<ISimulatedAnnealingHeatingStrategy> HeatingStrategyOperatorParameter
+        public IValueLookupParameter<IReheatingOperator> ReheatingOperatorParameter
         {
-            get { return (IValueLookupParameter<ISimulatedAnnealingHeatingStrategy>)Parameters[HeatingStrategyOperatorName]; }
+            get { return (IValueLookupParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
         }
         public ILookupParameter<BoolValue> IsAcceptedParameter
@@ -114 +114 @@
             Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
             Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
-            Parameters.Add(new ValueLookupParameter<ISimulatedAnnealingHeatingStrategy>(HeatingStrategyOperatorName, "The operator that heats the temperature."));
+            Parameters.Add(new ValueLookupParameter<IReheatingOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
             Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
             Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
@@ -130 +130 @@
         public override IOperation Apply()
         {
-            var iterations = IterationsParameter.ActualValue.Value;
-            var heatingStrategyOperator = HeatingStrategyOperatorParameter.ActualValue;
-            var accepted = IsAcceptedParameter.ActualValue;
-
-            // if there is no heatingstrategyoperator just do cooling     
-            if (accepted == null || heatingStrategyOperator == null)
-            {
-                CoolingParameter.ActualValue.Value = true;
-            }else
-            {
-                // else, let the heatingstrategyoperator decide if it is time to reheat
-                var acceptances = AcceptanceMemoryParameter.ActualValue;
-                acceptances.Add(accepted);
-                CoolingParameter.ActualValue.Value = !heatingStrategyOperator.
-                    ShouldReheat(CoolingParameter.ActualValue.Value, acceptances);
-            }
-
-            // if we want to cool, use the cooling parameter
-            if (CoolingParameter.ActualValue.Value == true)
-            { 
-                TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, iterations - 1);
-                StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
-                EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
-                return new OperationCollection {
-                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(ReheatingOperatorParameter.ActualValue),
                     base.Apply()
                 };
-            }else
-            {
-                // else just use the heating parameter
-                return new OperationCollection {
-                    ExecutionContext.CreateOperation(HeatingStrategyOperatorParameter.ActualValue),
-                    base.Apply()
-                };
-            }
         }
     }