public SingleValueAnalyzer()
: base() {
#region Create parameters
Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value contained in the scope tree which should be analyzed."));
Parameters.Add(new ValueLookupParameter<DataTable>("Values", "The data table to store the values."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
#endregion
#region Create operators
DataTableValuesCollector dataTableValuesCollector = new DataTableValuesCollector();
ResultsCollector resultsCollector = new ResultsCollector();
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Value", null, ValueParameter.Name));
dataTableValuesCollector.DataTableParameter.ActualName = ValuesParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Value", null, ValueParameter.Name));
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(ValuesParameter.Name));
resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = dataTableValuesCollector;
dataTableValuesCollector.Successor = resultsCollector;
resultsCollector.Successor = null;
#endregion
}
public SelectionPressureAnalyzer()
: base() {
#region Create parameters
Parameters.Add(new LookupParameter<DoubleValue>("ActualSelectionPressure", "The actual selection pressure."));
Parameters.Add(new ValueLookupParameter<DataTable>("SelectionPressure", "The data table to store the values."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
#endregion
#region Create operators
DataTableValuesCollector dataTableValuesCollector = new DataTableValuesCollector();
ResultsCollector resultsCollector = new ResultsCollector();
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("ActualSelectionPressure", null, ActualSelectionPressureParameter.Name));
dataTableValuesCollector.DataTableParameter.ActualName = SelectionPressureParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(SelectionPressureParameter.Name));
resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = dataTableValuesCollector;
dataTableValuesCollector.Successor = resultsCollector;
resultsCollector.Successor = null;
#endregion
}
public QualityAnalyzer()
: base() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestQuality", "The best quality value found in the current run."));
Parameters.Add(new ValueLookupParameter<DataTable>("Qualities", "The data table to store the current best, current average, current worst, best and best known quality value."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("AbsoluteDifferenceBestKnownToBest", "The absolute difference of the best known quality value to the best quality value."));
Parameters.Add(new ValueLookupParameter<PercentValue>("RelativeDifferenceBestKnownToBest", "The relative difference of the best known quality value to the best quality value."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
#endregion
#region Create operators
BestQualityMemorizer bestQualityMemorizer = new BestQualityMemorizer();
BestQualityMemorizer bestKnownQualityMemorizer = new BestQualityMemorizer();
DataTableValuesCollector dataTableValuesCollector = new DataTableValuesCollector();
QualityDifferenceCalculator qualityDifferenceCalculator = new QualityDifferenceCalculator();
ResultsCollector resultsCollector = new ResultsCollector();
bestQualityMemorizer.BestQualityParameter.ActualName = BestQualityParameter.Name;
bestQualityMemorizer.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestQualityMemorizer.QualityParameter.ActualName = QualityParameter.Name;
bestQualityMemorizer.QualityParameter.Depth = QualityParameter.Depth;
bestKnownQualityMemorizer.BestQualityParameter.ActualName = BestKnownQualityParameter.Name;
bestKnownQualityMemorizer.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestKnownQualityMemorizer.QualityParameter.ActualName = QualityParameter.Name;
bestKnownQualityMemorizer.QualityParameter.Depth = QualityParameter.Depth;
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestQuality", null, BestQualityParameter.Name));
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestKnownQuality", null, BestKnownQualityParameter.Name));
dataTableValuesCollector.CollectedValues.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", null, QualityParameter.Name));
((ScopeTreeLookupParameter<DoubleValue>)dataTableValuesCollector.CollectedValues["Quality"]).Depth = QualityParameter.Depth;
dataTableValuesCollector.DataTableParameter.ActualName = QualitiesParameter.Name;
qualityDifferenceCalculator.AbsoluteDifferenceParameter.ActualName = AbsoluteDifferenceBestKnownToBestParameter.Name;
qualityDifferenceCalculator.FirstQualityParameter.ActualName = BestKnownQualityParameter.Name;
qualityDifferenceCalculator.RelativeDifferenceParameter.ActualName = RelativeDifferenceBestKnownToBestParameter.Name;
qualityDifferenceCalculator.SecondQualityParameter.ActualName = BestQualityParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestQuality", null, BestQualityParameter.Name));
resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestKnownQuality", null, BestKnownQualityParameter.Name));
resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", null, QualityParameter.Name));
((ScopeTreeLookupParameter<DoubleValue>)resultsCollector.CollectedValues["Quality"]).Depth = QualityParameter.Depth;
resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("AbsoluteDifferenceBestKnownToBest", null, AbsoluteDifferenceBestKnownToBestParameter.Name));
resultsCollector.CollectedValues.Add(new LookupParameter<PercentValue>("RelativeDifferenceBestKnownToBest", null, RelativeDifferenceBestKnownToBestParameter.Name));
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(QualitiesParameter.Name));
resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = bestQualityMemorizer;
bestQualityMemorizer.Successor = bestKnownQualityMemorizer;
bestKnownQualityMemorizer.Successor = dataTableValuesCollector;
dataTableValuesCollector.Successor = qualityDifferenceCalculator;
qualityDifferenceCalculator.Successor = resultsCollector;
resultsCollector.Successor = null;
#endregion
Initialize();
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorStart", "The initial value for the comparison factor."));
Parameters.Add(new ValueLookupParameter<IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
Assigner comparisonFactorInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
IntCounter generationsCounter = new IntCounter();
Comparator maxGenerationsComparator = new Comparator();
Comparator maxSelectionPressureComparator = new Comparator();
Comparator maxEvaluatedSolutionsComparator = new Comparator();
Placeholder comparisonFactorModifier = new Placeholder();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch conditionalBranch1 = new ConditionalBranch();
ConditionalBranch conditionalBranch2 = new ConditionalBranch();
ConditionalBranch conditionalBranch3 = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class OffspringSelectionGeneticAlgorithm expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
comparisonFactorInitializer.Name = "Initialize ComparisonFactor (placeholder)";
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Comparison Factor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
generationsCounter.Increment = new IntValue(1);
generationsCounter.ValueParameter.ActualName = "Generations";
maxGenerationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxGenerationsComparator.LeftSideParameter.ActualName = "Generations";
maxGenerationsComparator.ResultParameter.ActualName = "TerminateMaximumGenerations";
maxGenerationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
maxSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
maxSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
maxSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
maxEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maxEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
comparisonFactorModifier.Name = "Update ComparisonFactor (placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
conditionalBranch1.Name = "MaximumSelectionPressure reached?";
conditionalBranch1.ConditionParameter.ActualName = "TerminateSelectionPressure";
conditionalBranch2.Name = "MaximumGenerations reached?";
conditionalBranch2.ConditionParameter.ActualName = "TerminateMaximumGenerations";
conditionalBranch3.Name = "MaximumEvaluatedSolutions reached?";
conditionalBranch3.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = comparisonFactorInitializer;
comparisonFactorInitializer.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = mainOperator;
mainOperator.Successor = generationsCounter;
generationsCounter.Successor = maxGenerationsComparator;
maxGenerationsComparator.Successor = maxSelectionPressureComparator;
maxSelectionPressureComparator.Successor = maxEvaluatedSolutionsComparator;
maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = analyzer2;
analyzer2.Successor = conditionalBranch1;
conditionalBranch1.FalseBranch = conditionalBranch2;
conditionalBranch1.TrueBranch = null;
conditionalBranch1.Successor = null;
conditionalBranch2.FalseBranch = conditionalBranch3;
conditionalBranch2.TrueBranch = null;
conditionalBranch2.Successor = null;
conditionalBranch3.FalseBranch = mainOperator;
conditionalBranch3.TrueBranch = null;
conditionalBranch3.Successor = null;
#endregion
}
public BestAverageWorstTimeWindowedVRPToursAnalyzer()
: base() {
#region Create parameters
Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Tardiness", "The tardiness of the VRP solutions which should be analyzed."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestTardiness", "The best tardiness value."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentBestTardiness", "The current best tardiness value."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAverageTardiness", "The current average tardiness value of all solutions."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentWorstTardiness", "The current worst tardiness value of all solutions."));
Parameters.Add(new ValueLookupParameter<DataTable>("TardinessValues", "The data table to store the current best, current average, current worst, best and best known tardiness value."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("TravelTime", "The travel time of the VRP solutions which should be analyzed."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestTravelTime", "The best travel time value."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentBestTravelTime", "The current best travel time value."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAverageTravelTime", "The current average travel time value of all solutions."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentWorstTravelTime", "The current worst travel time value of all solutions."));
Parameters.Add(new ValueLookupParameter<DataTable>("TravelTimes", "The data table to store the current best, current average, current worst, best and best known travel time value."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
#endregion
#region Create operators
BestTimeWindowedVRPToursMemorizer bestMemorizer = new BestTimeWindowedVRPToursMemorizer();
BestAverageWorstTimeWindowedVRPToursCalculator calculator = new BestAverageWorstTimeWindowedVRPToursCalculator();
ResultsCollector resultsCollector = new ResultsCollector();
//tardiness
bestMemorizer.BestTardinessParameter.ActualName = BestTardinessParameter.Name;
bestMemorizer.TardinessParameter.ActualName = TardinessParameter.Name;
bestMemorizer.TardinessParameter.Depth = TardinessParameter.Depth;
calculator.TardinessParameter.ActualName = TardinessParameter.Name;
calculator.TardinessParameter.Depth = TardinessParameter.Depth;
calculator.BestTardinessParameter.ActualName = CurrentBestTardinessParameter.Name;
calculator.AverageTardinessParameter.ActualName = CurrentAverageTardinessParameter.Name;
calculator.WorstTardinessParameter.ActualName = CurrentWorstTardinessParameter.Name;
DataTableValuesCollector tardinessDataTablesCollector = new DataTableValuesCollector();
tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestTardiness", null, BestTardinessParameter.Name));
tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentBestTardiness", null, CurrentBestTardinessParameter.Name));
tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAverageTardiness", null, CurrentAverageTardinessParameter.Name));
tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentWorstTardiness", null, CurrentWorstTardinessParameter.Name));
tardinessDataTablesCollector.DataTableParameter.ActualName = TardinessValuesParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(TardinessValuesParameter.Name));
//Travel Time
bestMemorizer.BestTravelTimeParameter.ActualName = BestTravelTimeParameter.Name;
bestMemorizer.TravelTimeParameter.ActualName = TravelTimeParameter.Name;
bestMemorizer.TravelTimeParameter.Depth = TravelTimeParameter.Depth;
calculator.TravelTimeParameter.ActualName = TravelTimeParameter.Name;
calculator.TravelTimeParameter.Depth = TravelTimeParameter.Depth;
calculator.BestTravelTimeParameter.ActualName = CurrentBestTravelTimeParameter.Name;
calculator.AverageTravelTimeParameter.ActualName = CurrentAverageTravelTimeParameter.Name;
calculator.WorstTravelTimeParameter.ActualName = CurrentWorstTravelTimeParameter.Name;
DataTableValuesCollector travelTimeDataTablesCollector = new DataTableValuesCollector();
travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestTravelTime", null, BestTravelTimeParameter.Name));
travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentBestTravelTime", null, CurrentBestTravelTimeParameter.Name));
travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAverageTravelTime", null, CurrentAverageTravelTimeParameter.Name));
travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentWorstTravelTime", null, CurrentWorstTravelTimeParameter.Name));
travelTimeDataTablesCollector.DataTableParameter.ActualName = TravelTimesParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(TravelTimesParameter.Name));
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = bestMemorizer;
bestMemorizer.Successor = calculator;
calculator.Successor = tardinessDataTablesCollector;
tardinessDataTablesCollector.Successor = travelTimeDataTablesCollector;
travelTimeDataTablesCollector.Successor = resultsCollector;
resultsCollector.Successor = null;
#endregion
Initialize();
}
private void InitializeOperators() {
prunedNodesReducer = new DataReducer();
prunedNodesReducer.ParameterToReduce.ActualName = PruningOperator.PrunedNodesParameter.ActualName;
prunedNodesReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum); // sum all the pruned subtrees parameter values
prunedNodesReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign); // asign the sum to the target parameter
prunedNodesReducer.TargetParameter.ActualName = TotalNumberOfPrunedNodesParameterName;
prunedSubtreesReducer = new DataReducer();
prunedSubtreesReducer.ParameterToReduce.ActualName = PruningOperator.PrunedSubtreesParameter.ActualName;
prunedSubtreesReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum); // sum all the pruned subtrees parameter values
prunedSubtreesReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign); // asign the sum to the target parameter
prunedSubtreesReducer.TargetParameter.ActualName = TotalNumberOfPrunedSubtreesParameterName;
prunedTreesReducer = new DataReducer();
prunedTreesReducer.ParameterToReduce.ActualName = PruningOperator.PrunedTreesParameter.ActualName;
prunedTreesReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
prunedTreesReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
prunedTreesReducer.TargetParameter.ActualName = TotalNumberOfPrunedTreesParameterName;
valuesCollector = new DataTableValuesCollector();
valuesCollector.CollectedValues.Add(new LookupParameter<IntValue>(TotalNumberOfPrunedNodesParameterName));
valuesCollector.CollectedValues.Add(new LookupParameter<IntValue>(TotalNumberOfPrunedSubtreesParameterName));
valuesCollector.CollectedValues.Add(new LookupParameter<IntValue>(TotalNumberOfPrunedTreesParameterName));
valuesCollector.DataTableParameter.ActualName = "Population pruning";
resultsCollector = new ResultsCollector();
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Population pruning"));
resultsCollector.ResultsParameter.ActualName = ResultsParameterName;
}
public RobustTabooSearch() {
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The analyzers that are applied after each iteration.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The seed value of the random number generator.", new IntValue(0)));
Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True whether the seed should be set randomly for each run, false if it should be fixed.", new BoolValue(true)));
Parameters.Add(new FixedValueParameter<IntValue>("MaximumIterations", "The number of iterations that the algorithm should run.", new IntValue(10000)));
Parameters.Add(new FixedValueParameter<IntValue>("MinimumTabuTenure", "The minimum tabu tenure.", new IntValue(10)));
Parameters.Add(new FixedValueParameter<IntValue>("MaximumTabuTenure", "The maximum tabu tenure.", new IntValue(20)));
Parameters.Add(new FixedValueParameter<BoolValue>("UseAlternativeAspiration", "True if the alternative aspiration condition should be used that takes moves that have not been made for some time above others.", new BoolValue(false)));
Parameters.Add(new FixedValueParameter<IntValue>("AlternativeAspirationTenure", "The time t that a move will be remembered for the alternative aspiration condition.", new IntValue(int.MaxValue)));
Parameters.Add(new FixedValueParameter<BoolValue>("TerminateOnOptimalSolution", "True when the algorithm should stop if it reached a quality equal or smaller to the BestKnownQuality.", new BoolValue(false)));
Parameters.Add(new FixedValueParameter<BoolValue>("UseNewTabuTenureAdaptionScheme", @"In an updated version of his implementation, Eric Taillard introduced a different way to change the tabu tenure.
Instead of setting it uniformly between min and max, it will be set between 0 and max according to a right-skewed distribution.
Set this option to false if you want to optimize using the earlier 1991 version, and set to true if you want to optimize using the newer version.
Please note that the MinimumTabuTenure parameter has no effect in the new version.", new BoolValue(true)));
TerminateOnOptimalSolutionParameter.Hidden = true;
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
qualityAnalyzer.ResultsParameter.ActualName = "Results";
AnalyzerParameter.Value.Operators.Add(qualityAnalyzer);
RandomCreator randomCreator = new RandomCreator();
randomCreator.RandomParameter.ActualName = "Random";
randomCreator.SeedParameter.Value = null;
randomCreator.SeedParameter.ActualName = SeedParameter.Name;
randomCreator.SetSeedRandomlyParameter.Value = null;
randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
VariableCreator variableCreator = new VariableCreator();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(1)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("EvaluatedSolutionEquivalents", new DoubleValue(1)));
ResultsCollector resultsCollector = new ResultsCollector();
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations", "The actual iteration."));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "Number of evaluated solutions."));
solutionsCreator = new SolutionsCreator();
solutionsCreator.NumberOfSolutions = new IntValue(1);
Placeholder analyzer = new Placeholder();
analyzer.Name = "(Analyzer)";
analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;
UniformSubScopesProcessor ussp = new UniformSubScopesProcessor();
mainOperator = new RobustTabooSeachOperator();
mainOperator.AlternativeAspirationTenureParameter.ActualName = AlternativeAspirationTenureParameter.Name;
mainOperator.BestQualityParameter.ActualName = "BestSoFarQuality";
mainOperator.IterationsParameter.ActualName = "Iterations";
mainOperator.LastMoveParameter.ActualName = "LastMove";
mainOperator.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
mainOperator.MaximumTabuTenureParameter.ActualName = MaximumTabuTenureParameter.Name;
mainOperator.MinimumTabuTenureParameter.ActualName = MinimumTabuTenureParameter.Name;
mainOperator.MoveQualityMatrixParameter.ActualName = "MoveQualityMatrix";
mainOperator.RandomParameter.ActualName = "Random";
mainOperator.ResultsParameter.ActualName = "Results";
mainOperator.ShortTermMemoryParameter.ActualName = "ShortTermMemory";
mainOperator.UseAlternativeAspirationParameter.ActualName = UseAlternativeAspirationParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
mainOperator.EvaluatedSolutionEquivalentsParameter.ActualName = "EvaluatedSolutionEquivalents";
ConditionalBranch qualityStopBranch = new ConditionalBranch();
qualityStopBranch.Name = "Terminate on optimal quality?";
qualityStopBranch.ConditionParameter.ActualName = "TerminateOnOptimalSolution";
Comparator qualityComparator = new Comparator();
qualityComparator.Comparison = new Comparison(ComparisonType.Greater);
qualityComparator.LeftSideParameter.ActualName = "BestQuality";
qualityComparator.RightSideParameter.ActualName = "BestKnownQuality";
qualityComparator.ResultParameter.ActualName = "ContinueByQuality";
ConditionalBranch continueByQualityBranch = new ConditionalBranch();
continueByQualityBranch.ConditionParameter.ActualName = "ContinueByQuality";
IntCounter iterationsCounter = new IntCounter();
iterationsCounter.ValueParameter.ActualName = "Iterations";
iterationsCounter.Increment = new IntValue(1);
Comparator comparator = new Comparator();
comparator.Name = "Iterations < MaximumIterations ?";
comparator.LeftSideParameter.ActualName = "Iterations";
comparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
comparator.Comparison = new Comparison(ComparisonType.Less);
comparator.ResultParameter.ActualName = "ContinueByIteration";
ConditionalBranch continueByIterationBranch = new ConditionalBranch();
continueByIterationBranch.ConditionParameter.ActualName = "ContinueByIteration";
OperatorGraph.InitialOperator = randomCreator;
randomCreator.Successor = variableCreator;
variableCreator.Successor = resultsCollector;
resultsCollector.Successor = solutionsCreator;
solutionsCreator.Successor = analyzer;
analyzer.Successor = ussp;
ussp.Operator = mainOperator;
ussp.Successor = qualityStopBranch;
qualityStopBranch.FalseBranch = iterationsCounter;
qualityStopBranch.TrueBranch = qualityComparator;
qualityStopBranch.Successor = null;
qualityComparator.Successor = continueByQualityBranch;
continueByQualityBranch.TrueBranch = iterationsCounter;
continueByQualityBranch.FalseBranch = null;
continueByQualityBranch.Successor = null;
iterationsCounter.Successor = comparator;
comparator.Successor = continueByIterationBranch;
continueByIterationBranch.TrueBranch = analyzer;
continueByIterationBranch.FalseBranch = null;
continueByIterationBranch.Successor = null;
RegisterEventHandlers();
Problem = new QuadraticAssignmentProblem();
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<IntValue>("SwarmSize", "Size of the particle swarm."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaxIterations", "Maximal number of iterations."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentInertia", "Inertia weight on a particle's movement (omega)."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("PersonalBestAttraction", "Weight for particle's pull towards its personal best soution (phi_p)."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("NeighborBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g)."));
Parameters.Add(new ValueLookupParameter<IOperator>("ParticleUpdater", "Operator that calculates new position and velocity of a particle"));
Parameters.Add(new ValueLookupParameter<IOperator>("TopologyUpdater", "Updates the neighborhood description vectors"));
Parameters.Add(new ValueLookupParameter<IOperator>("InertiaUpdater", "Updates the omega parameter"));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "Evaluates a particle solution."));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<ISwarmUpdater>("SwarmUpdater", "The encoding-specific swarm updater."));
#endregion
#region Create operators
ResultsCollector resultsCollector = new ResultsCollector();
Placeholder swarmUpdaterPlaceholer1 = new Placeholder();
Placeholder evaluatorPlaceholder = new Placeholder();
Placeholder analyzerPlaceholder = new Placeholder();
UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
Placeholder particleUpdaterPlaceholder = new Placeholder();
Placeholder topologyUpdaterPlaceholder = new Placeholder();
UniformSubScopesProcessor evaluationProcessor = new UniformSubScopesProcessor();
Placeholder swarmUpdater = new Placeholder();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch conditionalBranch = new ConditionalBranch();
Placeholder inertiaUpdaterPlaceholder = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentInertia"));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.Successor = swarmUpdaterPlaceholer1;
swarmUpdaterPlaceholer1.Name = "(Swarm Updater)";
swarmUpdaterPlaceholer1.OperatorParameter.ActualName = SwarmUpdaterParameter.ActualName;
swarmUpdaterPlaceholer1.Successor = analyzerPlaceholder;
analyzerPlaceholder.Name = "(Analyzer)";
analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
analyzerPlaceholder.Successor = uniformSubScopeProcessor;
uniformSubScopeProcessor.Operator = particleUpdaterPlaceholder;
uniformSubScopeProcessor.Successor = evaluationProcessor;
particleUpdaterPlaceholder.Name = "(ParticleUpdater)";
particleUpdaterPlaceholder.OperatorParameter.ActualName = ParticleUpdaterParameter.Name;
evaluationProcessor.Parallel = new BoolValue(true);
evaluationProcessor.Operator = evaluatorPlaceholder;
evaluationProcessor.Successor = subScopesCounter;
evaluatorPlaceholder.Name = "(Evaluator)";
evaluatorPlaceholder.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
subScopesCounter.Successor = topologyUpdaterPlaceholder;
topologyUpdaterPlaceholder.Name = "(TopologyUpdater)";
topologyUpdaterPlaceholder.OperatorParameter.ActualName = TopologyUpdaterParameter.Name;
topologyUpdaterPlaceholder.Successor = swarmUpdater;
swarmUpdater.Name = "(Swarm Updater)";
swarmUpdater.OperatorParameter.ActualName = SwarmUpdaterParameter.ActualName;
swarmUpdater.Successor = inertiaUpdaterPlaceholder;
inertiaUpdaterPlaceholder.Name = "(Inertia Updater)";
inertiaUpdaterPlaceholder.OperatorParameter.ActualName = InertiaUpdaterParameter.ActualName;
inertiaUpdaterPlaceholder.Successor = iterationsCounter;
iterationsCounter.Name = "Iterations++";
iterationsCounter.ValueParameter.ActualName = "Iterations";
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.LeftSideParameter.ActualName = "Iterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.Less);
iterationsComparator.RightSideParameter.ActualName = "MaxIterations";
iterationsComparator.ResultParameter.ActualName = "ContinueIteration";
iterationsComparator.Successor = conditionalBranch;
conditionalBranch.Name = "ContinueIteration?";
conditionalBranch.ConditionParameter.ActualName = "ContinueIteration";
conditionalBranch.TrueBranch = analyzerPlaceholder;
#endregion
}
private CombinedOperator CreateLayerOpener() {
var layerOpener = new CombinedOperator() { Name = "Open new Layer if needed" };
var maxLayerReached = new Comparator() { Name = "MaxLayersReached = OpenLayers >= NumberOfLayers" };
var maxLayerReachedBranch = new ConditionalBranch() { Name = "MaxLayersReached?" };
var openNewLayerCalculator = new ExpressionCalculator() { Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]" };
var openNewLayerBranch = new ConditionalBranch() { Name = "OpenNewLayer?" };
var layerCreator = new LastLayerCloner() { Name = "Create Layer" };
var updateLayerNumber = new Assigner() { Name = "Layer = OpenLayers" };
var historyWiper = new ResultsHistoryWiper() { Name = "Clear History in Results" };
var createChildrenViaCrossover = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxLayerReached.Successor = maxLayerReachedBranch;
maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>(AgeLimitsParameter.Name));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(NumberOfLayersParameter.Name));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
openNewLayerCalculator.Successor = openNewLayerBranch;
openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
openNewLayerBranch.TrueBranch = layerCreator;
layerCreator.NewLayerOperator = updateLayerNumber;
layerCreator.Successor = incrOpenLayers;
updateLayerNumber.LeftSideParameter.ActualName = "Layer";
updateLayerNumber.RightSideParameter.ActualName = "OpenLayers";
updateLayerNumber.Successor = historyWiper;
historyWiper.ResultsParameter.ActualName = "LayerResults";
historyWiper.Successor = createChildrenViaCrossover;
// Maybe use only crossover and no elitism instead of "default operator"
createChildrenViaCrossover.RandomParameter.ActualName = LocalRandomParameter.Name;
createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.ActualName;
createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
createChildrenViaCrossover.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
createChildrenViaCrossover.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
createChildrenViaCrossover.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
createChildrenViaCrossover.SelectionPressureParameter.ActualName = "SelectionPressure";
createChildrenViaCrossover.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
createChildrenViaCrossover.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
createChildrenViaCrossover.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
incrOpenLayers.Increment = new IntValue(1);
incrOpenLayers.Successor = newLayerResultsCollector;
newLayerResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each layer", "LayerResults"));
newLayerResultsCollector.CopyValue = new BoolValue(false);
newLayerResultsCollector.Successor = null;
return layerOpener;
}
public SASEGASAMainLoop()
: base() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfVillages", "The initial number of villages."));
Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The fixed period after which migration occurs."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the villages."));
Parameters.Add(new ValueLookupParameter<IOperator>("VillageAnalyzer", "The operator used to analyze each village."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorStart", "The lower bound of the comparison factor (start)."));
Parameters.Add(new ValueLookupParameter<IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("FinalMaximumSelectionPressure", "The maximum selection pressure used when there is only one village left."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum genreation that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
Assigner maxSelPressAssigner = new Assigner();
Assigner villageCountAssigner = new Assigner();
Assigner comparisonFactorInitializer = new Assigner();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator villageVariableCreator = new VariableCreator();
Placeholder villageAnalyzer1 = new Placeholder();
ResultsCollector villageResultsCollector1 = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
ConditionalBranch villageTerminatedBySelectionPressure1 = new ConditionalBranch();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
Placeholder villageAnalyzer2 = new Placeholder();
ResultsCollector villageResultsCollector2 = new ResultsCollector();
Comparator villageSelectionPressureComparator = new Comparator();
ConditionalBranch villageTerminatedBySelectionPressure2 = new ConditionalBranch();
IntCounter terminatedVillagesCounter = new IntCounter();
IntCounter generationsCounter = new IntCounter();
IntCounter generationsSinceLastReunificationCounter = new IntCounter();
Comparator reunificationComparator1 = new Comparator();
ConditionalBranch reunificationConditionalBranch1 = new ConditionalBranch();
Comparator reunificationComparator2 = new Comparator();
ConditionalBranch reunificationConditionalBranch2 = new ConditionalBranch();
Comparator reunificationComparator3 = new Comparator();
ConditionalBranch reunificationConditionalBranch3 = new ConditionalBranch();
Assigner resetTerminatedVillagesAssigner = new Assigner();
Assigner resetGenerationsSinceLastReunificationAssigner = new Assigner();
SASEGASAReunificator reunificator = new SASEGASAReunificator();
IntCounter reunificationCounter = new IntCounter();
Placeholder comparisonFactorModifier = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Assigner villageReviver = new Assigner();
Comparator villageCountComparator = new Comparator();
ConditionalBranch villageCountConditionalBranch = new ConditionalBranch();
Assigner finalMaxSelPressAssigner = new Assigner();
Comparator maximumGenerationsComparator = new Comparator();
Comparator maximumEvaluatedSolutionsComparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch terminationCondition = new ConditionalBranch();
ConditionalBranch maximumGenerationsTerminationCondition = new ConditionalBranch();
ConditionalBranch maximumEvaluatedSolutionsTerminationCondition = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Reunifications", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class SASEGASA expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("GenerationsSinceLastReunification", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TerminatedVillages", new IntValue(0)));
villageCountAssigner.LeftSideParameter.ActualName = "VillageCount";
villageCountAssigner.RightSideParameter.ActualName = NumberOfVillagesParameter.Name;
maxSelPressAssigner.LeftSideParameter.ActualName = "CurrentMaximumSelectionPressure";
maxSelPressAssigner.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
villageVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("Results", new ResultCollection()));
villageVariableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("TerminateSelectionPressure", new BoolValue(false)));
villageVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
villageVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
villageAnalyzer1.Name = "Village Analyzer (placeholder)";
villageAnalyzer1.OperatorParameter.ActualName = VillageAnalyzerParameter.Name;
villageResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
villageResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
villageResultsCollector1.ResultsParameter.ActualName = "Results";
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("ComparisonFactor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Terminated Villages", null, "TerminatedVillages"));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Total Active Villages", null, "VillageCount"));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("VillageResults", "Result set for each village", "Results"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
villageTerminatedBySelectionPressure1.Name = "Village Terminated ?";
villageTerminatedBySelectionPressure1.ConditionParameter.ActualName = "TerminateSelectionPressure";
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = "CurrentMaximumSelectionPressure";
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
villageAnalyzer2.Name = "Village Analyzer (placeholder)";
villageAnalyzer2.OperatorParameter.ActualName = VillageAnalyzerParameter.Name;
villageResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
villageResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
villageResultsCollector2.ResultsParameter.ActualName = "Results";
villageSelectionPressureComparator.Name = "SelectionPressure >= CurrentMaximumSelectionPressure ?";
villageSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
villageSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
villageSelectionPressureComparator.RightSideParameter.ActualName = "CurrentMaximumSelectionPressure";
villageSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
villageTerminatedBySelectionPressure2.Name = "Village Terminated ?";
villageTerminatedBySelectionPressure2.ConditionParameter.ActualName = "TerminateSelectionPressure";
terminatedVillagesCounter.Name = "TerminatedVillages + 1";
terminatedVillagesCounter.ValueParameter.ActualName = "TerminatedVillages";
terminatedVillagesCounter.Increment = new IntValue(1);
generationsCounter.Name = "Generations + 1";
generationsCounter.ValueParameter.ActualName = "Generations";
generationsCounter.Increment = new IntValue(1);
generationsSinceLastReunificationCounter.Name = "GenerationsSinceLastReunification + 1";
generationsSinceLastReunificationCounter.ValueParameter.ActualName = "GenerationsSinceLastReunification";
generationsSinceLastReunificationCounter.Increment = new IntValue(1);
reunificationComparator1.Name = "TerminatedVillages = VillageCount ?";
reunificationComparator1.LeftSideParameter.ActualName = "TerminatedVillages";
reunificationComparator1.Comparison = new Comparison(ComparisonType.Equal);
reunificationComparator1.RightSideParameter.ActualName = "VillageCount";
reunificationComparator1.ResultParameter.ActualName = "Reunificate";
reunificationConditionalBranch1.Name = "Reunificate ?";
reunificationConditionalBranch1.ConditionParameter.ActualName = "Reunificate";
reunificationComparator2.Name = "GenerationsSinceLastReunification = MigrationInterval ?";
reunificationComparator2.LeftSideParameter.ActualName = "GenerationsSinceLastReunification";
reunificationComparator2.Comparison = new Comparison(ComparisonType.Equal);
reunificationComparator2.RightSideParameter.ActualName = "MigrationInterval";
reunificationComparator2.ResultParameter.ActualName = "Reunificate";
reunificationConditionalBranch2.Name = "Reunificate ?";
reunificationConditionalBranch2.ConditionParameter.ActualName = "Reunificate";
// if there's just one village left and we're getting to this point SASEGASA terminates
reunificationComparator3.Name = "VillageCount <= 1 ?";
reunificationComparator3.LeftSideParameter.ActualName = "VillageCount";
reunificationComparator3.RightSideParameter.Value = new IntValue(1);
reunificationComparator3.Comparison.Value = ComparisonType.LessOrEqual;
reunificationComparator3.ResultParameter.ActualName = "TerminateSASEGASA";
reunificationConditionalBranch3.Name = "Skip reunification?";
reunificationConditionalBranch3.ConditionParameter.ActualName = "TerminateSASEGASA";
resetTerminatedVillagesAssigner.Name = "Reset TerminatedVillages";
resetTerminatedVillagesAssigner.LeftSideParameter.ActualName = "TerminatedVillages";
resetTerminatedVillagesAssigner.RightSideParameter.Value = new IntValue(0);
resetGenerationsSinceLastReunificationAssigner.Name = "Reset GenerationsSinceLastReunification";
resetGenerationsSinceLastReunificationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastReunification";
resetGenerationsSinceLastReunificationAssigner.RightSideParameter.Value = new IntValue(0);
reunificator.VillageCountParameter.ActualName = "VillageCount";
reunificationCounter.ValueParameter.ActualName = "Reunifications"; // this variable is referenced in SASEGASA, do not change!
reunificationCounter.IncrementParameter.Value = new IntValue(1);
comparisonFactorModifier.Name = "Update comparison factor (placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
villageReviver.Name = "Village Reviver";
villageReviver.LeftSideParameter.ActualName = "TerminateSelectionPressure";
villageReviver.RightSideParameter.Value = new BoolValue(false);
villageCountComparator.Name = "VillageCount == 1 ?";
villageCountComparator.LeftSideParameter.ActualName = "VillageCount";
villageCountComparator.RightSideParameter.Value = new IntValue(1);
villageCountComparator.Comparison.Value = ComparisonType.Equal;
villageCountComparator.ResultParameter.ActualName = "ChangeMaxSelPress";
villageCountConditionalBranch.Name = "Change max selection pressure?";
villageCountConditionalBranch.ConditionParameter.ActualName = "ChangeMaxSelPress";
finalMaxSelPressAssigner.LeftSideParameter.ActualName = "CurrentMaximumSelectionPressure";
finalMaxSelPressAssigner.RightSideParameter.ActualName = FinalMaximumSelectionPressureParameter.Name;
// if Generations is reaching MaximumGenerations we're also terminating
maximumGenerationsComparator.LeftSideParameter.ActualName = "Generations";
maximumGenerationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
maximumGenerationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maximumGenerationsComparator.ResultParameter.ActualName = "TerminateMaximumGenerations";
maximumEvaluatedSolutionsComparator.Name = "EvaluatedSolutions >= MaximumEvaluatedSolutions";
maximumEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maximumEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maximumEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maximumEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
terminationCondition.ConditionParameter.ActualName = "TerminateSASEGASA";
maximumGenerationsTerminationCondition.ConditionParameter.ActualName = "TerminateMaximumGenerations";
maximumEvaluatedSolutionsTerminationCondition.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = maxSelPressAssigner;
maxSelPressAssigner.Successor = villageCountAssigner;
villageCountAssigner.Successor = comparisonFactorInitializer;
comparisonFactorInitializer.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = villageVariableCreator;
uniformSubScopesProcessor0.Successor = analyzer1;
villageVariableCreator.Successor = villageAnalyzer1;
villageAnalyzer1.Successor = villageResultsCollector1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = villageTerminatedBySelectionPressure1;
uniformSubScopesProcessor1.Successor = generationsCounter;
villageTerminatedBySelectionPressure1.TrueBranch = null;
villageTerminatedBySelectionPressure1.FalseBranch = mainOperator;
villageTerminatedBySelectionPressure1.Successor = null;
mainOperator.Successor = villageAnalyzer2;
villageAnalyzer2.Successor = villageResultsCollector2;
villageResultsCollector2.Successor = villageSelectionPressureComparator;
villageSelectionPressureComparator.Successor = villageTerminatedBySelectionPressure2;
villageTerminatedBySelectionPressure2.TrueBranch = terminatedVillagesCounter;
villageTerminatedBySelectionPressure2.FalseBranch = null;
villageTerminatedBySelectionPressure2.Successor = null;
terminatedVillagesCounter.Successor = null;
generationsCounter.Successor = generationsSinceLastReunificationCounter;
generationsSinceLastReunificationCounter.Successor = reunificationComparator1;
reunificationComparator1.Successor = reunificationConditionalBranch1;
reunificationConditionalBranch1.TrueBranch = reunificationComparator3;
reunificationConditionalBranch1.FalseBranch = reunificationComparator2;
reunificationConditionalBranch1.Successor = maximumGenerationsComparator;
reunificationComparator2.Successor = reunificationConditionalBranch2;
reunificationConditionalBranch2.TrueBranch = reunificationComparator3;
reunificationConditionalBranch2.FalseBranch = null;
reunificationConditionalBranch2.Successor = null;
reunificationComparator3.Successor = reunificationConditionalBranch3;
reunificationConditionalBranch3.TrueBranch = null;
reunificationConditionalBranch3.FalseBranch = resetTerminatedVillagesAssigner;
reunificationConditionalBranch3.Successor = null;
resetTerminatedVillagesAssigner.Successor = resetGenerationsSinceLastReunificationAssigner;
resetGenerationsSinceLastReunificationAssigner.Successor = reunificator;
reunificator.Successor = reunificationCounter;
reunificationCounter.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = villageReviver;
uniformSubScopesProcessor2.Successor = villageCountComparator;
villageReviver.Successor = null;
villageCountComparator.Successor = villageCountConditionalBranch;
villageCountConditionalBranch.TrueBranch = finalMaxSelPressAssigner;
villageCountConditionalBranch.FalseBranch = null;
villageCountConditionalBranch.Successor = null;
finalMaxSelPressAssigner.Successor = null;
maximumGenerationsComparator.Successor = maximumEvaluatedSolutionsComparator;
maximumEvaluatedSolutionsComparator.Successor = analyzer2;
analyzer2.Successor = terminationCondition;
terminationCondition.TrueBranch = null;
terminationCondition.FalseBranch = maximumGenerationsTerminationCondition;
terminationCondition.Successor = null;
maximumGenerationsTerminationCondition.TrueBranch = null;
maximumGenerationsTerminationCondition.FalseBranch = maximumEvaluatedSolutionsTerminationCondition;
maximumGenerationsTerminationCondition.Successor = null;
maximumEvaluatedSolutionsTerminationCondition.TrueBranch = null;
maximumEvaluatedSolutionsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
maximumEvaluatedSolutionsTerminationCondition.Successor = null;
#endregion
}
public BestAverageWorstPickupAndDeliveryVRPToursAnalyzer()
: base() {
#region Create parameters
Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
Parameters.Add(new ScopeTreeLookupParameter<IntValue>("PickupViolations", "The pickup violations of the VRP solutions which should be analyzed."));
Parameters.Add(new ValueLookupParameter<IntValue>("BestPickupViolations", "The best pickup violations value."));
Parameters.Add(new ValueLookupParameter<IntValue>("CurrentBestPickupViolations", "The current best pickup violations value."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAveragePickupViolations", "The current average pickup violations value of all solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("CurrentWorstPickupViolations", "The current worst pickup violations value of all solutions."));
Parameters.Add(new ValueLookupParameter<DataTable>("PickupViolationsValues", "The data table to store the current best, current average, current worst, best and best known pickup violations value."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
#endregion
#region Create operators
BestPickupAndDeliveryVRPToursMemorizer bestMemorizer = new BestPickupAndDeliveryVRPToursMemorizer();
BestAverageWorstPickupAndDeliveryVRPToursCalculator calculator = new BestAverageWorstPickupAndDeliveryVRPToursCalculator();
ResultsCollector resultsCollector = new ResultsCollector();
//pickup violations
bestMemorizer.BestPickupViolationsParameter.ActualName = BestPickupViolationsParameter.Name;
bestMemorizer.PickupViolationsParameter.ActualName = PickupViolationsParameter.Name;
bestMemorizer.PickupViolationsParameter.Depth = PickupViolationsParameter.Depth;
calculator.PickupViolationsParameter.ActualName = PickupViolationsParameter.Name;
calculator.PickupViolationsParameter.Depth = PickupViolationsParameter.Depth;
calculator.BestPickupViolationsParameter.ActualName = CurrentBestPickupViolationsParameter.Name;
calculator.AveragePickupViolationsParameter.ActualName = CurrentAveragePickupViolationsParameter.Name;
calculator.WorstPickupViolationsParameter.ActualName = CurrentWorstPickupViolationsParameter.Name;
DataTableValuesCollector pickupViolationsDataTablesCollector = new DataTableValuesCollector();
pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<IntValue>("BestPickupViolations", null, BestPickupViolationsParameter.Name));
pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentBestPickupViolations", null, CurrentBestPickupViolationsParameter.Name));
pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAveragePickupViolations", null, CurrentAveragePickupViolationsParameter.Name));
pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentWorstPickupViolations", null, CurrentWorstPickupViolationsParameter.Name));
pickupViolationsDataTablesCollector.DataTableParameter.ActualName = PickupViolationsValuesParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(PickupViolationsValuesParameter.Name));
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = bestMemorizer;
bestMemorizer.Successor = calculator;
calculator.Successor = pickupViolationsDataTablesCollector;
pickupViolationsDataTablesCollector.Successor = resultsCollector;
resultsCollector.Successor = null;
#endregion
Initialize();
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "µ (mu) - the size of the population."));
Parameters.Add(new ValueLookupParameter<IntValue>("ParentsPerChild", "ρ (rho) - how many parents should be recombined."));
Parameters.Add(new ValueLookupParameter<IntValue>("Children", "λ (lambda) - the size of the offspring population."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<BoolValue>("PlusSelection", "True for plus selection (elitist population), false for comma selection (non-elitist population)."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Recombinator", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the EvolutionStrategy should be applied."));
Parameters.Add(new ValueLookupParameter<IOperator>("StrategyParameterManipulator", "The operator to mutate the endogeneous strategy parameters."));
Parameters.Add(new ValueLookupParameter<IOperator>("StrategyParameterCrossover", "The operator to cross the endogeneous strategy parameters."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector1 = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
WithoutRepeatingBatchedRandomSelector selector = new WithoutRepeatingBatchedRandomSelector();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
Comparator useRecombinationComparator = new Comparator();
ConditionalBranch useRecombinationBranch = new ConditionalBranch();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
Placeholder recombinator = new Placeholder();
Placeholder strategyRecombinator = new Placeholder();
Placeholder strategyMutator1 = new Placeholder();
Placeholder mutator1 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder strategyMutator2 = new Placeholder();
Placeholder mutator2 = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder evaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
ConditionalBranch plusOrCommaReplacementBranch = new ConditionalBranch();
MergingReducer plusReplacement = new MergingReducer();
RightReducer commaReplacement = new RightReducer();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
IntCounter intCounter = new IntCounter();
Comparator comparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch conditionalBranch = new ConditionalBranch();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
UniformSubScopesProcessor uniformSubScopesProcessor4 = new UniformSubScopesProcessor();
Placeholder evaluator2 = new Placeholder();
SubScopesCounter subScopesCounter2 = new SubScopesCounter();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class EvolutionStrategy expects this to be called Generations
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.ResultsParameter.ActualName = "Results";
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
selector.Name = "ES Random Selector";
selector.RandomParameter.ActualName = RandomParameter.Name;
selector.ParentsPerChildParameter.ActualName = ParentsPerChildParameter.Name;
selector.ChildrenParameter.ActualName = ChildrenParameter.Name;
useRecombinationComparator.Name = "ParentsPerChild > 1";
useRecombinationComparator.LeftSideParameter.ActualName = ParentsPerChildParameter.Name;
useRecombinationComparator.RightSideParameter.Value = new IntValue(1);
useRecombinationComparator.Comparison = new Comparison(ComparisonType.Greater);
useRecombinationComparator.ResultParameter.ActualName = "UseRecombination";
useRecombinationBranch.Name = "Use Recombination?";
useRecombinationBranch.ConditionParameter.ActualName = "UseRecombination";
childrenCreator.ParentsPerChild = null;
childrenCreator.ParentsPerChildParameter.ActualName = ParentsPerChildParameter.Name;
recombinator.Name = "Recombinator (placeholder)";
recombinator.OperatorParameter.ActualName = RecombinatorParameter.Name;
strategyRecombinator.Name = "Strategy Parameter Recombinator (placeholder)";
strategyRecombinator.OperatorParameter.ActualName = StrategyParameterCrossoverParameter.Name;
strategyMutator1.Name = "Strategy Parameter Manipulator (placeholder)";
strategyMutator1.OperatorParameter.ActualName = StrategyParameterManipulatorParameter.Name;
mutator1.Name = "Mutator (placeholder)";
mutator1.OperatorParameter.ActualName = MutatorParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
strategyMutator2.Name = "Strategy Parameter Manipulator (placeholder)";
strategyMutator2.OperatorParameter.ActualName = StrategyParameterManipulatorParameter.Name;
mutator2.Name = "Mutator (placeholder)";
mutator2.OperatorParameter.ActualName = MutatorParameter.Name;
uniformSubScopesProcessor3.Parallel.Value = true;
evaluator.Name = "Evaluator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
plusOrCommaReplacementBranch.ConditionParameter.ActualName = PlusSelectionParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = PopulationSizeParameter.Name;
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
intCounter.Increment = new IntValue(1);
intCounter.ValueParameter.ActualName = "Generations";
comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator.LeftSideParameter.ActualName = "Generations";
comparator.ResultParameter.ActualName = "Terminate";
comparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
conditionalBranch.ConditionParameter.ActualName = "Terminate";
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
uniformSubScopesProcessor4.Parallel.Value = true;
evaluator2.Name = "Evaluator (placeholder)";
evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter2.Name = "Increment EvaluatedSolutions";
subScopesCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = resultsCollector1;
resultsCollector1.Successor = analyzer1;
analyzer1.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(useRecombinationComparator);
subScopesProcessor1.Successor = plusOrCommaReplacementBranch;
useRecombinationComparator.Successor = useRecombinationBranch;
useRecombinationBranch.TrueBranch = childrenCreator;
useRecombinationBranch.FalseBranch = uniformSubScopesProcessor2;
useRecombinationBranch.Successor = uniformSubScopesProcessor3;
childrenCreator.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = recombinator;
uniformSubScopesProcessor1.Successor = null;
recombinator.Successor = strategyRecombinator;
strategyRecombinator.Successor = strategyMutator1;
strategyMutator1.Successor = mutator1;
mutator1.Successor = subScopesRemover;
subScopesRemover.Successor = null;
uniformSubScopesProcessor2.Operator = strategyMutator2;
uniformSubScopesProcessor2.Successor = null;
strategyMutator2.Successor = mutator2;
mutator2.Successor = null;
uniformSubScopesProcessor3.Operator = evaluator;
uniformSubScopesProcessor3.Successor = subScopesCounter;
evaluator.Successor = null;
subScopesCounter.Successor = null;
plusOrCommaReplacementBranch.TrueBranch = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = subScopesProcessor2;
reevaluateElitesBranch.FalseBranch = null;
subScopesProcessor2.Operators.Add(uniformSubScopesProcessor4);
subScopesProcessor2.Operators.Add(new EmptyOperator());
uniformSubScopesProcessor4.Operator = evaluator2;
uniformSubScopesProcessor4.Successor = subScopesCounter2;
subScopesCounter2.Successor = null;
reevaluateElitesBranch.Successor = plusReplacement;
plusOrCommaReplacementBranch.FalseBranch = commaReplacement;
plusOrCommaReplacementBranch.Successor = bestSelector;
bestSelector.Successor = rightReducer;
rightReducer.Successor = intCounter;
intCounter.Successor = comparator;
comparator.Successor = analyzer2;
analyzer2.Successor = conditionalBranch;
conditionalBranch.FalseBranch = selector;
conditionalBranch.TrueBranch = null;
conditionalBranch.Successor = null;
#endregion
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "µ (mu) - the size of the population."));
Parameters.Add(new ValueLookupParameter<IntValue>("ParentsPerChild", "ρ (rho) - how many parents should be recombined."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<BoolValue>("PlusSelection", "True for plus selection (elitist population), false for comma selection (non-elitist population)."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Recombinator", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the OffspringSelectionEvolutionStrategy should be applied."));
Parameters.Add(new ValueLookupParameter<IOperator>("StrategyParameterManipulator", "The operator to mutate the endogeneous strategy parameters."));
Parameters.Add(new ValueLookupParameter<IOperator>("StrategyParameterCrossover", "The operator to cross the endogeneous strategy parameters."));
Parameters.Add(new LookupParameter<DoubleValue>("CurrentSuccessRatio", "The current success ratio."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("SelectionPressure", "The actual selection pressure."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector1 = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
WithoutRepeatingBatchedRandomSelector selector = new WithoutRepeatingBatchedRandomSelector();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
Comparator useRecombinationComparator = new Comparator();
ConditionalBranch useRecombinationBranch = new ConditionalBranch();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
Placeholder recombinator = new Placeholder();
Placeholder strategyRecombinator = new Placeholder();
Placeholder strategyMutator1 = new Placeholder();
Placeholder mutator1 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder strategyMutator2 = new Placeholder();
Placeholder mutator2 = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder evaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
ConditionalBranch plusOrCommaReplacementBranch = new ConditionalBranch();
MergingReducer plusReplacement = new MergingReducer();
RightReducer commaReplacement = new RightReducer();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
IntCounter intCounter = new IntCounter();
Comparator maxGenerationsComparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch conditionalBranchTerminate = new ConditionalBranch();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
UniformSubScopesProcessor uniformSubScopesProcessor4 = new UniformSubScopesProcessor();
Placeholder evaluator2 = new Placeholder();
SubScopesCounter subScopesCounter2 = new SubScopesCounter();
WeightedParentsQualityComparator parentsComparator = new WeightedParentsQualityComparator();
SubScopesRemover subScopesRemover_afterCompare = new SubScopesRemover();
EvolutionStrategyOffspringSelector offspringSelector = new EvolutionStrategyOffspringSelector();
ChildrenCopyCreator childrenCopyCreator = new ChildrenCopyCreator();
Comparator maxSelectionPressureComparator = new Comparator();
ConditionalBranch conditionalBranchTerminateSelPressure = new ConditionalBranch();
Comparator maxEvaluatedSolutionsComparator = new Comparator();
ConditionalBranch conditionalBranchTerminateEvalSolutions = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class OffspringSelectionEvolutionStrategy expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
selector.Name = "ES Random Selector";
selector.RandomParameter.ActualName = RandomParameter.Name;
selector.ParentsPerChildParameter.ActualName = ParentsPerChildParameter.Name;
selector.ChildrenParameter.ActualName = SelectedParentsParameter.Name;
useRecombinationComparator.Name = "ParentsPerChild > 1";
useRecombinationComparator.LeftSideParameter.ActualName = ParentsPerChildParameter.Name;
useRecombinationComparator.RightSideParameter.Value = new IntValue(1);
useRecombinationComparator.Comparison = new Comparison(ComparisonType.Greater);
useRecombinationComparator.ResultParameter.ActualName = "UseRecombination";
useRecombinationBranch.Name = "Use Recombination?";
useRecombinationBranch.ConditionParameter.ActualName = "UseRecombination";
childrenCreator.ParentsPerChild = null;
childrenCreator.ParentsPerChildParameter.ActualName = ParentsPerChildParameter.Name;
recombinator.Name = "Recombinator (placeholder)";
recombinator.OperatorParameter.ActualName = RecombinatorParameter.Name;
strategyRecombinator.Name = "Strategy Parameter Recombinator (placeholder)";
strategyRecombinator.OperatorParameter.ActualName = StrategyParameterCrossoverParameter.Name;
strategyMutator1.Name = "Strategy Parameter Manipulator (placeholder)";
strategyMutator1.OperatorParameter.ActualName = StrategyParameterManipulatorParameter.Name;
mutator1.Name = "Mutator (placeholder)";
mutator1.OperatorParameter.ActualName = MutatorParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
strategyMutator2.Name = "Strategy Parameter Manipulator (placeholder)";
strategyMutator2.OperatorParameter.ActualName = StrategyParameterManipulatorParameter.Name;
mutator2.Name = "Mutator (placeholder)";
mutator2.OperatorParameter.ActualName = MutatorParameter.Name;
uniformSubScopesProcessor3.Parallel.Value = true;
evaluator.Name = "Evaluator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
plusOrCommaReplacementBranch.ConditionParameter.ActualName = PlusSelectionParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = PopulationSizeParameter.Name;
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
intCounter.Increment = new IntValue(1);
intCounter.ValueParameter.ActualName = "Generations";
maxGenerationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxGenerationsComparator.LeftSideParameter.ActualName = "Generations";
maxGenerationsComparator.ResultParameter.ActualName = "Terminate";
maxGenerationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
conditionalBranchTerminate.ConditionParameter.ActualName = "Terminate";
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
uniformSubScopesProcessor4.Parallel.Value = true;
evaluator2.Name = "Evaluator (placeholder)";
evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter2.Name = "Increment EvaluatedSolutions";
subScopesCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
parentsComparator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
parentsComparator.LeftSideParameter.ActualName = QualityParameter.Name;
parentsComparator.RightSideParameter.ActualName = QualityParameter.Name;
parentsComparator.MaximizationParameter.ActualName = MaximizationParameter.Name;
parentsComparator.ResultParameter.ActualName = "SuccessfulOffspring";
subScopesRemover_afterCompare.RemoveAllSubScopes = true;
offspringSelector.CurrentSuccessRatioParameter.ActualName = CurrentSuccessRatioParameter.Name;
offspringSelector.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
offspringSelector.SelectionPressureParameter.ActualName = SelectionPressureParameter.Name;
offspringSelector.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
offspringSelector.OffspringPopulationParameter.ActualName = "OffspringPopulation";
offspringSelector.OffspringPopulationWinnersParameter.ActualName = "OffspringPopulationWinners";
offspringSelector.SuccessfulOffspringParameter.ActualName = "SuccessfulOffspring";
offspringSelector.QualityParameter.ActualName = QualityParameter.Name;
maxSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
maxSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
maxSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
conditionalBranchTerminateSelPressure.ConditionParameter.ActualName = "TerminateSelectionPressure";
maxEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxEvaluatedSolutionsComparator.LeftSideParameter.ActualName = "EvaluatedSolutions";
maxEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = MaximumEvaluatedSolutionsParameter.Name;
conditionalBranchTerminateEvalSolutions.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = resultsCollector1;
resultsCollector1.Successor = analyzer1;
analyzer1.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(useRecombinationComparator);
subScopesProcessor1.Successor = offspringSelector;
offspringSelector.OffspringCreator = selector;
offspringSelector.Successor = plusOrCommaReplacementBranch;
useRecombinationComparator.Successor = useRecombinationBranch;
useRecombinationBranch.TrueBranch = childrenCreator;
useRecombinationBranch.FalseBranch = childrenCopyCreator;
childrenCopyCreator.Successor = uniformSubScopesProcessor2;
useRecombinationBranch.Successor = uniformSubScopesProcessor3;
childrenCreator.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = recombinator;
uniformSubScopesProcessor1.Successor = null;
recombinator.Successor = strategyRecombinator;
strategyRecombinator.Successor = strategyMutator1;
strategyMutator1.Successor = mutator1;
mutator1.Successor = null;
uniformSubScopesProcessor2.Operator = strategyMutator2;
uniformSubScopesProcessor2.Successor = null;
strategyMutator2.Successor = mutator2;
mutator2.Successor = null;
uniformSubScopesProcessor3.Operator = evaluator;
uniformSubScopesProcessor3.Successor = subScopesCounter;
evaluator.Successor = parentsComparator;
parentsComparator.Successor = subScopesRemover_afterCompare;
subScopesRemover_afterCompare.Successor = null;
subScopesCounter.Successor = null;
plusOrCommaReplacementBranch.TrueBranch = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = subScopesProcessor2;
reevaluateElitesBranch.FalseBranch = null;
subScopesProcessor2.Operators.Add(uniformSubScopesProcessor4);
subScopesProcessor2.Operators.Add(new EmptyOperator());
uniformSubScopesProcessor4.Operator = evaluator2;
uniformSubScopesProcessor4.Successor = subScopesCounter2;
subScopesCounter2.Successor = null;
reevaluateElitesBranch.Successor = plusReplacement;
plusReplacement.Successor = bestSelector;
bestSelector.Successor = rightReducer;
plusOrCommaReplacementBranch.FalseBranch = commaReplacement;
plusOrCommaReplacementBranch.Successor = intCounter;
intCounter.Successor = maxGenerationsComparator;
maxGenerationsComparator.Successor = maxSelectionPressureComparator;
maxSelectionPressureComparator.Successor = maxEvaluatedSolutionsComparator;
maxEvaluatedSolutionsComparator.Successor = analyzer2;
analyzer2.Successor = conditionalBranchTerminate;
conditionalBranchTerminate.FalseBranch = conditionalBranchTerminateSelPressure;
conditionalBranchTerminate.TrueBranch = null;
conditionalBranchTerminate.Successor = null;
conditionalBranchTerminateSelPressure.FalseBranch = conditionalBranchTerminateEvalSolutions;
conditionalBranchTerminateSelPressure.TrueBranch = null;
conditionalBranchTerminateSelPressure.Successor = null;
conditionalBranchTerminateEvalSolutions.FalseBranch = selector;
conditionalBranchTerminateEvalSolutions.TrueBranch = null;
conditionalBranchTerminateEvalSolutions.Successor = null;
#endregion
}
public IslandOffspringSelectionGeneticAlgorithmMainLoop()
: base() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfIslands", "The number of islands."));
Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
Parameters.Add(new ValueLookupParameter<IOperator>("Migrator", "The migration strategy."));
Parameters.Add(new ValueLookupParameter<IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces part of the original population with the immigrants."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter<IOperator>("Visualizer", "The operator used to visualize solutions."));
Parameters.Add(new LookupParameter<IItem>("Visualization", "The item which represents the visualization of solutions."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorStart", "The initial value for the comparison factor."));
Parameters.Add(new ValueLookupParameter<IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
Parameters.Add(new ValueLookupParameter<IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator islandVariableCreator = new VariableCreator();
Placeholder islandAnalyzer1 = new Placeholder();
ResultsCollector islandResultsCollector1 = new ResultsCollector();
Assigner comparisonFactorInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
ConditionalBranch islandTerminatedBySelectionPressure1 = new ConditionalBranch();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
Placeholder islandAnalyzer2 = new Placeholder();
ResultsCollector islandResultsCollector2 = new ResultsCollector();
Comparator islandSelectionPressureComparator = new Comparator();
ConditionalBranch islandTerminatedBySelectionPressure2 = new ConditionalBranch();
IntCounter terminatedIslandsCounter = new IntCounter();
IntCounter generationsCounter = new IntCounter();
IntCounter generationsSinceLastMigrationCounter = new IntCounter();
Comparator migrationComparator = new Comparator();
ConditionalBranch migrationBranch = new ConditionalBranch();
Assigner resetTerminatedIslandsAssigner = new Assigner();
Assigner resetGenerationsSinceLastMigrationAssigner = new Assigner();
IntCounter migrationsCounter = new IntCounter();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Assigner reviveIslandAssigner = new Assigner();
Placeholder emigrantsSelector = new Placeholder();
Placeholder migrator = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder immigrationReplacer = new Placeholder();
Comparator generationsComparator = new Comparator();
Comparator terminatedIslandsComparator = new Comparator();
Comparator maxEvaluatedSolutionsComparator = new Comparator();
Placeholder comparisonFactorModifier = new Placeholder();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
ConditionalBranch terminatedIslandsCondition = new ConditionalBranch();
ConditionalBranch evaluatedSolutionsTerminationCondition = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Migrations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class IslandOffspringSelectionGeneticAlgorithm expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TerminatedIslands", new IntValue(0)));
islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(ResultsParameter.Name, new ResultCollection()));
islandVariableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("TerminateSelectionPressure", new BoolValue(false)));
islandVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
islandAnalyzer1.Name = "Island Analyzer (placeholder)";
islandAnalyzer1.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
islandResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
islandResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
islandResultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
comparisonFactorInitializer.Name = "Initialize Comparison Factor";
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Migrations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Comparison Factor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("IslandResults", "Result set for each island", ResultsParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
islandTerminatedBySelectionPressure1.Name = "Island Terminated ?";
islandTerminatedBySelectionPressure1.ConditionParameter.ActualName = "TerminateSelectionPressure";
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
islandAnalyzer2.Name = "Island Analyzer (placeholder)";
islandAnalyzer2.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
islandResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
islandResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
islandResultsCollector2.ResultsParameter.ActualName = "Results";
islandSelectionPressureComparator.Name = "SelectionPressure >= MaximumSelectionPressure ?";
islandSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
islandSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
islandSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
islandSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
islandTerminatedBySelectionPressure2.Name = "Island Terminated ?";
islandTerminatedBySelectionPressure2.ConditionParameter.ActualName = "TerminateSelectionPressure";
terminatedIslandsCounter.Name = "TerminatedIslands + 1";
terminatedIslandsCounter.ValueParameter.ActualName = "TerminatedIslands";
terminatedIslandsCounter.Increment = new IntValue(1);
generationsCounter.Name = "Generations + 1";
generationsCounter.ValueParameter.ActualName = "Generations";
generationsCounter.Increment = new IntValue(1);
generationsSinceLastMigrationCounter.Name = "GenerationsSinceLastMigration + 1";
generationsSinceLastMigrationCounter.ValueParameter.ActualName = "GenerationsSinceLastMigration";
generationsSinceLastMigrationCounter.Increment = new IntValue(1);
migrationComparator.Name = "GenerationsSinceLastMigration = MigrationInterval ?";
migrationComparator.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
migrationComparator.Comparison = new Comparison(ComparisonType.Equal);
migrationComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
migrationComparator.ResultParameter.ActualName = "Migrate";
migrationBranch.Name = "Migrate?";
migrationBranch.ConditionParameter.ActualName = "Migrate";
resetTerminatedIslandsAssigner.Name = "Reset TerminatedIslands";
resetTerminatedIslandsAssigner.LeftSideParameter.ActualName = "TerminatedIslands";
resetTerminatedIslandsAssigner.RightSideParameter.Value = new IntValue(0);
resetGenerationsSinceLastMigrationAssigner.Name = "Reset GenerationsSinceLastMigration";
resetGenerationsSinceLastMigrationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
resetGenerationsSinceLastMigrationAssigner.RightSideParameter.Value = new IntValue(0);
migrationsCounter.Name = "Migrations + 1";
migrationsCounter.IncrementParameter.Value = new IntValue(1);
migrationsCounter.ValueParameter.ActualName = "Migrations";
reviveIslandAssigner.Name = "Revive Island";
reviveIslandAssigner.LeftSideParameter.ActualName = "TerminateSelectionPressure";
reviveIslandAssigner.RightSideParameter.Value = new BoolValue(false);
emigrantsSelector.Name = "Emigrants Selector (placeholder)";
emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
migrator.Name = "Migrator (placeholder)";
migrator.OperatorParameter.ActualName = MigratorParameter.Name;
immigrationReplacer.Name = "Immigration Replacer (placeholder)";
immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
generationsComparator.Name = "Generations >= MaximumGenerations ?";
generationsComparator.LeftSideParameter.ActualName = "Generations";
generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
generationsComparator.ResultParameter.ActualName = "TerminateGenerations";
terminatedIslandsComparator.Name = "All Islands terminated ?";
terminatedIslandsComparator.LeftSideParameter.ActualName = "TerminatedIslands";
terminatedIslandsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
terminatedIslandsComparator.RightSideParameter.ActualName = NumberOfIslandsParameter.Name;
terminatedIslandsComparator.ResultParameter.ActualName = "TerminateTerminatedIslands";
maxEvaluatedSolutionsComparator.Name = "EvaluatedSolutions >= MaximumEvaluatedSolutions ?";
maxEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maxEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
comparisonFactorModifier.Name = "Update Comparison Factor (Placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
generationsTerminationCondition.Name = "Terminate (MaxGenerations) ?";
generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
terminatedIslandsCondition.Name = "Terminate (TerminatedIslands) ?";
terminatedIslandsCondition.ConditionParameter.ActualName = "TerminateTerminatedIslands";
evaluatedSolutionsTerminationCondition.Name = "Terminate (EvaluatedSolutions) ?";
evaluatedSolutionsTerminationCondition.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = islandVariableCreator;
uniformSubScopesProcessor0.Successor = comparisonFactorInitializer;
islandVariableCreator.Successor = islandAnalyzer1;
islandAnalyzer1.Successor = islandResultsCollector1;
islandResultsCollector1.Successor = null;
comparisonFactorInitializer.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = islandTerminatedBySelectionPressure1;
uniformSubScopesProcessor1.Successor = generationsCounter;
islandTerminatedBySelectionPressure1.TrueBranch = null;
islandTerminatedBySelectionPressure1.FalseBranch = mainOperator;
islandTerminatedBySelectionPressure1.Successor = null;
mainOperator.Successor = islandAnalyzer2;
islandAnalyzer2.Successor = islandResultsCollector2;
islandResultsCollector2.Successor = islandSelectionPressureComparator;
islandSelectionPressureComparator.Successor = islandTerminatedBySelectionPressure2;
islandTerminatedBySelectionPressure2.TrueBranch = terminatedIslandsCounter;
islandTerminatedBySelectionPressure2.FalseBranch = null;
islandTerminatedBySelectionPressure2.Successor = null;
generationsCounter.Successor = generationsSinceLastMigrationCounter;
generationsSinceLastMigrationCounter.Successor = migrationComparator;
migrationComparator.Successor = migrationBranch;
migrationBranch.TrueBranch = resetTerminatedIslandsAssigner;
migrationBranch.FalseBranch = null;
migrationBranch.Successor = generationsComparator;
resetTerminatedIslandsAssigner.Successor = resetGenerationsSinceLastMigrationAssigner;
resetGenerationsSinceLastMigrationAssigner.Successor = migrationsCounter;
migrationsCounter.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = reviveIslandAssigner;
uniformSubScopesProcessor2.Successor = migrator;
reviveIslandAssigner.Successor = emigrantsSelector;
emigrantsSelector.Successor = null;
migrator.Successor = uniformSubScopesProcessor3;
uniformSubScopesProcessor3.Operator = immigrationReplacer;
uniformSubScopesProcessor3.Successor = null;
immigrationReplacer.Successor = null;
generationsComparator.Successor = terminatedIslandsComparator;
terminatedIslandsComparator.Successor = maxEvaluatedSolutionsComparator;
maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = analyzer2;
analyzer2.Successor = generationsTerminationCondition;
generationsTerminationCondition.TrueBranch = null;
generationsTerminationCondition.FalseBranch = terminatedIslandsCondition;
generationsTerminationCondition.Successor = null;
terminatedIslandsCondition.TrueBranch = null;
terminatedIslandsCondition.FalseBranch = evaluatedSolutionsTerminationCondition;
terminatedIslandsCondition.Successor = null;
evaluatedSolutionsTerminationCondition.TrueBranch = null;
evaluatedSolutionsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
evaluatedSolutionsTerminationCondition.Successor = null;
#endregion
}
private void Initialize() {
ResultsCollector = new ResultsCollector();
ResultsCollector.CollectedValues.Add(CurrentVelocityBoundsParameter);
ResultsCollector.CollectedValues.Add(VelocityBoundsParameter);
foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>()) {
VelocityBoundsScalingOperatorParameter.ValidValues.Add(op);
op.ValueParameter.ActualName = VelocityBoundsScaleParameter.Name;
op.StartValueParameter.ActualName = VelocityBoundsStartValueParameter.Name;
op.EndValueParameter.ActualName = VelocityBoundsEndValueParameter.Name;
op.IndexParameter.ActualName = VelocityBoundsIndexParameter.Name;
op.StartIndexParameter.ActualName = VelocityBoundsStartIndexParameter.Name;
op.EndIndexParameter.ActualName = VelocityBoundsEndIndexParameter.Name;
}
VelocityBoundsScalingOperatorParameter.Value = null;
}
public AlpsOffspringSelectionGeneticAlgorithmMainLoop()
: base() {
Parameters.Add(new ValueLookupParameter<IRandom>("GlobalRandom", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<IRandom>("LocalRandom", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze all individuals from all layers combined."));
Parameters.Add(new ValueLookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each layer."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfLayers", "The number of layers."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer."));
Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
Parameters.Add(new ValueLookupParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
Parameters.Add(new ValueLookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
Parameters.Add(new ValueLookupParameter<IOperator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
var variableCreator = new VariableCreator() { Name = "Initialize" };
var initLayerAnalyzerProcessor = new SubScopesProcessor();
var layerVariableCreator = new VariableCreator() { Name = "Initialize Layer" };
var initLayerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
var layerResultCollector = new ResultsCollector() { Name = "Collect layer results" };
var initAnalyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
var resultsCollector = new ResultsCollector();
var matingPoolCreator = new MatingPoolCreator() { Name = "Create Mating Pools" };
var matingPoolProcessor = new UniformSubScopesProcessor() { Name = "Process Mating Pools" };
var initializeLayer = new Assigner() { Name = "Reset LayerEvaluatedSolutions" };
var mainOperator = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
var generationsIcrementor = new IntCounter() { Name = "Increment Generations" };
var evaluatedSolutionsReducer = new DataReducer() { Name = "Increment EvaluatedSolutions" };
var eldersEmigrator = CreateEldersEmigrator();
var layerOpener = CreateLayerOpener();
var layerReseeder = CreateReseeder();
var layerAnalyzerProcessor = new UniformSubScopesProcessor();
var layerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
var analyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
var termination = new TerminationOperator();
OperatorGraph.InitialOperator = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OpenLayers", new IntValue(1)));
variableCreator.Successor = initLayerAnalyzerProcessor;
initLayerAnalyzerProcessor.Operators.Add(layerVariableCreator);
initLayerAnalyzerProcessor.Successor = initAnalyzerPlaceholder;
layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Layer", new IntValue(0)));
layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("LayerResults"));
layerVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
layerVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
initLayerAnalyzerPlaceholder.Successor = layerResultCollector;
layerResultCollector.ResultsParameter.ActualName = "LayerResults";
layerResultCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
layerResultCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
layerResultCollector.Successor = null;
initAnalyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
initAnalyzerPlaceholder.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each Layer", "LayerResults"));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
resultsCollector.CopyValue = new BoolValue(false);
resultsCollector.Successor = matingPoolCreator;
matingPoolCreator.MatingPoolRangeParameter.Value = null;
matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
matingPoolCreator.Successor = matingPoolProcessor;
matingPoolProcessor.Parallel.Value = true;
matingPoolProcessor.Operator = initializeLayer;
matingPoolProcessor.Successor = generationsIcrementor;
initializeLayer.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
initializeLayer.RightSideParameter.Value = new IntValue(0);
initializeLayer.Successor = mainOperator;
mainOperator.RandomParameter.ActualName = LocalRandomParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
mainOperator.AgeParameter.ActualName = AgeParameter.Name;
mainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
mainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
mainOperator.Successor = null;
generationsIcrementor.ValueParameter.ActualName = "Generations";
generationsIcrementor.Increment = new IntValue(1);
generationsIcrementor.Successor = evaluatedSolutionsReducer;
evaluatedSolutionsReducer.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
evaluatedSolutionsReducer.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
evaluatedSolutionsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.Successor = eldersEmigrator;
eldersEmigrator.Successor = layerOpener;
layerOpener.Successor = layerReseeder;
layerReseeder.Successor = layerAnalyzerProcessor;
layerAnalyzerProcessor.Operator = layerAnalyzerPlaceholder;
layerAnalyzerProcessor.Successor = analyzerPlaceholder;
layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
analyzerPlaceholder.Successor = termination;
termination.TerminatorParameter.ActualName = TerminatorParameter.Name;
termination.ContinueBranch = matingPoolCreator;
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population."));
Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the genetic algorithm should be applied."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector1 = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
Placeholder selector = new Placeholder();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
Placeholder crossover = new Placeholder();
StochasticBranch stochasticBranch = new StochasticBranch();
Placeholder mutator = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder evaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
MergingReducer mergingReducer = new MergingReducer();
IntCounter intCounter = new IntCounter();
Comparator comparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch conditionalBranch = new ConditionalBranch();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class GeneticAlgorithm expects this to be called Generations
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.ResultsParameter.ActualName = "Results";
analyzer1.Name = "Analyzer";
analyzer1.OperatorParameter.ActualName = "Analyzer";
selector.Name = "Selector";
selector.OperatorParameter.ActualName = "Selector";
childrenCreator.ParentsPerChild = new IntValue(2);
crossover.Name = "Crossover";
crossover.OperatorParameter.ActualName = "Crossover";
stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
stochasticBranch.RandomParameter.ActualName = "Random";
mutator.Name = "Mutator";
mutator.OperatorParameter.ActualName = "Mutator";
subScopesRemover.RemoveAllSubScopes = true;
uniformSubScopesProcessor2.Parallel.Value = true;
evaluator.Name = "Evaluator";
evaluator.OperatorParameter.ActualName = "Evaluator";
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = "Maximization";
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
bestSelector.QualityParameter.ActualName = "Quality";
intCounter.Increment = new IntValue(1);
intCounter.ValueParameter.ActualName = "Generations";
comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator.LeftSideParameter.ActualName = "Generations";
comparator.ResultParameter.ActualName = "Terminate";
comparator.RightSideParameter.ActualName = "MaximumGenerations";
analyzer2.Name = "Analyzer";
analyzer2.OperatorParameter.ActualName = "Analyzer";
conditionalBranch.ConditionParameter.ActualName = "Terminate";
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = resultsCollector1;
resultsCollector1.Successor = analyzer1;
analyzer1.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = subScopesProcessor2;
childrenCreator.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = crossover;
uniformSubScopesProcessor1.Successor = uniformSubScopesProcessor2;
crossover.Successor = stochasticBranch;
stochasticBranch.FirstBranch = mutator;
stochasticBranch.SecondBranch = null;
stochasticBranch.Successor = subScopesRemover;
mutator.Successor = null;
subScopesRemover.Successor = null;
uniformSubScopesProcessor2.Operator = evaluator;
uniformSubScopesProcessor2.Successor = subScopesCounter;
evaluator.Successor = null;
subScopesCounter.Successor = null;
subScopesProcessor2.Operators.Add(bestSelector);
subScopesProcessor2.Operators.Add(new EmptyOperator());
subScopesProcessor2.Successor = mergingReducer;
bestSelector.Successor = rightReducer;
rightReducer.Successor = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor2;
reevaluateElitesBranch.FalseBranch = null;
reevaluateElitesBranch.Successor = null;
mergingReducer.Successor = intCounter;
intCounter.Successor = comparator;
comparator.Successor = analyzer2;
analyzer2.Successor = conditionalBranch;
conditionalBranch.FalseBranch = selector;
conditionalBranch.TrueBranch = null;
conditionalBranch.Successor = null;
#endregion
}
public AlpsGeneticAlgorithm()
: base() {
#region Add parameters
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
Parameters.Add(new ValueParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation.", new BoolValue(false)));
Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
Parameters.Add(new ValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(20)));
Parameters.Add(new ValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1.0)) { Hidden = true });
Parameters.Add(new ValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) { Hidden = true });
Parameters.Add(new ValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
#endregion
#region Create operators
var globalRandomCreator = new RandomCreator();
var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
var layer0Processor = new SubScopesProcessor();
var localRandomCreator = new LocalRandomCreator();
var layerSolutionsCreator = new SolutionsCreator();
var initializeAgeProcessor = new UniformSubScopesProcessor();
var initializeAge = new VariableCreator() { Name = "Initialize Age" };
var initializeCurrentPopulationSize = new SubScopesCounter() { Name = "Initialize CurrentPopulationCounter" };
var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
var resultsCollector = new ResultsCollector();
var mainLoop = new AlpsGeneticAlgorithmMainLoop();
#endregion
#region Create and parameterize operator graph
OperatorGraph.InitialOperator = globalRandomCreator;
globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
globalRandomCreator.SeedParameter.Value = null;
globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
globalRandomCreator.SetSeedRandomlyParameter.Value = null;
globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
globalRandomCreator.Successor = layer0Creator;
layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
layer0Creator.Successor = layer0Processor;
layer0Processor.Operators.Add(localRandomCreator);
layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
localRandomCreator.Successor = layerSolutionsCreator;
layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
layerSolutionsCreator.Successor = initializeAgeProcessor;
initializeAgeProcessor.Operator = initializeAge;
initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
initializeAge.Successor = null;
initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
initializeLocalEvaluatedSolutions.Successor = null;
initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
resultsCollector.Successor = mainLoop;
mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainLoop.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
mainLoop.AgeParameter.ActualName = "Age";
mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
#endregion
#region Set selectors
foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
SelectorParameter.ValidValues.Add(selector);
var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
if (defaultSelector != null) {
defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
SelectorParameter.Value = defaultSelector;
}
#endregion
#region Create analyzers
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
ageDistributionAnalyzer = new AgeDistributionAnalyzer();
layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
#endregion
#region Create terminators
generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
#endregion
#region Parameterize
UpdateAnalyzers();
ParameterizeAnalyzers();
ParameterizeSelectors();
UpdateTerminators();
ParameterizeAgeLimits();
#endregion
Initialize();
}
public CMAEvolutionStrategy()
: base() {
Parameters.Add(new FixedValueParameter<IntValue>(SeedName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new FixedValueParameter<IntValue>(PopulationSizeName, "λ (lambda) - the size of the offspring population.", new IntValue(20)));
Parameters.Add(new FixedValueParameter<IntValue>(InitialIterationsName, "The number of iterations that should be performed with only axis parallel mutation.", new IntValue(0)));
Parameters.Add(new FixedValueParameter<DoubleArray>(InitialSigmaName, "The initial sigma can be a single value or a value for each dimension. All values need to be > 0.", new DoubleArray(new[] { 0.5 })));
Parameters.Add(new OptionalValueParameter<IntValue>(MuName, "Optional, the mu best offspring that should be considered for update of the new mean and strategy parameters. If not given it will be automatically calculated."));
Parameters.Add(new ConstrainedValueParameter<ICMARecombinator>(CMARecombinatorName, "The operator used to calculate the new mean."));
Parameters.Add(new ConstrainedValueParameter<ICMAManipulator>(CMAMutatorName, "The operator used to manipulate a point."));
Parameters.Add(new ConstrainedValueParameter<ICMAInitializer>(CMAInitializerName, "The operator that initializes the covariance matrix and strategy parameters."));
Parameters.Add(new ConstrainedValueParameter<ICMAUpdater>(CMAUpdaterName, "The operator that updates the covariance matrix and strategy parameters."));
Parameters.Add(new ValueParameter<MultiAnalyzer>(AnalyzerName, "The operator used to analyze each generation.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter<IntValue>(MaximumGenerationsName, "The maximum number of generations which should be processed.", new IntValue(1000)));
Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluatedSolutionsName, "The maximum number of evaluated solutions that should be computed.", new IntValue(int.MaxValue)));
Parameters.Add(new FixedValueParameter<DoubleValue>(TargetQualityName, "(stopFitness) Surpassing this quality value terminates the algorithm.", new DoubleValue(double.NaN)));
Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumQualityChangeName, "(stopTolFun) If the range of fitness values is less than a certain value the algorithm terminates (set to 0 or positive value to enable).", new DoubleValue(double.NaN)));
Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumQualityHistoryChangeName, "(stopTolFunHist) If the range of fitness values is less than a certain value for a certain time the algorithm terminates (set to 0 or positive to enable).", new DoubleValue(double.NaN)));
Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumStandardDeviationName, "(stopTolXFactor) If the standard deviation falls below a certain value the algorithm terminates (set to 0 or positive to enable).", new DoubleValue(double.NaN)));
Parameters.Add(new FixedValueParameter<DoubleValue>(MaximumStandardDeviationChangeName, "(stopTolUpXFactor) If the standard deviation changes by a value larger than this parameter the algorithm stops (set to a value > 0 to enable).", new DoubleValue(double.NaN)));
var randomCreator = new RandomCreator();
var variableCreator = new VariableCreator();
var resultsCollector = new ResultsCollector();
var cmaInitializer = new Placeholder();
solutionCreator = new Placeholder();
var subScopesCreator = new SubScopesCreator();
var ussp1 = new UniformSubScopesProcessor();
populationSolutionCreator = new Placeholder();
var cmaMutator = new Placeholder();
var ussp2 = new UniformSubScopesProcessor();
evaluator = new Placeholder();
var subScopesCounter = new SubScopesCounter();
sorter = new SubScopesSorter();
var analyzer = new Placeholder();
var cmaRecombinator = new Placeholder();
var generationsCounter = new IntCounter();
var cmaUpdater = new Placeholder();
terminator = new Terminator();
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 = variableCreator;
variableCreator.Name = "Initialize Variables";
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
variableCreator.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions"));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.Successor = cmaInitializer;
cmaInitializer.Name = "Initialize Strategy Parameters";
cmaInitializer.OperatorParameter.ActualName = CMAInitializerParameter.Name;
cmaInitializer.Successor = subScopesCreator;
subScopesCreator.NumberOfSubScopesParameter.ActualName = PopulationSizeParameter.Name;
subScopesCreator.Successor = ussp1;
ussp1.Name = "Create population";
ussp1.Parallel = new BoolValue(false);
ussp1.Operator = populationSolutionCreator;
ussp1.Successor = solutionCreator;
populationSolutionCreator.Name = "Initialize arx";
// populationSolutionCreator.OperatorParameter will be wired
populationSolutionCreator.Successor = null;
solutionCreator.Name = "Initialize xmean";
// solutionCreator.OperatorParameter will be wired
solutionCreator.Successor = cmaMutator;
cmaMutator.Name = "Sample population";
cmaMutator.OperatorParameter.ActualName = CMAMutatorParameter.Name;
cmaMutator.Successor = ussp2;
ussp2.Name = "Evaluate offspring";
ussp2.Parallel = new BoolValue(true);
ussp2.Operator = evaluator;
ussp2.Successor = subScopesCounter;
evaluator.Name = "Evaluator";
// evaluator.OperatorParameter will be wired
evaluator.Successor = null;
subScopesCounter.Name = "Count EvaluatedSolutions";
subScopesCounter.AccumulateParameter.Value = new BoolValue(true);
subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
subScopesCounter.Successor = sorter;
// sorter.ValueParameter will be wired
// sorter.DescendingParameter will be wired
sorter.Successor = analyzer;
analyzer.Name = "Analyzer";
analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;
analyzer.Successor = cmaRecombinator;
cmaRecombinator.Name = "Create new xmean";
cmaRecombinator.OperatorParameter.ActualName = CMARecombinatorParameter.Name;
cmaRecombinator.Successor = generationsCounter;
generationsCounter.Name = "Generations++";
generationsCounter.IncrementParameter.Value = new IntValue(1);
generationsCounter.ValueParameter.ActualName = "Generations";
generationsCounter.Successor = cmaUpdater;
cmaUpdater.Name = "Update distributions";
cmaUpdater.OperatorParameter.ActualName = CMAUpdaterParameter.Name;
cmaUpdater.Successor = terminator;
terminator.Continue = cmaMutator;
terminator.Terminate = null;
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
cmaAnalyzer = new CMAAnalyzer();
InitializeOperators();
RegisterEventHandlers();
Parameterize();
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolArray>("Maximization", "True if an objective should be maximized, or false if it should be minimized."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("Qualities", "The vector of quality values."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The population size."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<PercentValue>("CrossoverProbability", "The probability that the crossover operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("DominateOnEqualQualities", "Flag which determines wether solutions with equal quality values should be treated as dominated."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector1 = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
Placeholder selector = new Placeholder();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
StochasticBranch crossoverStochasticBranch = new StochasticBranch();
Placeholder crossover = new Placeholder();
ParentCopyCrossover noCrossover = new ParentCopyCrossover();
StochasticBranch mutationStochasticBranch = new StochasticBranch();
Placeholder mutator = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder evaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
MergingReducer mergingReducer = new MergingReducer();
RankAndCrowdingSorter rankAndCrowdingSorter = new RankAndCrowdingSorter();
LeftSelector leftSelector = new LeftSelector();
RightReducer rightReducer = new RightReducer();
IntCounter intCounter = new IntCounter();
Comparator comparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch conditionalBranch = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer1.Name = "Analyzer";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
selector.Name = "Selector";
selector.OperatorParameter.ActualName = SelectorParameter.Name;
childrenCreator.ParentsPerChild = new IntValue(2);
crossoverStochasticBranch.ProbabilityParameter.ActualName = CrossoverProbabilityParameter.Name;
crossoverStochasticBranch.RandomParameter.ActualName = RandomParameter.Name;
crossover.Name = "Crossover";
crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
noCrossover.Name = "Clone parent";
noCrossover.RandomParameter.ActualName = RandomParameter.Name;
mutationStochasticBranch.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mutationStochasticBranch.RandomParameter.ActualName = RandomParameter.Name;
mutator.Name = "Mutator";
mutator.OperatorParameter.ActualName = MutatorParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
uniformSubScopesProcessor2.Parallel.Value = true;
evaluator.Name = "Evaluator";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
rankAndCrowdingSorter.DominateOnEqualQualitiesParameter.ActualName = DominateOnEqualQualitiesParameter.Name;
rankAndCrowdingSorter.CrowdingDistanceParameter.ActualName = "CrowdingDistance";
rankAndCrowdingSorter.RankParameter.ActualName = "Rank";
leftSelector.CopySelected = new BoolValue(false);
leftSelector.NumberOfSelectedSubScopesParameter.ActualName = PopulationSizeParameter.Name;
intCounter.Increment = new IntValue(1);
intCounter.ValueParameter.ActualName = "Generations";
comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator.LeftSideParameter.ActualName = "Generations";
comparator.ResultParameter.ActualName = "Terminate";
comparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
analyzer2.Name = "Analyzer";
analyzer2.OperatorParameter.ActualName = "Analyzer";
conditionalBranch.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = resultsCollector1;
resultsCollector1.Successor = analyzer1;
analyzer1.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = mergingReducer;
childrenCreator.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = crossoverStochasticBranch;
uniformSubScopesProcessor1.Successor = uniformSubScopesProcessor2;
crossoverStochasticBranch.FirstBranch = crossover;
crossoverStochasticBranch.SecondBranch = noCrossover;
crossoverStochasticBranch.Successor = mutationStochasticBranch;
crossover.Successor = null;
noCrossover.Successor = null;
mutationStochasticBranch.FirstBranch = mutator;
mutationStochasticBranch.SecondBranch = null;
mutationStochasticBranch.Successor = subScopesRemover;
mutator.Successor = null;
subScopesRemover.Successor = null;
uniformSubScopesProcessor2.Operator = evaluator;
uniformSubScopesProcessor2.Successor = subScopesCounter;
evaluator.Successor = null;
subScopesCounter.Successor = null;
mergingReducer.Successor = rankAndCrowdingSorter;
rankAndCrowdingSorter.Successor = leftSelector;
leftSelector.Successor = rightReducer;
rightReducer.Successor = intCounter;
intCounter.Successor = comparator;
comparator.Successor = analyzer2;
analyzer2.Successor = conditionalBranch;
conditionalBranch.FalseBranch = selector;
conditionalBranch.TrueBranch = null;
conditionalBranch.Successor = null;
#endregion
}
public VariableNeighborhoodSearch()
: base() {
Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ConstrainedValueParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation"));
Parameters.Add(new ConstrainedValueParameter<IMultiNeighborhoodShakingOperator>("ShakingOperator", "The operator that performs the shaking of solutions."));
Parameters.Add(new FixedValueParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed.", new IntValue(50)));
Parameters.Add(new FixedValueParameter<IntValue>("LocalImprovementMaximumIterations", "The maximum number of iterations which should be performed in the local improvement phase.", new IntValue(50)));
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution and moves.", new MultiAnalyzer()));
RandomCreator randomCreator = new RandomCreator();
SolutionsCreator solutionsCreator = new SolutionsCreator();
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector = new ResultsCollector();
VariableNeighborhoodSearchMainLoop mainLoop = new VariableNeighborhoodSearchMainLoop();
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 = variableCreator;
variableCreator.Name = "Initialize Evaluated Solutions";
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("CurrentNeighborhoodIndex", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NeighborhoodCount", new IntValue(0)));
variableCreator.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.Successor = mainLoop;
mainLoop.IterationsParameter.ActualName = "Iterations";
mainLoop.CurrentNeighborhoodIndexParameter.ActualName = "CurrentNeighborhoodIndex";
mainLoop.NeighborhoodCountParameter.ActualName = "NeighborhoodCount";
mainLoop.LocalImprovementParameter.ActualName = LocalImprovementParameter.Name;
mainLoop.ShakingOperatorParameter.ActualName = ShakingOperatorParameter.Name;
mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
mainLoop.ResultsParameter.ActualName = "Results";
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
InitializeLocalImprovementOperators();
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
ParameterizeAnalyzers();
UpdateAnalyzers();
RegisterEventHandlers();
}
protected SymbolicDataAnalysisSingleObjectivePruningAnalyzer(SymbolicDataAnalysisSingleObjectivePruningAnalyzer original, Cloner cloner)
: base(original, cloner) {
if (original.prunedNodesReducer != null)
this.prunedNodesReducer = (DataReducer)original.prunedNodesReducer.Clone();
if (original.prunedSubtreesReducer != null)
this.prunedSubtreesReducer = (DataReducer)original.prunedSubtreesReducer.Clone();
if (original.prunedTreesReducer != null)
this.prunedTreesReducer = (DataReducer)original.prunedTreesReducer.Clone();
if (original.valuesCollector != null)
this.valuesCollector = (DataTableValuesCollector)original.valuesCollector.Clone();
if (original.resultsCollector != null)
this.resultsCollector = (ResultsCollector)original.resultsCollector.Clone();
}
public RandomSearchAlgorithm()
: base() {
#region Add parameters
Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solutions each iteration.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter<IntValue>("MaximumEvaluatedSolutions", "The number of random solutions the algorithm should evaluate.", new IntValue(1000)));
Parameters.Add(new FixedValueParameter<IntValue>("BatchSize", "The number of random solutions that are evaluated (in parallel) per iteration.", new IntValue(100)));
Parameters.Add(new FixedValueParameter<IntValue>("MaximumIterations", "The number of iterations that the algorithm will run.", new IntValue(10)) { Hidden = true });
Parameters.Add(new FixedValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()) { Hidden = true });
#endregion
#region Create operators
var randomCreator = new RandomCreator();
var variableCreator = new VariableCreator() { Name = "Initialize Variables" };
var resultsCollector = new ResultsCollector();
var solutionCreator = new SolutionsCreator() { Name = "Create Solutions" };
var analyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
var evaluationsCounter = new IntCounter() { Name = "Increment EvaluatedSolutions" };
var subScopesRemover = new SubScopesRemover();
var iterationsCounter = new IntCounter() { Name = "Increment Iterations" };
var terminationOperator = new TerminationOperator();
#endregion
#region Create and parameterize operator graph
OperatorGraph.InitialOperator = randomCreator;
randomCreator.SeedParameter.Value = null;
randomCreator.SeedParameter.ActualName = SeedParameter.Name;
randomCreator.SetSeedRandomlyParameter.Value = null;
randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
randomCreator.Successor = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
variableCreator.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations", "The current iteration number."));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The current number of evaluated solutions."));
resultsCollector.Successor = solutionCreator;
solutionCreator.NumberOfSolutionsParameter.ActualName = BatchSizeParameter.Name;
solutionCreator.ParallelParameter.Value.Value = true;
solutionCreator.Successor = evaluationsCounter;
evaluationsCounter.ValueParameter.ActualName = "EvaluatedSolutions";
evaluationsCounter.Increment = null;
evaluationsCounter.IncrementParameter.ActualName = BatchSizeParameter.Name;
evaluationsCounter.Successor = analyzerPlaceholder;
analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
analyzerPlaceholder.Successor = subScopesRemover;
subScopesRemover.RemoveAllSubScopes = true;
subScopesRemover.Successor = iterationsCounter;
iterationsCounter.ValueParameter.ActualName = "Iterations";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.Successor = terminationOperator;
terminationOperator.TerminatorParameter.ActualName = TerminatorParameter.Name;
terminationOperator.ContinueBranch = solutionCreator;
#endregion
#region Create analyzers
singleObjectiveQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
#endregion
#region Create terminators
evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, MaximumEvaluatedSolutionsParameter) { Name = "Evaluated solutions." };
qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
#endregion
#region Parameterize
UpdateAnalyzers();
ParameterizeAnalyzers();
UpdateTerminators();
#endregion
Initialize();
}
public OffspringSelectionEvolutionStrategy()
: base() {
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "µ (mu) - the size of the population.", new IntValue(20)));
Parameters.Add(new ValueParameter<IntValue>("ParentsPerChild", "ρ (rho) - how many parents should be recombined.", new IntValue(1)));
Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
Parameters.Add(new ValueParameter<BoolValue>("PlusSelection", "True for plus selection (elitist population), false for comma selection (non-elitist population).", new BoolValue(true)));
Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
Parameters.Add(new OptionalConstrainedValueParameter<ICrossover>("Recombinator", "The operator used to cross solutions."));
Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new OptionalConstrainedValueParameter<IStrategyParameterCreator>("StrategyParameterCreator", "The operator that creates the strategy parameters."));
Parameters.Add(new OptionalConstrainedValueParameter<IStrategyParameterCrossover>("StrategyParameterCrossover", "The operator that recombines the strategy parameters."));
Parameters.Add(new OptionalConstrainedValueParameter<IStrategyParameterManipulator>("StrategyParameterManipulator", "The operator that manipulates the strategy parameters."));
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
Parameters.Add(new ValueLookupParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(40)));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
Parameters.Add(new ValueParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions.", new IntValue(int.MaxValue)));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1].", new DoubleValue(0.5)));
RandomCreator randomCreator = new RandomCreator();
SolutionsCreator solutionsCreator = new SolutionsCreator();
SubScopesCounter subScopesCounter = new SubScopesCounter();
UniformSubScopesProcessor strategyVectorProcessor = new UniformSubScopesProcessor();
Placeholder strategyVectorCreator = new Placeholder();
ResultsCollector resultsCollector = new ResultsCollector();
OffspringSelectionEvolutionStrategyMainLoop mainLoop = new OffspringSelectionEvolutionStrategyMainLoop();
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.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
solutionsCreator.Successor = subScopesCounter;
subScopesCounter.Name = "Initialize EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
subScopesCounter.Successor = strategyVectorProcessor;
strategyVectorProcessor.Operator = strategyVectorCreator;
strategyVectorProcessor.Successor = resultsCollector;
strategyVectorCreator.OperatorParameter.ActualName = "StrategyParameterCreator";
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.Successor = mainLoop;
mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainLoop.ParentsPerChildParameter.ActualName = ParentsPerChildParameter.Name;
mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
mainLoop.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
mainLoop.RecombinatorParameter.ActualName = RecombinatorParameter.Name;
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.ResultsParameter.ActualName = "Results";
mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainLoop.MaximumEvaluatedSolutionsParameter.ActualName = MaximumEvaluatedSolutionsParameter.Name;
mainLoop.SelectedParentsParameter.ActualName = SelectedParentsParameter.Name;
mainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainLoop.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainLoop.SelectionPressureParameter.ActualName = "SelectionPressure";
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
selectionPressureAnalyzer = new ValueAnalyzer();
ParameterizeAnalyzers();
UpdateAnalyzers();
Initialize();
}
public OffspringSelectionGeneticAlgorithm()
: base() {
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start).", new DoubleValue(0)));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorUpperBound", "The upper bound of the comparison factor (end).", new DoubleValue(1)));
Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("ComparisonFactorModifier", "The operator used to modify the comparison factor.", new ItemSet<IDiscreteDoubleValueModifier>(new IDiscreteDoubleValueModifier[] { new LinearDiscreteDoubleValueModifier() }), new LinearDiscreteDoubleValueModifier()));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
Parameters.Add(new ValueLookupParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(200)));
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
Parameters.Add(new ValueParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions (approximately).", new IntValue(int.MaxValue)));
Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
RandomCreator randomCreator = new RandomCreator();
SolutionsCreator solutionsCreator = new SolutionsCreator();
SubScopesCounter subScopesCounter = new SubScopesCounter();
ResultsCollector resultsCollector = new ResultsCollector();
OffspringSelectionGeneticAlgorithmMainLoop mainLoop = new OffspringSelectionGeneticAlgorithmMainLoop();
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.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
solutionsCreator.Successor = subScopesCounter;
subScopesCounter.Name = "Initialize EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
subScopesCounter.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", "", "EvaluatedSolutions"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.Successor = mainLoop;
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.ComparisonFactorModifierParameter.ActualName = ComparisonFactorModifierParameter.Name;
mainLoop.ComparisonFactorParameter.ActualName = "ComparisonFactor";
mainLoop.ComparisonFactorStartParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
mainLoop.ResultsParameter.ActualName = "Results";
mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
SelectorParameter.ValidValues.Add(selector);
ISelector proportionalSelector = SelectorParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("ProportionalSelector"));
if (proportionalSelector != null) SelectorParameter.Value = proportionalSelector;
ParameterizeSelectors();
foreach (IDiscreteDoubleValueModifier modifier in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
ComparisonFactorModifierParameter.ValidValues.Add(modifier);
IDiscreteDoubleValueModifier linearModifier = ComparisonFactorModifierParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("LinearDiscreteDoubleValueModifier"));
if (linearModifier != null) ComparisonFactorModifierParameter.Value = linearModifier;
ParameterizeComparisonFactorModifiers();
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
selectionPressureAnalyzer = new ValueAnalyzer();
successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
ParameterizeAnalyzers();
UpdateAnalyzers();
Initialize();
}
public SimulatedAnnealing()
: base() {
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ConstrainedValueParameter<IMultiMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>("AnnealingOperator", "The operator used to modify the temperature."));
Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(100)));
Parameters.Add(new ValueParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again).", new IntValue(10)));
Parameters.Add(new ValueParameter<DoubleValue>("StartTemperature", "The initial temperature.", new DoubleValue(100)));
Parameters.Add(new ValueParameter<DoubleValue>("EndTemperature", "The final temperature which should be reached when iterations reaches maximum iterations.", new DoubleValue(1e-6)));
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
RandomCreator randomCreator = new RandomCreator();
SolutionsCreator solutionsCreator = new SolutionsCreator();
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector = new ResultsCollector();
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 = variableCreator;
variableCreator.Name = "Initialize EvaluatedMoves";
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedMoves", new IntValue()));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
variableCreator.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Moves", null, "EvaluatedMoves"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.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.TemperatureParameter.ActualName = "Temperature";
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;
mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
mainLoop.IterationsParameter.ActualName = "Iterations";
foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
AnnealingOperatorParameter.ValidValues.Add(op);
ParameterizeAnnealingOperators();
qualityAnalyzer = new QualityAnalyzer();
temperatureAnalyzer = new SingleValueAnalyzer();
temperatureAnalyzer.Name = "TemperatureAnalyzer";
ParameterizeAnalyzers();
UpdateAnalyzers();
Initialize();
}
public OldestAverageYoungestAgeAnalyzer()
: base() {
#region Create parameters
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The value which represents the age of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentOldestAge", "The oldest age value found in the current population."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAverageAge", "The average age value of all solutions in the current population."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentYoungestAge", "The youngest age value found in the current population."));
Parameters.Add(new ValueLookupParameter<DataTable>("Ages", "The data table to store the current oldest, current average, current youngest age value."));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection where the analysis values should be stored."));
CurrentOldestAgeParameter.Hidden = true;
CurrentAverageAgeParameter.Hidden = true;
CurrentYoungestAgeParameter.Hidden = true;
AgesParameter.Hidden = true;
#endregion
#region Create operators
var oldestAverageYoungestAgeCalculator = new OldestAverageYoungestAgeCalculator();
var dataTableValuesCollector = new DataTableValuesCollector();
var resultsCollector = new ResultsCollector();
oldestAverageYoungestAgeCalculator.AverageAgeParameter.ActualName = CurrentAverageAgeParameter.Name;
oldestAverageYoungestAgeCalculator.OldestAgeParameter.ActualName = CurrentOldestAgeParameter.Name;
oldestAverageYoungestAgeCalculator.AgeParameter.ActualName = AgeParameter.Name;
oldestAverageYoungestAgeCalculator.AgeParameter.Depth = AgeParameter.Depth;
oldestAverageYoungestAgeCalculator.YoungestAgeParameter.ActualName = CurrentYoungestAgeParameter.Name;
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentOldestAge", null, CurrentOldestAgeParameter.Name));
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAverageAge", null, CurrentAverageAgeParameter.Name));
dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentYoungestAge", null, CurrentYoungestAgeParameter.Name));
dataTableValuesCollector.DataTableParameter.ActualName = AgesParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(AgesParameter.Name));
resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = oldestAverageYoungestAgeCalculator;
oldestAverageYoungestAgeCalculator.Successor = dataTableValuesCollector;
dataTableValuesCollector.Successor = resultsCollector;
resultsCollector.Successor = null;
#endregion
Initialize();
}
protected ResultsCollector(ResultsCollector original, Cloner cloner) : base(original, cloner)
{
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new LookupParameter<IntValue>("Iterations", "The iterations to count."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
Parameters.Add(new ValueLookupParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation."));
Parameters.Add(new ValueLookupParameter<IMultiNeighborhoodShakingOperator>("ShakingOperator", "The shaking operation."));
Parameters.Add(new LookupParameter<IntValue>("CurrentNeighborhoodIndex", "The index of the current shaking operation that should be applied."));
Parameters.Add(new LookupParameter<IntValue>("NeighborhoodCount", "The number of neighborhood operators used for shaking."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
CombinedOperator iteration = new CombinedOperator();
Assigner iterationInit = new Assigner();
SubScopesCloner createChild = new SubScopesCloner();
SubScopesProcessor childProcessor = new SubScopesProcessor();
Assigner qualityAssigner = new Assigner();
Placeholder shaking = new Placeholder();
Placeholder localImprovement = new Placeholder();
Placeholder evaluator = new Placeholder();
IntCounter evalCounter = new IntCounter();
QualityComparator qualityComparator = new QualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Assigner bestQualityUpdater = new Assigner();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
IntCounter indexCounter = new IntCounter();
Assigner indexResetter = new Assigner();
Placeholder analyzer2 = new Placeholder();
Comparator indexComparator = new Comparator();
ConditionalBranch indexTermination = new ConditionalBranch();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("IsBetter", new BoolValue(false)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("BestQuality", new DoubleValue(0)));
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = "BestQuality";
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
iteration.Name = "MainLoop Body";
iterationInit.Name = "Init k = 0";
iterationInit.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
iterationInit.RightSideParameter.Value = new IntValue(0);
createChild.Name = "Clone solution";
qualityAssigner.Name = "Assign quality";
qualityAssigner.LeftSideParameter.ActualName = "OriginalQuality";
qualityAssigner.RightSideParameter.ActualName = QualityParameter.Name;
shaking.Name = "Shaking operator (placeholder)";
shaking.OperatorParameter.ActualName = ShakingOperatorParameter.Name;
localImprovement.Name = "Local improvement operator (placeholder)";
localImprovement.OperatorParameter.ActualName = LocalImprovementParameter.Name;
evaluator.Name = "Evaluation operator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
evalCounter.Name = "Count evaluations";
evalCounter.Increment.Value = 1;
evalCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.ActualName;
qualityComparator.LeftSideParameter.ActualName = QualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = "OriginalQuality";
qualityComparator.ResultParameter.ActualName = "IsBetter";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.LeftSideParameter.ActualName = "BestQuality";
bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
indexCounter.Name = "Count neighborhood index";
indexCounter.Increment.Value = 1;
indexCounter.ValueParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexResetter.Name = "Reset neighborhood index";
indexResetter.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexResetter.RightSideParameter.Value = new IntValue(0);
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
indexComparator.Name = "k < k_max (index condition)";
indexComparator.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexComparator.RightSideParameter.ActualName = NeighborhoodCountParameter.Name;
indexComparator.Comparison = new Comparison(ComparisonType.Less);
indexComparator.ResultParameter.ActualName = "ContinueIteration";
indexTermination.Name = "Index Termination Condition";
indexTermination.ConditionParameter.ActualName = "ContinueIteration";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
/////////
resultsCollector1.Successor = iteration;
iteration.OperatorGraph.InitialOperator = iterationInit;
iteration.Successor = iterationsCounter;
iterationInit.Successor = createChild;
createChild.Successor = childProcessor;
childProcessor.Operators.Add(new EmptyOperator());
childProcessor.Operators.Add(qualityAssigner);
childProcessor.Successor = bestSelector;
/////////
qualityAssigner.Successor = shaking;
shaking.Successor = evaluator;
evaluator.Successor = evalCounter;
evalCounter.Successor = localImprovement;
localImprovement.Successor = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = bestQualityUpdater;
improvesQualityBranch.FalseBranch = indexCounter;
bestQualityUpdater.Successor = indexResetter;
indexResetter.Successor = null;
indexCounter.Successor = null;
/////////
bestSelector.Successor = rightReducer;
rightReducer.Successor = analyzer2;
analyzer2.Successor = indexComparator;
indexComparator.Successor = indexTermination;
indexTermination.TrueBranch = createChild;
indexTermination.FalseBranch = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = iteration;
#endregion
}
public TabuSearch()
: base() {
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ConstrainedValueParameter<IMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
Parameters.Add(new ConstrainedValueParameter<ITabuChecker>("TabuChecker", "The operator to check whether a move is tabu or not."));
Parameters.Add(new ConstrainedValueParameter<ITabuMaker>("TabuMaker", "The operator used to insert attributes of a move into the tabu list."));
Parameters.Add(new ValueParameter<IntValue>("TabuTenure", "The length of the tabu list.", new IntValue(10)));
Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
Parameters.Add(new ValueParameter<IntValue>("SampleSize", "The neighborhood size for stochastic sampling move generators", new IntValue(100)));
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer()));
RandomCreator randomCreator = new RandomCreator();
SolutionsCreator solutionsCreator = new SolutionsCreator();
VariableCreator variableCreator = new VariableCreator();
ResultsCollector resultsCollector = new ResultsCollector();
TabuSearchMainLoop mainLoop = new TabuSearchMainLoop();
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 = variableCreator;
variableCreator.Name = "Initialize EvaluatedMoves";
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedMoves", new IntValue()));
variableCreator.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Moves", null, "EvaluatedMoves"));
resultsCollector.ResultsParameter.ActualName = "Results";
resultsCollector.Successor = mainLoop;
mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
mainLoop.TabuCheckerParameter.ActualName = TabuCheckerParameter.Name;
mainLoop.TabuMakerParameter.ActualName = TabuMakerParameter.Name;
mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
mainLoop.ResultsParameter.ActualName = "Results";
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
moveQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
tabuNeighborhoodAnalyzer = new TabuNeighborhoodAnalyzer();
ParameterizeAnalyzers();
UpdateAnalyzers();
Initialize();
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new LookupParameter<DoubleValue>("BestLocalQuality", "The value which represents the best quality found so far."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The problem's best known quality value found so far."));
Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations performed."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution and moves."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor mainProcessor = new SubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
BestSelector bestSelector = new BestSelector();
SubScopesProcessor moveMakingProcessor = new SubScopesProcessor();
UniformSubScopesProcessor selectedMoveMakingProcessor = new UniformSubScopesProcessor();
QualityComparator qualityComparator = new QualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Placeholder moveMaker = new Placeholder();
Assigner bestQualityUpdater = new Assigner();
ResultsCollector resultsCollector2 = new ResultsCollector();
MergingReducer mergingReducer = new MergingReducer();
Placeholder analyzer2 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
moveGenerator.Name = "MoveGenerator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluationProcessor.Parallel = new BoolValue(true);
moveEvaluator.Name = "MoveEvaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
bestSelector.QualityParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
qualityComparator.ResultParameter.ActualName = "IsBetter";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
moveMaker.Name = "MoveMaker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
resultsCollector2.CopyValue = new BoolValue(false);
resultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
resultsCollector2.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = subScopesProcessor0; // don't change this without adapting the constructor of LocalSearchImprovementOperator
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = resultsCollector1;
bestQualityInitializer.Successor = analyzer1;
analyzer1.Successor = null;
resultsCollector1.Successor = mainProcessor;
mainProcessor.Operators.Add(moveGenerator);
mainProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = null;
subScopesCounter.Successor = bestSelector;
bestSelector.Successor = moveMakingProcessor;
moveMakingProcessor.Operators.Add(new EmptyOperator());
moveMakingProcessor.Operators.Add(selectedMoveMakingProcessor);
moveMakingProcessor.Successor = mergingReducer;
selectedMoveMakingProcessor.Operator = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = moveMaker;
improvesQualityBranch.FalseBranch = null;
improvesQualityBranch.Successor = null;
moveMaker.Successor = bestQualityUpdater;
bestQualityUpdater.Successor = null;
mergingReducer.Successor = analyzer2;
analyzer2.Successor = subScopesRemover;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = mainProcessor;
#endregion
}
