#region License Information
/* HeuristicLab
* Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
*
* This file is part of HeuristicLab.
*
* HeuristicLab is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* HeuristicLab is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with HeuristicLab. If not, see .
*/
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Optimization.Operators;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Random;
namespace HeuristicLab.Algorithms.SimulatedAnnealing {
[Item("Simulated Annealing", "A simulated annealing algorithm.")]
[Creatable("Algorithms")]
[StorableClass]
public sealed class SimulatedAnnealing : EngineAlgorithm {
#region Problem Properties
public override Type ProblemType {
get { return typeof(ISingleObjectiveProblem); }
}
public new ISingleObjectiveProblem Problem {
get { return (ISingleObjectiveProblem)base.Problem; }
set { base.Problem = value; }
}
#endregion
#region Parameter Properties
private ValueParameter SeedParameter {
get { return (ValueParameter)Parameters["Seed"]; }
}
private ValueParameter SetSeedRandomlyParameter {
get { return (ValueParameter)Parameters["SetSeedRandomly"]; }
}
private ConstrainedValueParameter MoveGeneratorParameter {
get { return (ConstrainedValueParameter)Parameters["MoveGenerator"]; }
}
private ConstrainedValueParameter MoveMakerParameter {
get { return (ConstrainedValueParameter)Parameters["MoveMaker"]; }
}
private ConstrainedValueParameter MoveEvaluatorParameter {
get { return (ConstrainedValueParameter)Parameters["MoveEvaluator"]; }
}
private ConstrainedValueParameter AnnealingOperatorParameter {
get { return (ConstrainedValueParameter)Parameters["AnnealingOperator"]; }
}
private ValueParameter MaximumIterationsParameter {
get { return (ValueParameter)Parameters["MaximumIterations"]; }
}
private ValueParameter InnerIterationsParameter {
get { return (ValueParameter)Parameters["InnerIterations"]; }
}
private ValueParameter StartTemperatureParameter {
get { return (ValueParameter)Parameters["StartTemperature"]; }
}
private ValueParameter EndTemperatureParameter {
get { return (ValueParameter)Parameters["EndTemperature"]; }
}
private ValueParameter AnalyzerParameter {
get { return (ValueParameter)Parameters["Analyzer"]; }
}
#endregion
#region Properties
public IntValue Seed {
get { return SeedParameter.Value; }
set { SeedParameter.Value = value; }
}
public BoolValue SetSeedRandomly {
get { return SetSeedRandomlyParameter.Value; }
set { SetSeedRandomlyParameter.Value = value; }
}
public IMultiMoveGenerator MoveGenerator {
get { return MoveGeneratorParameter.Value; }
set { MoveGeneratorParameter.Value = value; }
}
public IMoveMaker MoveMaker {
get { return MoveMakerParameter.Value; }
set { MoveMakerParameter.Value = value; }
}
public ISingleObjectiveMoveEvaluator MoveEvaluator {
get { return MoveEvaluatorParameter.Value; }
set { MoveEvaluatorParameter.Value = value; }
}
public IntValue MaximumIterations {
get { return MaximumIterationsParameter.Value; }
set { MaximumIterationsParameter.Value = value; }
}
public IntValue InnerIterations {
get { return InnerIterationsParameter.Value; }
set { InnerIterationsParameter.Value = value; }
}
public DoubleValue StartTemperature {
get { return StartTemperatureParameter.Value; }
set { StartTemperatureParameter.Value = value; }
}
public DoubleValue EndTemperature {
get { return EndTemperatureParameter.Value; }
set { EndTemperatureParameter.Value = value; }
}
public MultiAnalyzer Analyzer {
get { return AnalyzerParameter.Value; }
set { AnalyzerParameter.Value = value; }
}
private RandomCreator RandomCreator {
get { return (RandomCreator)OperatorGraph.InitialOperator; }
}
private SolutionsCreator SolutionsCreator {
get { return (SolutionsCreator)RandomCreator.Successor; }
}
private SimulatedAnnealingMainLoop MainLoop {
get { return (SimulatedAnnealingMainLoop)SolutionsCreator.Successor; }
}
[Storable]
private QualityAnalyzer qualityAnalyzer;
#endregion
[StorableConstructor]
private SimulatedAnnealing(bool deserializing) : base(deserializing) { }
public SimulatedAnnealing()
: base() {
Parameters.Add(new ValueParameter("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ConstrainedValueParameter("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
Parameters.Add(new ConstrainedValueParameter("MoveEvaluator", "The operator used to evaluate a move."));
Parameters.Add(new ConstrainedValueParameter("MoveMaker", "The operator used to perform a move."));
Parameters.Add(new ConstrainedValueParameter("AnnealingOperator", "The operator used to modify the temperature."));
Parameters.Add(new ValueParameter("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(100)));
Parameters.Add(new ValueParameter("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again).", new IntValue(10)));
Parameters.Add(new ValueParameter("StartTemperature", "The initial temperature.", new DoubleValue(100)));
Parameters.Add(new ValueParameter("EndTemperature", "The final temperature which should be reached when iterations reaches maximum iterations.", new DoubleValue(1e-6)));
Parameters.Add(new ValueParameter("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
RandomCreator randomCreator = new RandomCreator();
SolutionsCreator solutionsCreator = new SolutionsCreator();
SimulatedAnnealingMainLoop mainLoop = new SimulatedAnnealingMainLoop();
OperatorGraph.InitialOperator = randomCreator;
randomCreator.RandomParameter.ActualName = "Random";
randomCreator.SeedParameter.ActualName = SeedParameter.Name;
randomCreator.SeedParameter.Value = null;
randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
randomCreator.SetSeedRandomlyParameter.Value = null;
randomCreator.Successor = solutionsCreator;
solutionsCreator.NumberOfSolutions = new IntValue(1);
solutionsCreator.Successor = mainLoop;
mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
mainLoop.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
mainLoop.StartTemperatureParameter.ActualName = StartTemperatureParameter.Name;
mainLoop.EndTemperatureParameter.ActualName = EndTemperatureParameter.Name;
mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
mainLoop.ResultsParameter.ActualName = "Results";
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances().OrderBy(x => x.Name))
AnnealingOperatorParameter.ValidValues.Add(op);
ParameterizeAnnealingOperators();
qualityAnalyzer = new QualityAnalyzer();
ParameterizeAnalyzers();
UpdateAnalyzers();
Initialize();
}
public override IDeepCloneable Clone(Cloner cloner) {
SimulatedAnnealing clone = (SimulatedAnnealing)base.Clone(cloner);
clone.qualityAnalyzer = (QualityAnalyzer)cloner.Clone(qualityAnalyzer);
clone.Initialize();
return clone;
}
public override void Prepare() {
if (Problem != null && MoveGenerator != null && MoveMaker != null && MoveEvaluator != null)
base.Prepare();
}
#region Events
protected override void OnProblemChanged() {
ParameterizeStochasticOperator(Problem.SolutionCreator);
ParameterizeStochasticOperator(Problem.Evaluator);
foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType()) {
op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
}
ParameterizeSolutionsCreator();
ParameterizeMainLoop();
UpdateMoveGenerator();
UpdateMoveParameters();
UpdateAnalyzers();
ParameterizeMoveEvaluators();
ParameterizeMoveMakers();
ParameterizeMoveGenerators();
ParameterizeAnalyzers();
ParameterizeIterationBasedOperators();
Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
base.OnProblemChanged();
}
protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
ParameterizeStochasticOperator(Problem.SolutionCreator);
ParameterizeSolutionsCreator();
base.Problem_SolutionCreatorChanged(sender, e);
}
protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
ParameterizeStochasticOperator(Problem.Evaluator);
ParameterizeSolutionsCreator();
ParameterizeMainLoop();
ParameterizeMoveEvaluators();
ParameterizeMoveMakers();
ParameterizeAnalyzers();
Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
base.Problem_EvaluatorChanged(sender, e);
}
protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
// This may seem pointless, but some operators already have the eventhandler registered, others don't
// FIXME: Is there another way to solve this problem?
foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType()) {
op.MoveQualityParameter.ActualNameChanged -= new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
}
UpdateMoveGenerator();
UpdateMoveParameters();
UpdateAnalyzers();
ParameterizeMainLoop();
ParameterizeMoveEvaluators();
ParameterizeMoveMakers();
ParameterizeMoveGenerators();
ParameterizeIterationBasedOperators();
base.Problem_OperatorsChanged(sender, e);
}
private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
ParameterizeMainLoop();
ParameterizeMoveEvaluators();
ParameterizeMoveMakers();
ParameterizeAnalyzers();
}
private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e) {
UpdateMoveParameters();
}
private void MoveEvaluatorParameter_ValueChanged(object sender, EventArgs e) {
ParameterizeMainLoop();
ParameterizeMoveEvaluators();
ParameterizeMoveMakers();
}
private void MoveEvaluator_MoveQualityParameter_ActualNameChanged(object sender, EventArgs e) {
ParameterizeMainLoop();
ParameterizeMoveEvaluators();
ParameterizeMoveMakers();
}
#endregion
#region Helpers
[StorableHook(HookType.AfterDeserialization)]
private void Initialize() {
if (Problem != null) {
Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType()) {
op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
}
}
MoveGeneratorParameter.ValueChanged += new EventHandler(MoveGeneratorParameter_ValueChanged);
MoveEvaluatorParameter.ValueChanged += new EventHandler(MoveEvaluatorParameter_ValueChanged);
}
private void UpdateMoveGenerator() {
IMultiMoveGenerator oldMoveGenerator = MoveGenerator;
MoveGeneratorParameter.ValidValues.Clear();
if (Problem != null) {
foreach (IMultiMoveGenerator generator in Problem.Operators.OfType().OrderBy(x => x.Name))
MoveGeneratorParameter.ValidValues.Add(generator);
}
if (oldMoveGenerator != null) {
IMultiMoveGenerator newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
}
if (MoveGenerator == null) {
ClearMoveParameters();
}
}
private void ParameterizeAnalyzers() {
qualityAnalyzer.ResultsParameter.ActualName = "Results";
if (Problem != null) {
qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
qualityAnalyzer.QualityParameter.Depth = 0;
qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
}
}
private void UpdateMoveParameters() {
IMoveMaker oldMoveMaker = MoveMaker;
ISingleObjectiveMoveEvaluator oldMoveEvaluator = MoveEvaluator;
ClearMoveParameters();
if (MoveGenerator != null) {
List moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
foreach (Type type in moveTypes.ToList()) {
if (moveTypes.Any(t => t != type && type.IsAssignableFrom(t)))
moveTypes.Remove(type);
}
foreach (Type type in moveTypes) {
var operators = Problem.Operators.Where(x => type.IsAssignableFrom(x.GetType())).OrderBy(x => x.Name);
foreach (IMoveMaker moveMaker in operators.OfType())
MoveMakerParameter.ValidValues.Add(moveMaker);
foreach (ISingleObjectiveMoveEvaluator moveEvaluator in operators.OfType())
MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
}
if (oldMoveMaker != null) {
IMoveMaker mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
if (mm != null) MoveMaker = mm;
}
if (oldMoveEvaluator != null) {
ISingleObjectiveMoveEvaluator me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
if (me != null) MoveEvaluator = me;
}
}
}
private void ClearMoveParameters() {
MoveMakerParameter.ValidValues.Clear();
MoveEvaluatorParameter.ValidValues.Clear();
}
private void ParameterizeSolutionsCreator() {
SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
}
private void ParameterizeMainLoop() {
MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
if (MoveEvaluator != null)
MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
}
private void ParameterizeStochasticOperator(IOperator op) {
if (op is IStochasticOperator)
((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
}
private void ParameterizeMoveEvaluators() {
foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType()) {
op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
}
}
private void ParameterizeMoveMakers() {
foreach (IMoveMaker op in Problem.Operators.OfType()) {
op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
if (MoveEvaluator != null)
op.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
}
}
private void ParameterizeAnnealingOperators() {
foreach (IDiscreteDoubleValueModifier op in AnnealingOperatorParameter.ValidValues) {
op.IndexParameter.ActualName = "Iterations";
op.StartIndexParameter.Value = new IntValue(0);
op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
op.ValueParameter.ActualName = "Temperature";
op.StartValueParameter.ActualName = StartTemperatureParameter.Name;
op.EndValueParameter.ActualName = EndTemperatureParameter.Name;
ParameterizeStochasticOperator(op);
}
}
private void ParameterizeMoveGenerators() {
foreach (IMultiMoveGenerator op in Problem.Operators.OfType()) {
op.SampleSizeParameter.ActualName = InnerIterationsParameter.Name;
}
}
private void ParameterizeIterationBasedOperators() {
if (Problem != null) {
foreach (IIterationBasedOperator op in Problem.Operators.OfType()) {
op.IterationsParameter.ActualName = "Iterations";
op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
}
}
}
private void UpdateAnalyzers() {
Analyzer.Operators.Clear();
if (Problem != null) {
foreach (IAnalyzer analyzer in Problem.Operators.OfType()) {
foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType())
param.Depth = 0;
Analyzer.Operators.Add(analyzer);
}
}
Analyzer.Operators.Add(qualityAnalyzer);
}
#endregion
}
}