Example #1
0
        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();
        }
Example #2
0
        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;
        }
Example #3
0
 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();
     }
 }
        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
        }
Example #5
0
        public ScatterSearch()
            : base()
        {
            #region Create parameters
            Parameters.Add(new ValueParameter <MultiAnalyzer>("Analyzer", "The analyzer used to analyze each iteration.", new MultiAnalyzer()));
            Parameters.Add(new ConstrainedValueParameter <ICrossover>("Crossover", "The operator used to cross solutions."));
            Parameters.Add(new ValueParameter <BoolValue>("ExecutePathRelinking", "True if path relinking should be executed instead of crossover, otherwise false.", new BoolValue(false)));
            Parameters.Add(new ConstrainedValueParameter <IImprovementOperator>("Improver", "The operator used to improve solutions."));
            Parameters.Add(new ValueParameter <IntValue>("MaximumIterations", "The maximum number of iterations which should be processed.", new IntValue(100)));
            Parameters.Add(new ValueParameter <IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set.", new IntValue(5)));
            Parameters.Add(new ConstrainedValueParameter <IPathRelinker>("PathRelinker", "The operator used to execute path relinking."));
            Parameters.Add(new ValueParameter <IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(50)));
            Parameters.Add(new ValueParameter <IntValue>("ReferenceSetSize", "The size of the reference set.", new IntValue(20)));
            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 <ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
            #endregion

            #region Create operators
            RandomCreator             randomCreator             = new RandomCreator();
            SolutionsCreator          solutionsCreator          = new SolutionsCreator();
            UniformSubScopesProcessor uniformSubScopesProcessor = new UniformSubScopesProcessor();
            Placeholder           solutionEvaluator             = new Placeholder();
            Placeholder           solutionImprover = new Placeholder();
            VariableCreator       variableCreator  = new VariableCreator();
            DataReducer           dataReducer      = new DataReducer();
            ResultsCollector      resultsCollector = new ResultsCollector();
            BestSelector          bestSelector     = new BestSelector();
            ScatterSearchMainLoop mainLoop         = new ScatterSearchMainLoop();
            #endregion

            #region Create operator graph
            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.Name = "DiversificationGenerationMethod";
            solutionsCreator.NumberOfSolutionsParameter.ActualName = "PopulationSize";
            solutionsCreator.Successor = uniformSubScopesProcessor;

            uniformSubScopesProcessor.Operator = solutionImprover;
            uniformSubScopesProcessor.ParallelParameter.Value = new BoolValue(true);
            uniformSubScopesProcessor.Successor = variableCreator;

            solutionImprover.Name = "SolutionImprover";
            solutionImprover.OperatorParameter.ActualName = "Improver";
            solutionImprover.Successor = solutionEvaluator;

            solutionEvaluator.Name = "SolutionEvaluator";
            solutionEvaluator.OperatorParameter.ActualName = "Evaluator";
            solutionEvaluator.Successor = null;

            variableCreator.Name = "Initialize EvaluatedSolutions";
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("EvaluatedSolutions", new IntValue()));
            variableCreator.Successor = dataReducer;

            dataReducer.Name = "Increment EvaluatedSolutions";
            dataReducer.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
            dataReducer.TargetParameter.ActualName   = "EvaluatedSolutions";
            dataReducer.ReductionOperation.Value     = new ReductionOperation(ReductionOperations.Sum);
            dataReducer.TargetOperation.Value        = new ReductionOperation(ReductionOperations.Sum);
            dataReducer.Successor = resultsCollector;

            resultsCollector.Name = "ResultsCollector";
            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("EvaluatedSolutions", null, "EvaluatedSolutions"));
            resultsCollector.Successor = bestSelector;

            bestSelector.NumberOfSelectedSubScopesParameter.ActualName = NumberOfHighQualitySolutionsParameter.Name;
            bestSelector.CopySelected = new BoolValue(false);
            bestSelector.Successor    = mainLoop;

            mainLoop.MaximumIterationsParameter.ActualName            = MaximumIterationsParameter.Name;
            mainLoop.RandomParameter.ActualName                       = randomCreator.RandomParameter.ActualName;
            mainLoop.ResultsParameter.ActualName                      = "Results";
            mainLoop.AnalyzerParameter.ActualName                     = AnalyzerParameter.Name;
            mainLoop.IterationsParameter.ActualName                   = "Iterations";
            mainLoop.EvaluatedSolutionsParameter.ActualName           = "EvaluatedSolutions";
            mainLoop.CrossoverParameter.ActualName                    = CrossoverParameter.Name;
            mainLoop.PopulationSizeParameter.ActualName               = PopulationSizeParameter.Name;
            mainLoop.NumberOfHighQualitySolutionsParameter.ActualName = NumberOfHighQualitySolutionsParameter.Name;
            mainLoop.Successor = null;
            #endregion

            qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
            ParameterizeAnalyzers();
            UpdateAnalyzers();

            Initialize();
        }
        public IslandGeneticAlgorithmMainLoop()
            : 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 some 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 the algorithm should process."));
            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."));
            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 islands."));
            Parameters.Add(new ValueLookupParameter <IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
            Parameters.Add(new LookupParameter <IntValue>("EvaluatedSolutions", "The number of times a solution has been evaluated."));
            Parameters.Add(new LookupParameter <IntValue>("IslandGenerations", "The number of generations calculated on one island."));
            Parameters.Add(new LookupParameter <IntValue>("IslandEvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
            Parameters.Add(new ValueLookupParameter <BoolValue>("Migrate", "Migrate the island?"));
            #endregion

            #region Create operators
            VariableCreator           variableCreator            = new VariableCreator();
            UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
            VariableCreator           islandVariableCreator      = new VariableCreator();
            Placeholder               islandAnalyzer1            = new Placeholder();
            LocalRandomCreator        localRandomCreator         = new LocalRandomCreator();
            Placeholder               analyzer1                  = new Placeholder();
            ResultsCollector          resultsCollector1          = new ResultsCollector();
            UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
            Assigner                  generationsAssigner        = new Assigner();
            Assigner                  evaluatedSolutionsAssigner = new Assigner();
            Placeholder               selector                   = new Placeholder();
            SubScopesProcessor        subScopesProcessor1        = new SubScopesProcessor();
            ChildrenCreator           childrenCreator            = new ChildrenCreator();
            UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
            Placeholder               crossover                  = new Placeholder();
            StochasticBranch          stochasticBranch           = new StochasticBranch();
            Placeholder               mutator                              = new Placeholder();
            SubScopesRemover          subScopesRemover                     = new SubScopesRemover();
            UniformSubScopesProcessor uniformSubScopesProcessor3           = 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                islandGenerationsCounter             = new IntCounter();
            Comparator                checkIslandGenerationsReachedMaximum = new Comparator();
            ConditionalBranch         checkContinueEvolution               = new ConditionalBranch();
            DataReducer               generationsReducer                   = new DataReducer();
            DataReducer               evaluatedSolutionsReducer            = new DataReducer();
            Placeholder               islandAnalyzer2                      = new Placeholder();
            UniformSubScopesProcessor uniformSubScopesProcessor5           = new UniformSubScopesProcessor();
            Placeholder               emigrantsSelector                    = new Placeholder();
            IntCounter                migrationsCounter                    = new IntCounter();
            Placeholder               migrator                             = new Placeholder();
            UniformSubScopesProcessor uniformSubScopesProcessor6           = new UniformSubScopesProcessor();
            Placeholder               immigrationReplacer                  = new Placeholder();
            Comparator                generationsComparator                = new Comparator();
            Placeholder               analyzer2                            = new Placeholder();
            ConditionalBranch         generationsTerminationCondition      = new ConditionalBranch();
            ConditionalBranch         reevaluateElitesBranch               = new ConditionalBranch();


            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Migrations", new IntValue(0)));
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Generations", new IntValue(0))); // Class IslandGeneticAlgorithm expects this to be called Generations

            islandVariableCreator.CollectedValues.Add(new ValueParameter <ResultCollection>("Results", new ResultCollection()));
            islandVariableCreator.CollectedValues.Add(new ValueParameter <IntValue>("IslandGenerations", new IntValue(0)));
            islandVariableCreator.CollectedValues.Add(new ValueParameter <IntValue>("IslandEvaluatedSolutions", new IntValue(0)));

            islandAnalyzer1.Name = "Island Analyzer (placeholder)";
            islandAnalyzer1.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;

            analyzer1.Name = "Analyzer (placeholder)";
            analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;

            resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Migrations"));
            resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
            resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter <ResultCollection>("IslandResults", "Result set for each island", "Results"));
            resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;

            uniformSubScopesProcessor1.Parallel.Value = true;

            generationsAssigner.Name = "Initialize Island Generations";
            generationsAssigner.LeftSideParameter.ActualName = IslandGenerations.Name;
            generationsAssigner.RightSideParameter.Value     = new IntValue(0);

            evaluatedSolutionsAssigner.Name = "Initialize Island evaluated solutions";
            evaluatedSolutionsAssigner.LeftSideParameter.ActualName = IslandEvaluatedSolutions.Name;
            evaluatedSolutionsAssigner.RightSideParameter.Value     = new IntValue(0);

            selector.Name = "Selector (placeholder)";
            selector.OperatorParameter.ActualName = SelectorParameter.Name;

            childrenCreator.ParentsPerChild = new IntValue(2);

            crossover.Name = "Crossover (placeholder)";
            crossover.OperatorParameter.ActualName = CrossoverParameter.Name;

            stochasticBranch.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
            //set it to the random number generator of the island
            stochasticBranch.RandomParameter.ActualName = "LocalRandom";

            mutator.Name = "Mutator (placeholder)";
            mutator.OperatorParameter.ActualName = MutatorParameter.Name;

            subScopesRemover.RemoveAllSubScopes = true;

            evaluator.Name = "Evaluator (placeholder)";
            evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;

            subScopesCounter.Name = "Increment EvaluatedSolutions";
            subScopesCounter.ValueParameter.ActualName = IslandEvaluatedSolutions.Name;

            bestSelector.CopySelected = new BoolValue(false);
            bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
            bestSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
            bestSelector.QualityParameter.ActualName = QualityParameter.Name;

            islandGenerationsCounter.Name = "Increment island generatrions";
            islandGenerationsCounter.ValueParameter.ActualName = IslandGenerations.Name;
            islandGenerationsCounter.Increment = new IntValue(1);

            checkIslandGenerationsReachedMaximum.LeftSideParameter.ActualName  = IslandGenerations.Name;
            checkIslandGenerationsReachedMaximum.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
            checkIslandGenerationsReachedMaximum.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
            checkIslandGenerationsReachedMaximum.ResultParameter.ActualName = Migrate.Name;

            checkContinueEvolution.Name = "Migrate?";
            checkContinueEvolution.ConditionParameter.ActualName = Migrate.Name;
            checkContinueEvolution.FalseBranch = selector;

            islandAnalyzer2.Name = "Island Analyzer (placeholder)";
            islandAnalyzer2.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;

            generationsReducer.Name = "Increment Generations";
            generationsReducer.ParameterToReduce.ActualName = islandGenerationsCounter.ValueParameter.ActualName;
            generationsReducer.TargetParameter.ActualName   = "Generations";
            generationsReducer.ReductionOperation.Value     = new ReductionOperation(ReductionOperations.Min);
            generationsReducer.TargetOperation.Value        = new ReductionOperation(ReductionOperations.Sum);

            evaluatedSolutionsReducer.Name = "Increment Evaluated Solutions";
            evaluatedSolutionsReducer.ParameterToReduce.ActualName = IslandEvaluatedSolutions.Name;
            evaluatedSolutionsReducer.TargetParameter.ActualName   = EvaluatedSolutionsParameter.Name;
            evaluatedSolutionsReducer.ReductionOperation.Value     = new ReductionOperation(ReductionOperations.Sum);
            evaluatedSolutionsReducer.TargetOperation.Value        = new ReductionOperation(ReductionOperations.Sum);

            emigrantsSelector.Name = "Emigrants Selector (placeholder)";
            emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;

            migrationsCounter.Name = "Increment number of Migrations";
            migrationsCounter.ValueParameter.ActualName = "Migrations";
            migrationsCounter.Increment = new IntValue(1);

            migrator.Name = "Migrator (placeholder)";
            migrator.OperatorParameter.ActualName = MigratorParameter.Name;

            immigrationReplacer.Name = "Immigration Replacer (placeholder)";
            immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;

            generationsComparator.Name       = "Generations >= MaximumGenerations ?";
            generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
            generationsComparator.LeftSideParameter.ActualName  = "Generations";
            generationsComparator.ResultParameter.ActualName    = "TerminateGenerations";
            generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;

            analyzer2.Name = "Analyzer (placeholder)";
            analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;

            generationsTerminationCondition.Name = "Terminate?";
            generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";

            reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
            reevaluateElitesBranch.Name = "Reevaluate elites ?";
            #endregion

            #region Create operator graph
            OperatorGraph.InitialOperator        = variableCreator;
            variableCreator.Successor            = uniformSubScopesProcessor0;
            uniformSubScopesProcessor0.Operator  = islandVariableCreator;
            uniformSubScopesProcessor0.Successor = analyzer1;
            islandVariableCreator.Successor      = islandAnalyzer1;
            // BackwardsCompatibility3.3
            //the local randoms are created by the island GA itself and are only here to ensure same algorithm results
            #region Backwards compatible code, remove local random creator with 3.4 and rewire the operator graph
            islandAnalyzer1.Successor    = localRandomCreator;
            localRandomCreator.Successor = null;
            #endregion
            analyzer1.Successor                  = resultsCollector1;
            resultsCollector1.Successor          = uniformSubScopesProcessor1;
            uniformSubScopesProcessor1.Operator  = generationsAssigner;
            uniformSubScopesProcessor1.Successor = generationsReducer;
            generationsReducer.Successor         = evaluatedSolutionsReducer;
            evaluatedSolutionsReducer.Successor  = migrationsCounter;
            migrationsCounter.Successor          = uniformSubScopesProcessor5;
            generationsAssigner.Successor        = evaluatedSolutionsAssigner;
            evaluatedSolutionsAssigner.Successor = selector;
            selector.Successor = subScopesProcessor1;
            subScopesProcessor1.Operators.Add(new EmptyOperator());
            subScopesProcessor1.Operators.Add(childrenCreator);
            subScopesProcessor1.Successor        = subScopesProcessor2;
            childrenCreator.Successor            = uniformSubScopesProcessor2;
            uniformSubScopesProcessor2.Operator  = crossover;
            uniformSubScopesProcessor2.Successor = uniformSubScopesProcessor3;
            crossover.Successor                  = stochasticBranch;
            stochasticBranch.FirstBranch         = mutator;
            stochasticBranch.SecondBranch        = null;
            stochasticBranch.Successor           = subScopesRemover;
            mutator.Successor                    = null;
            subScopesRemover.Successor           = null;
            uniformSubScopesProcessor3.Operator  = evaluator;
            uniformSubScopesProcessor3.Successor = subScopesCounter;
            evaluator.Successor                  = null;
            subScopesCounter.Successor           = null;
            subScopesProcessor2.Operators.Add(bestSelector);
            subScopesProcessor2.Operators.Add(new EmptyOperator());
            subScopesProcessor2.Successor                  = mergingReducer;
            mergingReducer.Successor                       = islandAnalyzer2;
            bestSelector.Successor                         = rightReducer;
            rightReducer.Successor                         = reevaluateElitesBranch;
            reevaluateElitesBranch.TrueBranch              = uniformSubScopesProcessor3;
            reevaluateElitesBranch.FalseBranch             = null;
            reevaluateElitesBranch.Successor               = null;
            islandAnalyzer2.Successor                      = islandGenerationsCounter;
            islandGenerationsCounter.Successor             = checkIslandGenerationsReachedMaximum;
            checkIslandGenerationsReachedMaximum.Successor = checkContinueEvolution;
            uniformSubScopesProcessor5.Operator            = emigrantsSelector;
            emigrantsSelector.Successor                    = null;
            uniformSubScopesProcessor5.Successor           = migrator;
            migrator.Successor = uniformSubScopesProcessor6;
            uniformSubScopesProcessor6.Operator  = immigrationReplacer;
            uniformSubScopesProcessor6.Successor = generationsComparator;
            generationsComparator.Successor      = analyzer2;
            analyzer2.Successor = generationsTerminationCondition;
            generationsTerminationCondition.TrueBranch  = null;
            generationsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
            generationsTerminationCondition.Successor   = null;
            #endregion
        }
 private MinAverageMaxValueAnalyzer(MinAverageMaxValueAnalyzer original, Cloner cloner)
     : base(original, cloner)
 {
     resultsCollector = cloner.Clone(original.resultsCollector);
     RegisterEventHandlers();
 }
Example #8
0
        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
        }
Example #9
0
        public SASEGASA()
            : 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>("NumberOfVillages", "The initial number of villages.", new IntValue(10)));
            Parameters.Add(new ValueParameter <IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
            Parameters.Add(new ValueParameter <IntValue>("MaximumGenerations", "The maximum number of generations that should be processed.", new IntValue(1000)));
            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 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.3)));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("ComparisonFactorUpperBound", "The upper bound of the comparison factor (end).", new DoubleValue(0.7)));
            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 <DoubleValue>("FinalMaximumSelectionPressure", "The maximum selection pressure used when there is only one village left.", 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 the villages.", new MultiAnalyzer()));
            Parameters.Add(new ValueParameter <MultiAnalyzer>("VillageAnalyzer", "The operator used to analyze each village.", 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(true))
            {
                Hidden = true
            });

            RandomCreator             randomCreator     = new RandomCreator();
            SubScopesCreator          populationCreator = new SubScopesCreator();
            UniformSubScopesProcessor ussp1             = new UniformSubScopesProcessor();
            SolutionsCreator          solutionsCreator  = new SolutionsCreator();
            VariableCreator           variableCreator   = new VariableCreator();
            UniformSubScopesProcessor ussp2             = new UniformSubScopesProcessor();
            SubScopesCounter          subScopesCounter  = new SubScopesCounter();
            ResultsCollector          resultsCollector  = new ResultsCollector();
            SASEGASAMainLoop          mainLoop          = new SASEGASAMainLoop();

            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 = populationCreator;

            populationCreator.NumberOfSubScopesParameter.ActualName = NumberOfVillagesParameter.Name;
            populationCreator.Successor = ussp1;

            ussp1.Operator  = solutionsCreator;
            ussp1.Successor = variableCreator;

            solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
            solutionsCreator.Successor = null;

            variableCreator.Name = "Initialize EvaluatedSolutions";
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("EvaluatedSolutions", new IntValue()));
            variableCreator.Successor = ussp2;

            ussp2.Operator  = subScopesCounter;
            ussp2.Successor = resultsCollector;

            subScopesCounter.Name = "Increment EvaluatedSolutions";
            subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";

            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Evaluated Solutions", "", "EvaluatedSolutions"));
            resultsCollector.ResultsParameter.ActualName = "Results";
            resultsCollector.Successor = mainLoop;

            mainLoop.NumberOfVillagesParameter.ActualName                 = NumberOfVillagesParameter.Name;
            mainLoop.SelectorParameter.ActualName                         = SelectorParameter.Name;
            mainLoop.CrossoverParameter.ActualName                        = CrossoverParameter.Name;
            mainLoop.ElitesParameter.ActualName                           = ElitesParameter.Name;
            mainLoop.ReevaluateElitesParameter.ActualName                 = ReevaluateElitesParameter.Name;
            mainLoop.MutatorParameter.ActualName                          = MutatorParameter.Name;
            mainLoop.MutationProbabilityParameter.ActualName              = MutationProbabilityParameter.Name;
            mainLoop.RandomParameter.ActualName                           = randomCreator.RandomParameter.ActualName;
            mainLoop.ResultsParameter.ActualName                          = "Results";
            mainLoop.SuccessRatioParameter.ActualName                     = SuccessRatioParameter.Name;
            mainLoop.ComparisonFactorStartParameter.ActualName            = ComparisonFactorLowerBoundParameter.Name;
            mainLoop.ComparisonFactorModifierParameter.ActualName         = ComparisonFactorModifierParameter.Name;
            mainLoop.MaximumSelectionPressureParameter.ActualName         = MaximumSelectionPressureParameter.Name;
            mainLoop.FinalMaximumSelectionPressureParameter.ActualName    = FinalMaximumSelectionPressureParameter.Name;
            mainLoop.MaximumGenerationsParameter.ActualName               = MaximumGenerationsParameter.Name;
            mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
            mainLoop.EvaluatedSolutionsParameter.ActualName               = "EvaluatedSolutions";
            mainLoop.FillPopulationWithParentsParameter.ActualName        = FillPopulationWithParentsParameter.Name;
            mainLoop.Successor = null;

            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();
            villageQualityAnalyzer           = new BestAverageWorstQualityAnalyzer();
            selectionPressureAnalyzer        = new ValueAnalyzer();
            villageSelectionPressureAnalyzer = new ValueAnalyzer();
            successfulOffspringAnalyzer      = new SuccessfulOffspringAnalyzer();
            ParameterizeAnalyzers();
            UpdateAnalyzers();

            Initialize();
        }
Example #10
0
 private RealVectorSwarmUpdater(RealVectorSwarmUpdater original, Cloner cloner)
     : base(original, cloner)
 {
     ResultsCollector = cloner.Clone(original.ResultsCollector);
 }
Example #11
0
        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 LookupParameter <DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
            Parameters.Add(new LookupParameter <DoubleValue>("Temperature", "The current temperature."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("StartTemperature", "The initial temperature."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("EndTemperature", "The end temperature."));
            Parameters.Add(new ValueLookupParameter <IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again)."));
            Parameters.Add(new LookupParameter <IntValue>("Iterations", "The number of iterations."));
            Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));

            Parameters.Add(new ValueLookupParameter <IOperator>("MoveGenerator", "The operator that generates the moves."));
            Parameters.Add(new ValueLookupParameter <IOperator>("MoveEvaluator", "The operator that evaluates a move."));
            Parameters.Add(new ValueLookupParameter <IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
            Parameters.Add(new ValueLookupParameter <IOperator>("AnnealingOperator", "The operator that modifies the temperature."));

            Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze each generation."));
            Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
            Parameters.Add(new LookupParameter <IntValue>("EvaluatedMoves", "The number of evaluated moves."));
            #endregion

            #region Create operators
            Assigner                       temperatureInitializer = new Assigner();
            ResultsCollector               resultsCollector1      = new ResultsCollector();
            SubScopesProcessor             subScopesProcessor0    = new SubScopesProcessor();
            Placeholder                    analyzer1               = new Placeholder();
            SubScopesProcessor             sssp                    = new SubScopesProcessor();
            ResultsCollector               resultsCollector        = new ResultsCollector();
            Placeholder                    annealingOperator       = new Placeholder();
            UniformSubScopesProcessor      mainProcessor           = new UniformSubScopesProcessor();
            Placeholder                    moveGenerator           = new Placeholder();
            UniformSubScopesProcessor      moveEvaluationProcessor = new UniformSubScopesProcessor();
            Placeholder                    moveEvaluator           = new Placeholder();
            SubScopesCounter               subScopesCounter        = new SubScopesCounter();
            ProbabilisticQualityComparator qualityComparator       = new ProbabilisticQualityComparator();
            ConditionalBranch              improvesQualityBranch   = new ConditionalBranch();
            Placeholder                    moveMaker               = new Placeholder();
            SubScopesRemover               subScopesRemover        = new SubScopesRemover();
            IntCounter                     iterationsCounter       = new IntCounter();
            Comparator                     iterationsComparator    = new Comparator();
            SubScopesProcessor             subScopesProcessor1     = new SubScopesProcessor();
            Placeholder                    analyzer2               = new Placeholder();
            ConditionalBranch              iterationsTermination   = new ConditionalBranch();

            temperatureInitializer.LeftSideParameter.ActualName  = TemperatureParameter.ActualName;
            temperatureInitializer.RightSideParameter.ActualName = StartTemperatureParameter.Name;

            resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>(IterationsParameter.Name));
            resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;

            analyzer1.Name = "Analyzer (placeholder)";
            analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;

            annealingOperator.Name = "Annealing operator (placeholder)";
            annealingOperator.OperatorParameter.ActualName = AnnealingOperatorParameter.Name;

            moveGenerator.Name = "Move generator (placeholder)";
            moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;

            moveEvaluator.Name = "Move evaluator (placeholder)";
            moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;

            subScopesCounter.Name = "Increment EvaluatedMoves";
            subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;

            qualityComparator.LeftSideParameter.ActualName  = MoveQualityParameter.Name;
            qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
            qualityComparator.ResultParameter.ActualName    = "IsBetter";
            qualityComparator.DampeningParameter.ActualName = "Temperature";

            improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";

            moveMaker.Name = "Move maker (placeholder)";
            moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;

            subScopesRemover.RemoveAllSubScopes = true;

            iterationsCounter.Name      = "Increment Iterations";
            iterationsCounter.Increment = new IntValue(1);
            iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;

            iterationsComparator.Name = "Iterations >= MaximumIterations";
            iterationsComparator.LeftSideParameter.ActualName  = IterationsParameter.Name;
            iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
            iterationsComparator.ResultParameter.ActualName    = "Terminate";
            iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;

            analyzer2.Name = "Analyzer (placeholder)";
            analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;

            iterationsTermination.Name = "Iterations termination condition";
            iterationsTermination.ConditionParameter.ActualName = "Terminate";
            #endregion

            #region Create operator graph
            OperatorGraph.InitialOperator    = temperatureInitializer;
            temperatureInitializer.Successor = resultsCollector1;
            resultsCollector1.Successor      = subScopesProcessor0;
            subScopesProcessor0.Operators.Add(analyzer1);
            subScopesProcessor0.Successor = sssp;
            analyzer1.Successor           = null;
            sssp.Operators.Add(resultsCollector);
            sssp.Successor                    = annealingOperator;
            resultsCollector.Successor        = null;
            annealingOperator.Successor       = mainProcessor;
            mainProcessor.Operator            = moveGenerator;
            mainProcessor.Successor           = iterationsCounter;
            moveGenerator.Successor           = moveEvaluationProcessor;
            moveEvaluationProcessor.Operator  = moveEvaluator;
            moveEvaluationProcessor.Successor = subScopesCounter;
            moveEvaluator.Successor           = qualityComparator;
            qualityComparator.Successor       = improvesQualityBranch;
            improvesQualityBranch.TrueBranch  = moveMaker;
            improvesQualityBranch.FalseBranch = null;
            improvesQualityBranch.Successor   = null;
            moveMaker.Successor               = null;
            subScopesCounter.Successor        = subScopesRemover;
            subScopesRemover.Successor        = null;
            iterationsCounter.Successor       = iterationsComparator;
            iterationsComparator.Successor    = subScopesProcessor1;
            subScopesProcessor1.Operators.Add(analyzer2);
            subScopesProcessor1.Successor     = iterationsTermination;
            iterationsTermination.TrueBranch  = null;
            iterationsTermination.FalseBranch = annealingOperator;
            #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 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
        }
Example #13
0
 private SPSOSwarmUpdater(SPSOSwarmUpdater original, Cloner cloner)
     : base(original, cloner)
 {
     ResultsCollector = cloner.Clone(original.ResultsCollector);
 }
        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()
        {
            #region Create parameters
            Parameters.Add(new ValueLookupParameter <IMultiAnalyzer>("Analyzer", "The analyzer used to analyze each iteration."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
            Parameters.Add(new ValueLookupParameter <ICrossover>("Crossover", "The operator used to cross solutions."));
            Parameters.Add(new ValueLookupParameter <IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
            Parameters.Add(new ValueLookupParameter <IEvaluator>("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 <BoolValue>("ExecutePathRelinking", "True if path relinking should be executed instead of crossover, otherwise false."));
            Parameters.Add(new ValueLookupParameter <IImprovementOperator>("Improver", "The operator used to improve solutions."));
            Parameters.Add(new ValueLookupParameter <IntValue>("Iterations", "The number of iterations performed."));
            Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
            Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
            Parameters.Add(new ValueLookupParameter <IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set."));
            Parameters.Add(new ValueLookupParameter <IPathRelinker>("PathRelinker", "The operator used to execute path relinking."));
            Parameters.Add(new ValueLookupParameter <IntValue>("PopulationSize", "The size of the population of solutions."));
            Parameters.Add(new ValueLookupParameter <IntValue>("ReferenceSetSize", "The size of the reference set."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("Quality", "This parameter is used for name translation only."));
            Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
            Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
            Parameters.Add(new ValueLookupParameter <ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
            #endregion

            #region Create operators
            Placeholder               analyzer                   = new Placeholder();
            Assigner                  assigner1                  = new Assigner();
            Assigner                  assigner2                  = new Assigner();
            ChildrenCreator           childrenCreator            = new ChildrenCreator();
            Placeholder               crossover                  = new Placeholder();
            Comparator                iterationsChecker          = new Comparator();
            IntCounter                iterationsCounter          = new IntCounter();
            MergingReducer            mergingReducer             = new MergingReducer();
            ConditionalBranch         executePathRelinkingBranch = new ConditionalBranch();
            ConditionalBranch         newSolutionsBranch         = new ConditionalBranch();
            OffspringProcessor        offspringProcessor         = new OffspringProcessor();
            Placeholder               pathRelinker               = new Placeholder();
            PopulationRebuildMethod   populationRebuildMethod    = new PopulationRebuildMethod();
            ReferenceSetUpdateMethod  referenceSetUpdateMethod   = new ReferenceSetUpdateMethod();
            ResultsCollector          resultsCollector           = new ResultsCollector();
            RightSelector             rightSelector              = new RightSelector();
            Placeholder               solutionEvaluator1         = new Placeholder();
            Placeholder               solutionEvaluator2         = new Placeholder();
            Placeholder               solutionImprover1          = new Placeholder();
            Placeholder               solutionImprover2          = new Placeholder();
            SolutionPoolUpdateMethod  solutionPoolUpdateMethod   = new SolutionPoolUpdateMethod();
            SolutionsCreator          solutionsCreator           = new SolutionsCreator();
            DataReducer               dataReducer1               = new DataReducer();
            DataReducer               dataReducer2               = new DataReducer();
            SubScopesProcessor        subScopesProcessor1        = new SubScopesProcessor();
            SubScopesProcessor        subScopesProcessor2        = new SubScopesProcessor();
            SubScopesProcessor        subScopesProcessor3        = new SubScopesProcessor();
            SubScopesProcessor        subScopesProcessor4        = new SubScopesProcessor();
            ConditionalBranch         terminateBranch            = new ConditionalBranch();
            UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
            UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
            UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
            VariableCreator           variableCreator            = new VariableCreator();
            #endregion

            #region Create operator graph
            OperatorGraph.InitialOperator = variableCreator;
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>(IterationsParameter.Name, new IntValue(0)));
            variableCreator.CollectedValues.Add(new ValueParameter <BoolValue>("NewSolutions", new BoolValue(false)));
            variableCreator.Successor = resultsCollector;

            resultsCollector.CopyValue = new BoolValue(false);
            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>(IterationsParameter.Name));
            resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
            resultsCollector.Successor = iterationsChecker;

            iterationsChecker.Name                          = "IterationsChecker";
            iterationsChecker.Comparison.Value              = ComparisonType.GreaterOrEqual;
            iterationsChecker.LeftSideParameter.ActualName  = IterationsParameter.Name;
            iterationsChecker.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
            iterationsChecker.ResultParameter.ActualName    = "Terminate";
            iterationsChecker.Successor                     = terminateBranch;

            terminateBranch.Name = "TerminateChecker";
            terminateBranch.ConditionParameter.ActualName = "Terminate";
            terminateBranch.FalseBranch = referenceSetUpdateMethod;

            referenceSetUpdateMethod.Successor = assigner1;

            assigner1.Name = "NewSolutions = true";
            assigner1.LeftSideParameter.ActualName = "NewSolutions";
            assigner1.RightSideParameter.Value     = new BoolValue(true);
            assigner1.Successor = subScopesProcessor1;

            subScopesProcessor1.DepthParameter.Value = new IntValue(1);
            subScopesProcessor1.Operators.Add(new EmptyOperator());
            subScopesProcessor1.Operators.Add(childrenCreator);
            subScopesProcessor1.Successor = newSolutionsBranch;

            childrenCreator.Name = "SubsetGenerator";
            childrenCreator.ParentsPerChildParameter.Value = new IntValue(2);
            childrenCreator.Successor = assigner2;

            assigner2.Name = "NewSolutions = false";
            assigner2.LeftSideParameter.ActualName = "NewSolutions";
            assigner2.RightSideParameter.Value     = new BoolValue(false);
            assigner2.Successor = uniformSubScopesProcessor1;

            uniformSubScopesProcessor1.DepthParameter.Value = new IntValue(1);
            uniformSubScopesProcessor1.Operator             = executePathRelinkingBranch;
            uniformSubScopesProcessor1.Successor            = solutionPoolUpdateMethod;

            executePathRelinkingBranch.Name = "ExecutePathRelinkingChecker";
            executePathRelinkingBranch.ConditionParameter.ActualName = ExecutePathRelinkingParameter.ActualName;
            executePathRelinkingBranch.TrueBranch  = pathRelinker;
            executePathRelinkingBranch.FalseBranch = crossover;

            pathRelinker.Name = "PathRelinker";
            pathRelinker.OperatorParameter.ActualName = PathRelinkerParameter.Name;
            pathRelinker.Successor = rightSelector;

            crossover.Name = "Crossover";
            crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
            crossover.Successor = offspringProcessor;

            offspringProcessor.Successor = rightSelector;

            rightSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
            rightSelector.CopySelected = new BoolValue(false);
            rightSelector.Successor    = subScopesProcessor2;

            subScopesProcessor2.DepthParameter.Value = new IntValue(1);
            subScopesProcessor2.Operators.Add(new EmptyOperator());
            subScopesProcessor2.Operators.Add(uniformSubScopesProcessor2);
            subScopesProcessor2.Successor = mergingReducer;

            uniformSubScopesProcessor2.DepthParameter.Value    = new IntValue(2);
            uniformSubScopesProcessor2.Operator                = solutionImprover1;
            uniformSubScopesProcessor2.ParallelParameter.Value = new BoolValue(true);
            uniformSubScopesProcessor2.Successor               = subScopesProcessor4;

            solutionImprover1.Name = "SolutionImprover";
            solutionImprover1.OperatorParameter.ActualName = ImproverParameter.Name;
            solutionImprover1.Successor = solutionEvaluator1;

            solutionEvaluator1.Name = "SolutionEvaluator";
            solutionEvaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;

            subScopesProcessor4.Operators.Add(dataReducer1);

            dataReducer1.Name = "Increment EvaluatedSolutions";
            dataReducer1.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
            dataReducer1.TargetParameter.ActualName   = EvaluatedSolutionsParameter.Name;
            dataReducer1.ReductionOperation.Value     = new ReductionOperation(ReductionOperations.Sum);
            dataReducer1.TargetOperation.Value        = new ReductionOperation(ReductionOperations.Sum);

            solutionPoolUpdateMethod.QualityParameter.ActualName = QualityParameter.ActualName;
            solutionPoolUpdateMethod.Successor = analyzer;

            analyzer.Name = "Analyzer";
            analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;

            newSolutionsBranch.Name = "NewSolutionsChecker";
            newSolutionsBranch.ConditionParameter.ActualName = "NewSolutions";
            newSolutionsBranch.TrueBranch  = subScopesProcessor1;
            newSolutionsBranch.FalseBranch = populationRebuildMethod;

            populationRebuildMethod.QualityParameter.ActualName = QualityParameter.ActualName;
            populationRebuildMethod.Successor = subScopesProcessor3;

            subScopesProcessor3.DepthParameter.Value = new IntValue(1);
            subScopesProcessor3.Operators.Add(solutionsCreator);
            subScopesProcessor3.Operators.Add(new EmptyOperator());
            subScopesProcessor3.Successor = iterationsCounter;

            solutionsCreator.Name = "DiversificationGenerationMethod";
            solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
            solutionsCreator.Successor = uniformSubScopesProcessor3;

            uniformSubScopesProcessor3.DepthParameter.Value    = new IntValue(1);
            uniformSubScopesProcessor3.Operator                = solutionImprover2;
            uniformSubScopesProcessor3.ParallelParameter.Value = new BoolValue(true);
            uniformSubScopesProcessor3.Successor               = dataReducer2;

            solutionImprover2.Name = "SolutionImprover";
            solutionImprover2.OperatorParameter.ActualName = ImproverParameter.Name;
            solutionImprover2.Successor = solutionEvaluator2;

            solutionEvaluator2.Name = "SolutionEvaluator";
            solutionEvaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;

            dataReducer2.Name = "Increment EvaluatedSolutions";
            dataReducer2.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
            dataReducer2.TargetParameter.ActualName   = EvaluatedSolutionsParameter.Name;
            dataReducer2.ReductionOperation.Value     = new ReductionOperation(ReductionOperations.Sum);
            dataReducer2.TargetOperation.Value        = new ReductionOperation(ReductionOperations.Sum);

            iterationsCounter.Name = "IterationCounter";
            iterationsCounter.IncrementParameter.Value  = new IntValue(1);
            iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
            iterationsCounter.Successor = resultsCollector;
            #endregion
        }
Example #16
0
        public NSGA2()
        {
            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 ValueParameter <PercentValue>("CrossoverProbability", "The probability that the crossover operator is applied on two parents.", new PercentValue(0.9)));
            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 ConstrainedValueParameter <IManipulator>("Mutator", "The operator used to mutate solutions."));
            Parameters.Add(new ValueParameter <MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
            Parameters.Add(new ValueParameter <IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
            Parameters.Add(new ValueParameter <IntValue>("SelectedParents", "Each two parents form a new child, typically this value should be twice the population size, but because the NSGA-II is maximally elitist it can be any multiple of 2 greater than 0.", new IntValue(200)));
            Parameters.Add(new FixedValueParameter <BoolValue>("DominateOnEqualQualities", "Flag which determines wether solutions with equal quality values should be treated as dominated.", new BoolValue(false)));

            RandomCreator         randomCreator         = new RandomCreator();
            SolutionsCreator      solutionsCreator      = new SolutionsCreator();
            SubScopesCounter      subScopesCounter      = new SubScopesCounter();
            RankAndCrowdingSorter rankAndCrowdingSorter = new RankAndCrowdingSorter();
            ResultsCollector      resultsCollector      = new ResultsCollector();
            NSGA2MainLoop         mainLoop = new NSGA2MainLoop();

            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 = rankAndCrowdingSorter;

            rankAndCrowdingSorter.DominateOnEqualQualitiesParameter.ActualName = DominateOnEqualQualitiesParameter.Name;
            rankAndCrowdingSorter.CrowdingDistanceParameter.ActualName         = "CrowdingDistance";
            rankAndCrowdingSorter.RankParameter.ActualName = "Rank";
            rankAndCrowdingSorter.Successor = resultsCollector;

            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
            resultsCollector.ResultsParameter.ActualName = "Results";
            resultsCollector.Successor = mainLoop;

            mainLoop.PopulationSizeParameter.ActualName       = PopulationSizeParameter.Name;
            mainLoop.SelectorParameter.ActualName             = SelectorParameter.Name;
            mainLoop.CrossoverParameter.ActualName            = CrossoverParameter.Name;
            mainLoop.CrossoverProbabilityParameter.ActualName = CrossoverProbabilityParameter.Name;
            mainLoop.MaximumGenerationsParameter.ActualName   = MaximumGenerationsParameter.Name;
            mainLoop.MutatorParameter.ActualName             = MutatorParameter.Name;
            mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
            mainLoop.RandomParameter.ActualName             = RandomCreator.RandomParameter.ActualName;
            mainLoop.AnalyzerParameter.ActualName           = AnalyzerParameter.Name;
            mainLoop.ResultsParameter.ActualName            = "Results";
            mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";

            foreach (ISelector selector in ApplicationManager.Manager.GetInstances <ISelector>().Where(x => !(x is ISingleObjectiveSelector)).OrderBy(x => x.Name))
            {
                SelectorParameter.ValidValues.Add(selector);
            }
            ISelector tournamentSelector = SelectorParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("CrowdedTournamentSelector"));

            if (tournamentSelector != null)
            {
                SelectorParameter.Value = tournamentSelector;
            }

            ParameterizeSelectors();

            paretoFrontAnalyzer = new RankBasedParetoFrontAnalyzer();
            paretoFrontAnalyzer.RankParameter.ActualName    = "Rank";
            paretoFrontAnalyzer.RankParameter.Depth         = 1;
            paretoFrontAnalyzer.ResultsParameter.ActualName = "Results";
            ParameterizeAnalyzers();
            UpdateAnalyzers();

            RegisterEventhandlers();
        }
        public BestAverageWorstVRPToursAnalyzer()
            : base()
        {
            #region Create parameters
            Parameters.Add(new LookupParameter <IVRPProblemInstance>("ProblemInstance", "The problem instance."));

            Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("Distance", "The distance of the VRP solutions which should be analyzed."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("BestDistance", "The best distance value."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("CurrentBestDistance", "The current best distance value."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("CurrentAverageDistance", "The current average distance value of all solutions."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("CurrentWorstDistance", "The current worst distance value of all solutions."));
            Parameters.Add(new ValueLookupParameter <DataTable>("Distances", "The data table to store the current best, current average, current worst, best and best known distance value."));

            Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("VehiclesUtilized", "The vehicles utilized of the VRP solutions which should be analyzed."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("BestVehiclesUtilized", "The best  vehicles utilized value."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("CurrentBestVehiclesUtilized", "The current best  vehicles utilized value."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("CurrentAverageVehiclesUtilized", "The current average  vehicles utilized value of all solutions."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("CurrentWorstVehiclesUtilized", "The current worst  vehicles utilized value of all solutions."));
            Parameters.Add(new ValueLookupParameter <DataTable>("VehiclesUtilizedValues", "The data table to store the current best, current average, current worst, best and best known vehicles utilized value."));

            Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The results collection where the analysis values should be stored."));
            #endregion

            #region Create operators
            BestVRPToursMemorizer bestMemorizer           = new BestVRPToursMemorizer();
            BestAverageWorstVRPToursCalculator calculator = new BestAverageWorstVRPToursCalculator();
            ResultsCollector resultsCollector             = new ResultsCollector();

            //Distance
            bestMemorizer.BestDistanceParameter.ActualName = BestDistanceParameter.Name;
            bestMemorizer.DistanceParameter.ActualName     = DistanceParameter.Name;
            bestMemorizer.DistanceParameter.Depth          = DistanceParameter.Depth;

            calculator.DistanceParameter.ActualName        = DistanceParameter.Name;
            calculator.DistanceParameter.Depth             = DistanceParameter.Depth;
            calculator.BestDistanceParameter.ActualName    = CurrentBestDistanceParameter.Name;
            calculator.AverageDistanceParameter.ActualName = CurrentAverageDistanceParameter.Name;
            calculator.WorstDistanceParameter.ActualName   = CurrentWorstDistanceParameter.Name;

            DataTableValuesCollector distanceDataTablesCollector = new DataTableValuesCollector();
            distanceDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("BestDistance", null, BestDistanceParameter.Name));
            distanceDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("CurrentBestDistance", null, CurrentBestDistanceParameter.Name));
            distanceDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("CurrentAverageDistance", null, CurrentAverageDistanceParameter.Name));
            distanceDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("CurrentWorstDistance", null, CurrentWorstDistanceParameter.Name));
            distanceDataTablesCollector.DataTableParameter.ActualName = DistancesParameter.Name;

            resultsCollector.CollectedValues.Add(new LookupParameter <DataTable>(DistancesParameter.Name));

            //Vehicles Utlized
            bestMemorizer.BestVehiclesUtilizedParameter.ActualName = BestVehiclesUtilizedParameter.Name;
            bestMemorizer.VehiclesUtilizedParameter.ActualName     = VehiclesUtilizedParameter.Name;
            bestMemorizer.VehiclesUtilizedParameter.Depth          = VehiclesUtilizedParameter.Depth;

            calculator.VehiclesUtilizedParameter.ActualName        = VehiclesUtilizedParameter.Name;
            calculator.VehiclesUtilizedParameter.Depth             = VehiclesUtilizedParameter.Depth;
            calculator.BestVehiclesUtilizedParameter.ActualName    = CurrentBestVehiclesUtilizedParameter.Name;
            calculator.AverageVehiclesUtilizedParameter.ActualName = CurrentAverageVehiclesUtilizedParameter.Name;
            calculator.WorstVehiclesUtilizedParameter.ActualName   = CurrentWorstVehiclesUtilizedParameter.Name;

            DataTableValuesCollector vehiclesUtilizedDataTablesCollector = new DataTableValuesCollector();
            vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("BestVehiclesUtilized", null, BestVehiclesUtilizedParameter.Name));
            vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("CurrentBestVehiclesUtilized", null, CurrentBestVehiclesUtilizedParameter.Name));
            vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("CurrentAverageVehiclesUtilized", null, CurrentAverageVehiclesUtilizedParameter.Name));
            vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter <DoubleValue>("CurrentWorstVehiclesUtilized", null, CurrentWorstVehiclesUtilizedParameter.Name));
            vehiclesUtilizedDataTablesCollector.DataTableParameter.ActualName = VehiclesUtilizedValuesParameter.Name;

            resultsCollector.CollectedValues.Add(new LookupParameter <DataTable>(VehiclesUtilizedValuesParameter.Name));
            #endregion

            #region Create operator graph
            OperatorGraph.InitialOperator                 = bestMemorizer;
            bestMemorizer.Successor                       = calculator;
            calculator.Successor                          = distanceDataTablesCollector;
            distanceDataTablesCollector.Successor         = vehiclesUtilizedDataTablesCollector;
            vehiclesUtilizedDataTablesCollector.Successor = resultsCollector;
            resultsCollector.Successor                    = null;
            #endregion

            Initialize();
        }
        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();
        }
Example #19
0
        public GeneticAlgorithm()
            : 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 <MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
            Parameters.Add(new ValueParameter <IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));

            RandomCreator            randomCreator    = new RandomCreator();
            SolutionsCreator         solutionsCreator = new SolutionsCreator();
            SubScopesCounter         subScopesCounter = new SubScopesCounter();
            ResultsCollector         resultsCollector = new ResultsCollector();
            GeneticAlgorithmMainLoop mainLoop         = new GeneticAlgorithmMainLoop();

            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", null, "EvaluatedSolutions"));
            resultsCollector.ResultsParameter.ActualName = "Results";
            resultsCollector.Successor = mainLoop;

            mainLoop.SelectorParameter.ActualName            = SelectorParameter.Name;
            mainLoop.CrossoverParameter.ActualName           = CrossoverParameter.Name;
            mainLoop.ElitesParameter.ActualName              = ElitesParameter.Name;
            mainLoop.ReevaluateElitesParameter.ActualName    = ReevaluateElitesParameter.Name;
            mainLoop.MaximumGenerationsParameter.ActualName  = MaximumGenerationsParameter.Name;
            mainLoop.MutatorParameter.ActualName             = MutatorParameter.Name;
            mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
            mainLoop.RandomParameter.ActualName              = RandomCreator.RandomParameter.ActualName;
            mainLoop.AnalyzerParameter.ActualName            = AnalyzerParameter.Name;
            mainLoop.EvaluatedSolutionsParameter.ActualName  = "EvaluatedSolutions";
            mainLoop.PopulationSizeParameter.ActualName      = PopulationSizeParameter.Name;
            mainLoop.ResultsParameter.ActualName             = "Results";

            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();

            qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
            ParameterizeAnalyzers();
            UpdateAnalyzers();

            Initialize();
        }
Example #20
0
        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
        }
Example #21
0
        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();
        }
Example #22
0
        public EvolutionStrategy()
            : 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>("Children", "λ (lambda) - the size of the offspring population.", new IntValue(100)));
            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()));

            RandomCreator             randomCreator           = new RandomCreator();
            SolutionsCreator          solutionsCreator        = new SolutionsCreator();
            SubScopesCounter          subScopesCounter        = new SubScopesCounter();
            UniformSubScopesProcessor strategyVectorProcessor = new UniformSubScopesProcessor();
            Placeholder               strategyVectorCreator   = new Placeholder();
            ResultsCollector          resultsCollector        = new ResultsCollector();
            EvolutionStrategyMainLoop mainLoop = new EvolutionStrategyMainLoop();

            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.ChildrenParameter.ActualName           = ChildrenParameter.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";

            qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
            ParameterizeAnalyzers();
            UpdateAnalyzers();

            Initialize();
        }
Example #23
0
        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 ValueLookupParameter <IntValue>("MinimumPopulationSize", "The minimum size of the population of solutions."));
            Parameters.Add(new ValueLookupParameter <IntValue>("MaximumPopulationSize", "The maximum size of the population of solutions."));
            Parameters.Add(new ValueLookupParameter <DoubleValue>("ComparisonFactor", "The comparison factor."));
            Parameters.Add(new ValueLookupParameter <IntValue>("Effort", "The maximum number of offspring created in each generation."));
            Parameters.Add(new ValueLookupParameter <IntValue>("BatchSize", "The number of children that should be created during one iteration of the offspring creation process."));
            Parameters.Add(new ValueLookupParameter <ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
            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();
            Assigner                         assigner1                 = new Assigner();
            ResultsCollector                 resultsCollector          = new ResultsCollector();
            Placeholder                      analyzer1                 = new Placeholder();
            Placeholder                      selector                  = new Placeholder();
            SubScopesProcessor               subScopesProcessor1       = new SubScopesProcessor();
            ChildrenCreator                  childrenCreator           = new ChildrenCreator();
            UniformSubScopesProcessor        uniformSubScopesProcessor = new UniformSubScopesProcessor();
            Placeholder                      crossover                 = new Placeholder();
            StochasticBranch                 stochasticBranch          = new StochasticBranch();
            Placeholder                      mutator   = new Placeholder();
            Placeholder                      evaluator = new Placeholder();
            WeightedParentsQualityComparator weightedParentsQualityComparator = new WeightedParentsQualityComparator();
            SubScopesRemover                 subScopesRemover             = new SubScopesRemover();
            IntCounter                       intCounter1                  = new IntCounter();
            IntCounter                       intCounter2                  = new IntCounter();
            ConditionalSelector              conditionalSelector          = new ConditionalSelector();
            RightReducer                     rightReducer1                = new RightReducer();
            DuplicatesSelector               duplicateSelector            = new DuplicatesSelector();
            LeftReducer                      leftReducer1                 = new LeftReducer();
            ProgressiveOffspringPreserver    progressiveOffspringSelector = new ProgressiveOffspringPreserver();
            SubScopesCounter                 subScopesCounter2            = new SubScopesCounter();
            ExpressionCalculator             calculator1                  = new ExpressionCalculator();
            ConditionalBranch                conditionalBranch1           = new ConditionalBranch();
            Comparator                       comparator1                  = new Comparator();
            ConditionalBranch                conditionalBranch2           = new ConditionalBranch();
            LeftReducer                      leftReducer2                 = new LeftReducer();
            SubScopesProcessor               subScopesProcessor2          = new SubScopesProcessor();
            BestSelector                     bestSelector                 = new BestSelector();
            RightReducer                     rightReducer2                = new RightReducer();
            ScopeCleaner                     scopeCleaner                 = new ScopeCleaner();
            ScopeRestorer                    scopeRestorer                = new ScopeRestorer();
            MergingReducer                   mergingReducer               = new MergingReducer();
            IntCounter                       intCounter3                  = new IntCounter();
            SubScopesCounter                 subScopesCounter3            = new SubScopesCounter();
            ExpressionCalculator             calculator2                  = new ExpressionCalculator();
            Comparator                       comparator2                  = new Comparator();
            ConditionalBranch                conditionalBranch3           = new ConditionalBranch();
            Placeholder                      analyzer2                  = new Placeholder();
            Comparator                       comparator3                = new Comparator();
            ConditionalBranch                conditionalBranch4         = new ConditionalBranch();
            Comparator                       comparator4                = new Comparator();
            ConditionalBranch                conditionalBranch5         = new ConditionalBranch();
            Assigner                         assigner3                  = new Assigner();
            Assigner                         assigner4                  = new Assigner();
            Assigner                         assigner5                  = new Assigner();
            ConditionalBranch                reevaluateElitesBranch     = new ConditionalBranch();
            UniformSubScopesProcessor        uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
            Placeholder                      evaluator2                 = new Placeholder();
            SubScopesCounter                 subScopesCounter4          = new SubScopesCounter();

            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Generations", new IntValue(0))); // Class RAPGA expects this to be called Generations
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("CurrentPopulationSize", new IntValue(0)));
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("NumberOfCreatedOffspring", new IntValue(0)));
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("NumberOfSuccessfulOffspring", new IntValue(0)));
            variableCreator.CollectedValues.Add(new ValueParameter <ScopeList>("OffspringList", new ScopeList()));

            assigner1.Name = "Initialize CurrentPopulationSize";
            assigner1.LeftSideParameter.ActualName  = "CurrentPopulationSize";
            assigner1.RightSideParameter.ActualName = PopulationSizeParameter.Name;

            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("CurrentPopulationSize"));
            resultsCollector.ResultsParameter.ActualName = "Results";

            analyzer1.Name = "Analyzer";
            analyzer1.OperatorParameter.ActualName = "Analyzer";

            selector.Name = "Selector";
            selector.OperatorParameter.ActualName = "Selector";

            childrenCreator.ParentsPerChild = new IntValue(2);

            uniformSubScopesProcessor.Parallel.Value = true;

            crossover.Name = "Crossover";
            crossover.OperatorParameter.ActualName = "Crossover";

            stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
            stochasticBranch.RandomParameter.ActualName      = "Random";

            mutator.Name = "Mutator";
            mutator.OperatorParameter.ActualName = "Mutator";

            evaluator.Name = "Evaluator";
            evaluator.OperatorParameter.ActualName = "Evaluator";

            weightedParentsQualityComparator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
            weightedParentsQualityComparator.LeftSideParameter.ActualName         = QualityParameter.Name;
            weightedParentsQualityComparator.MaximizationParameter.ActualName     = MaximizationParameter.Name;
            weightedParentsQualityComparator.RightSideParameter.ActualName        = QualityParameter.Name;
            weightedParentsQualityComparator.ResultParameter.ActualName           = "SuccessfulOffspring";

            subScopesRemover.RemoveAllSubScopes = true;

            intCounter1.Name = "Increment NumberOfCreatedOffspring";
            intCounter1.ValueParameter.ActualName = "NumberOfCreatedOffspring";
            intCounter1.Increment = null;
            intCounter1.IncrementParameter.ActualName = BatchSizeParameter.Name;

            intCounter2.Name = "Increment EvaluatedSolutions";
            intCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
            intCounter2.Increment = null;
            intCounter2.IncrementParameter.ActualName = BatchSizeParameter.Name;

            conditionalSelector.ConditionParameter.ActualName = "SuccessfulOffspring";
            conditionalSelector.ConditionParameter.Depth      = 1;
            conditionalSelector.CopySelected.Value            = false;

            duplicateSelector.CopySelected.Value = false;

            progressiveOffspringSelector.OffspringListParameter.ActualName         = "OffspringList";
            progressiveOffspringSelector.ElitesParameter.ActualName                = ElitesParameter.Name;
            progressiveOffspringSelector.MaximumPopulationSizeParameter.ActualName = MaximumPopulationSizeParameter.Name;

            subScopesCounter2.Name = "Count Successful Offspring";
            subScopesCounter2.ValueParameter.ActualName = "NumberOfSuccessfulOffspring";

            calculator1.Name = "NumberOfSuccessfulOffspring == MaximumPopulationSize - Elites";
            calculator1.CollectedValues.Add(new ValueLookupParameter <IntValue>("NumberOfSuccessfulOffspring"));
            calculator1.CollectedValues.Add(new ValueLookupParameter <IntValue>("MaximumPopulationSize"));
            calculator1.CollectedValues.Add(new ValueLookupParameter <IntValue>("Elites"));
            calculator1.ExpressionParameter.Value            = new StringValue("NumberOfSuccessfulOffspring MaximumPopulationSize Elites - ==");
            calculator1.ExpressionResultParameter.ActualName = "Break";

            conditionalBranch1.Name = "Break?";
            conditionalBranch1.ConditionParameter.ActualName = "Break";

            comparator1.Name       = "NumberOfCreatedOffspring >= Effort";
            comparator1.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
            comparator1.LeftSideParameter.ActualName  = "NumberOfCreatedOffspring";
            comparator1.RightSideParameter.ActualName = EffortParameter.Name;
            comparator1.ResultParameter.ActualName    = "Break";

            conditionalBranch2.Name = "Break?";
            conditionalBranch2.ConditionParameter.ActualName = "Break";

            bestSelector.CopySelected = new BoolValue(false);
            bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
            bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
            bestSelector.QualityParameter.ActualName = QualityParameter.Name;

            intCounter3.Name      = "Increment Generations";
            intCounter3.Increment = new IntValue(1);
            intCounter3.ValueParameter.ActualName = "Generations";

            subScopesCounter3.Name = "Update CurrentPopulationSize";
            subScopesCounter3.ValueParameter.ActualName = "CurrentPopulationSize";
            subScopesCounter3.AccumulateParameter.Value = new BoolValue(false);

            calculator2.Name = "Evaluate ActualSelectionPressure";
            calculator2.CollectedValues.Add(new ValueLookupParameter <IntValue>("NumberOfCreatedOffspring"));
            calculator2.CollectedValues.Add(new ValueLookupParameter <IntValue>("Elites"));
            calculator2.CollectedValues.Add(new ValueLookupParameter <IntValue>("CurrentPopulationSize"));
            calculator2.ExpressionParameter.Value            = new StringValue("NumberOfCreatedOffspring Elites + CurrentPopulationSize /");
            calculator2.ExpressionResultParameter.ActualName = "ActualSelectionPressure";

            comparator2.Name       = "CurrentPopulationSize < 1";
            comparator2.Comparison = new Comparison(ComparisonType.Less);
            comparator2.LeftSideParameter.ActualName = "CurrentPopulationSize";
            comparator2.RightSideParameter.Value     = new IntValue(1);
            comparator2.ResultParameter.ActualName   = "Terminate";

            conditionalBranch3.Name = "Terminate?";
            conditionalBranch3.ConditionParameter.ActualName = "Terminate";

            analyzer2.Name = "Analyzer";
            analyzer2.OperatorParameter.ActualName = "Analyzer";

            comparator3.Name       = "Generations >= MaximumGenerations";
            comparator3.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
            comparator3.LeftSideParameter.ActualName  = "Generations";
            comparator3.ResultParameter.ActualName    = "Terminate";
            comparator3.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;

            conditionalBranch4.Name = "Terminate?";
            conditionalBranch4.ConditionParameter.ActualName = "Terminate";

            comparator4.Name       = "CurrentPopulationSize < MinimumPopulationSize";
            comparator4.Comparison = new Comparison(ComparisonType.Less);
            comparator4.LeftSideParameter.ActualName  = "CurrentPopulationSize";
            comparator4.RightSideParameter.ActualName = MinimumPopulationSizeParameter.Name;
            comparator4.ResultParameter.ActualName    = "Terminate";

            conditionalBranch5.Name = "Terminate?";
            conditionalBranch5.ConditionParameter.ActualName = "Terminate";

            assigner3.Name = "Reset NumberOfCreatedOffspring";
            assigner3.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
            assigner3.RightSideParameter.Value     = new IntValue(0);

            assigner4.Name = "Reset NumberOfSuccessfulOffspring";
            assigner4.LeftSideParameter.ActualName = "NumberOfSuccessfulOffspring";
            assigner4.RightSideParameter.Value     = new IntValue(0);

            assigner5.Name = "Reset OffspringList";
            assigner5.LeftSideParameter.ActualName = "OffspringList";
            assigner5.RightSideParameter.Value     = new ScopeList();

            reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
            reevaluateElitesBranch.Name = "Reevaluate elites ?";

            uniformSubScopesProcessor2.Parallel.Value = true;

            evaluator2.Name = "Evaluator (placeholder)";
            evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;

            subScopesCounter4.Name = "Increment EvaluatedSolutions";
            subScopesCounter4.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
            #endregion

            #region Create operator graph
            OperatorGraph.InitialOperator = variableCreator;
            variableCreator.Successor     = assigner1;
            assigner1.Successor           = resultsCollector;
            resultsCollector.Successor    = analyzer1;
            analyzer1.Successor           = selector;
            selector.Successor            = subScopesProcessor1;
            subScopesProcessor1.Operators.Add(new EmptyOperator());
            subScopesProcessor1.Operators.Add(childrenCreator);
            subScopesProcessor1.Successor       = calculator1;
            childrenCreator.Successor           = uniformSubScopesProcessor;
            uniformSubScopesProcessor.Operator  = crossover;
            uniformSubScopesProcessor.Successor = intCounter1;
            crossover.Successor           = stochasticBranch;
            stochasticBranch.FirstBranch  = mutator;
            stochasticBranch.SecondBranch = null;
            mutator.Successor             = null;
            stochasticBranch.Successor    = evaluator;
            evaluator.Successor           = weightedParentsQualityComparator;
            weightedParentsQualityComparator.Successor = subScopesRemover;
            intCounter1.Successor                  = intCounter2;
            intCounter2.Successor                  = conditionalSelector;
            conditionalSelector.Successor          = rightReducer1;
            rightReducer1.Successor                = duplicateSelector;
            duplicateSelector.Successor            = leftReducer1;
            leftReducer1.Successor                 = progressiveOffspringSelector;
            progressiveOffspringSelector.Successor = subScopesCounter2;
            calculator1.Successor                  = conditionalBranch1;
            conditionalBranch1.FalseBranch         = comparator1;
            conditionalBranch1.TrueBranch          = subScopesProcessor2;
            comparator1.Successor                  = conditionalBranch2;
            conditionalBranch2.FalseBranch         = leftReducer2;
            conditionalBranch2.TrueBranch          = subScopesProcessor2;
            leftReducer2.Successor                 = selector;
            subScopesProcessor2.Operators.Add(bestSelector);
            subScopesProcessor2.Operators.Add(scopeCleaner);
            subScopesProcessor2.Successor        = mergingReducer;
            bestSelector.Successor               = rightReducer2;
            rightReducer2.Successor              = reevaluateElitesBranch;
            reevaluateElitesBranch.TrueBranch    = uniformSubScopesProcessor2;
            uniformSubScopesProcessor2.Operator  = evaluator2;
            uniformSubScopesProcessor2.Successor = subScopesCounter4;
            evaluator2.Successor               = null;
            subScopesCounter4.Successor        = null;
            reevaluateElitesBranch.FalseBranch = null;
            reevaluateElitesBranch.Successor   = null;
            scopeCleaner.Successor             = scopeRestorer;
            mergingReducer.Successor           = intCounter3;
            intCounter3.Successor              = subScopesCounter3;
            subScopesCounter3.Successor        = calculator2;
            calculator2.Successor              = comparator2;
            comparator2.Successor              = conditionalBranch3;
            conditionalBranch3.FalseBranch     = analyzer2;
            conditionalBranch3.TrueBranch      = null;
            analyzer2.Successor            = comparator3;
            comparator3.Successor          = conditionalBranch4;
            conditionalBranch4.FalseBranch = comparator4;
            conditionalBranch4.TrueBranch  = null;
            conditionalBranch4.Successor   = null;
            comparator4.Successor          = conditionalBranch5;
            conditionalBranch5.FalseBranch = assigner3;
            conditionalBranch5.TrueBranch  = null;
            conditionalBranch5.Successor   = null;
            assigner3.Successor            = assigner4;
            assigner4.Successor            = assigner5;
            assigner5.Successor            = selector;

            #endregion
        }
        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();
            Placeholder               analyzer2Placeholder       = 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;
            conditionalBranch.FalseBranch = analyzer2Placeholder;

            analyzer2Placeholder.Name = "(Analyzer)";
            analyzer2Placeholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
            #endregion
        }
Example #25
0
        public IslandGeneticAlgorithm()
            : 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>("NumberOfIslands", "The number of islands.", new IntValue(5)));
            Parameters.Add(new ValueParameter <IntValue>("MigrationInterval", "The number of generations that should pass between migration phases.", new IntValue(20)));
            Parameters.Add(new ValueParameter <PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands.", new PercentValue(0.15)));
            Parameters.Add(new ConstrainedValueParameter <IMigrator>("Migrator", "The migration strategy."));
            Parameters.Add(new ConstrainedValueParameter <ISelector>("EmigrantsSelector", "Selects the individuals that will be migrated."));
            Parameters.Add(new ConstrainedValueParameter <IReplacer>("ImmigrationReplacer", "Selects the population from the unification of the original population and the immigrants."));
            Parameters.Add(new ValueParameter <IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
            Parameters.Add(new ValueParameter <IntValue>("MaximumGenerations", "The maximum number of generations that should be processed.", new IntValue(1000)));
            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 <MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
            Parameters.Add(new ValueParameter <MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));

            RandomCreator                  randomCreator        = new RandomCreator();
            UniformSubScopesProcessor      ussp0                = new UniformSubScopesProcessor();
            LocalRandomCreator             localRandomCreator   = new LocalRandomCreator();
            RandomCreator                  globalRandomResetter = new RandomCreator();
            SubScopesCreator               populationCreator    = new SubScopesCreator();
            UniformSubScopesProcessor      ussp1                = new UniformSubScopesProcessor();
            SolutionsCreator               solutionsCreator     = new SolutionsCreator();
            VariableCreator                variableCreator      = new VariableCreator();
            UniformSubScopesProcessor      ussp2                = new UniformSubScopesProcessor();
            SubScopesCounter               subScopesCounter     = new SubScopesCounter();
            ResultsCollector               resultsCollector     = new ResultsCollector();
            IslandGeneticAlgorithmMainLoop mainLoop             = new IslandGeneticAlgorithmMainLoop();

            OperatorGraph.InitialOperator = randomCreator;

            randomCreator.RandomParameter.ActualName          = "GlobalRandom";
            randomCreator.SeedParameter.ActualName            = SeedParameter.Name;
            randomCreator.SeedParameter.Value                 = null;
            randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
            randomCreator.SetSeedRandomlyParameter.Value      = null;
            randomCreator.Successor = populationCreator;

            populationCreator.NumberOfSubScopesParameter.ActualName = NumberOfIslandsParameter.Name;
            populationCreator.Successor = ussp0;

            ussp0.Operator  = localRandomCreator;
            ussp0.Successor = globalRandomResetter;

            // BackwardsCompatibility3.3
            // the global random is resetted to ensure the same algorithm results
            #region Backwards compatible code, remove global random resetter with 3.4 and rewire the operator graph
            globalRandomResetter.RandomParameter.ActualName     = "GlobalRandom";
            globalRandomResetter.SeedParameter.ActualName       = SeedParameter.Name;
            globalRandomResetter.SeedParameter.Value            = null;
            globalRandomResetter.SetSeedRandomlyParameter.Value = new BoolValue(false);
            globalRandomResetter.Successor = ussp1;
            #endregion

            ussp1.Operator  = solutionsCreator;
            ussp1.Successor = variableCreator;

            solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
            //don't create solutions in parallel because the hive engine would distribute these tasks
            solutionsCreator.ParallelParameter.Value = new BoolValue(false);
            solutionsCreator.Successor = null;

            variableCreator.Name = "Initialize EvaluatedSolutions";
            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("EvaluatedSolutions", new IntValue()));
            variableCreator.Successor = ussp2;

            ussp2.Operator  = subScopesCounter;
            ussp2.Successor = resultsCollector;

            subScopesCounter.Name = "Count EvaluatedSolutions";
            subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
            subScopesCounter.Successor = null;

            resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
            resultsCollector.ResultsParameter.ActualName = "Results";
            resultsCollector.Successor = mainLoop;

            mainLoop.EmigrantsSelectorParameter.ActualName   = EmigrantsSelectorParameter.Name;
            mainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
            mainLoop.MaximumGenerationsParameter.ActualName  = MaximumGenerationsParameter.Name;
            mainLoop.MigrationIntervalParameter.ActualName   = MigrationIntervalParameter.Name;
            mainLoop.MigrationRateParameter.ActualName       = MigrationRateParameter.Name;
            mainLoop.MigratorParameter.ActualName            = MigratorParameter.Name;
            mainLoop.NumberOfIslandsParameter.ActualName     = NumberOfIslandsParameter.Name;
            mainLoop.SelectorParameter.ActualName            = SelectorParameter.Name;
            mainLoop.CrossoverParameter.ActualName           = CrossoverParameter.Name;
            mainLoop.ElitesParameter.ActualName              = ElitesParameter.Name;
            mainLoop.ReevaluateElitesParameter.ActualName    = ReevaluateElitesParameter.Name;
            mainLoop.MutatorParameter.ActualName             = MutatorParameter.Name;
            mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
            mainLoop.RandomParameter.ActualName              = randomCreator.RandomParameter.ActualName;
            mainLoop.ResultsParameter.ActualName             = "Results";
            mainLoop.AnalyzerParameter.ActualName            = AnalyzerParameter.Name;
            mainLoop.IslandAnalyzerParameter.ActualName      = IslandAnalyzerParameter.Name;
            mainLoop.EvaluatedSolutionsParameter.ActualName  = "EvaluatedSolutions";
            mainLoop.Successor = null;

            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;
            }

            foreach (ISelector selector in ApplicationManager.Manager.GetInstances <ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
            {
                EmigrantsSelectorParameter.ValidValues.Add(selector);
            }

            foreach (IReplacer replacer in ApplicationManager.Manager.GetInstances <IReplacer>().OrderBy(x => x.Name))
            {
                ImmigrationReplacerParameter.ValidValues.Add(replacer);
            }

            ParameterizeSelectors();

            foreach (IMigrator migrator in ApplicationManager.Manager.GetInstances <IMigrator>().OrderBy(x => x.Name))
            {
                // BackwardsCompatibility3.3
                // Set the migration direction to counterclockwise
                var unidirectionalRing = migrator as UnidirectionalRingMigrator;
                if (unidirectionalRing != null)
                {
                    unidirectionalRing.ClockwiseMigrationParameter.Value = new BoolValue(false);
                }
                MigratorParameter.ValidValues.Add(migrator);
            }

            qualityAnalyzer       = new BestAverageWorstQualityAnalyzer();
            islandQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
            ParameterizeAnalyzers();
            UpdateAnalyzers();

            Initialize();
        }
Example #26
0
        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();
        }
Example #27
0
        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 LookupParameter <DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
            Parameters.Add(new LookupParameter <BoolValue>("MoveTabu", "The value that indicates if a move is tabu or not."));
            Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
            Parameters.Add(new ValueLookupParameter <IntValue>("TabuTenure", "The length of the tabu list, and also means the number of iterations a move is kept tabu"));

            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>("TabuChecker", "The operator that checks whether a move is tabu."));
            Parameters.Add(new ValueLookupParameter <IOperator>("TabuMaker", "The operator that declares a move tabu."));

            Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze the solution and moves."));
            Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
            Parameters.Add(new LookupParameter <IntValue>("EvaluatedMoves", "The number of evaluated moves."));
            #endregion

            #region Create operators
            VariableCreator           variableCreator        = new VariableCreator();
            SubScopesProcessor        subScopesProcessor0    = new SubScopesProcessor();
            Assigner                  bestQualityInitializer = new Assigner();
            Placeholder               analyzer1                  = new Placeholder();
            ResultsCollector          resultsCollector1          = new ResultsCollector();
            SubScopesProcessor        solutionProcessor          = new SubScopesProcessor();
            Placeholder               moveGenerator              = new Placeholder();
            UniformSubScopesProcessor moveEvaluationProcessor    = new UniformSubScopesProcessor();
            Placeholder               moveEvaluator              = new Placeholder();
            Placeholder               tabuChecker                = new Placeholder();
            SubScopesCounter          subScopesCounter           = new SubScopesCounter();
            SubScopesSorter           moveQualitySorter          = new SubScopesSorter();
            TabuSelector              tabuSelector               = new TabuSelector();
            ConditionalBranch         emptyNeighborhoodBranch1   = new ConditionalBranch();
            SubScopesProcessor        moveMakingProcessor        = new SubScopesProcessor();
            UniformSubScopesProcessor selectedMoveMakingProcesor = new UniformSubScopesProcessor();
            Placeholder               tabuMaker                  = new Placeholder();
            Placeholder               moveMaker                  = new Placeholder();
            MergingReducer            mergingReducer             = new MergingReducer();
            Placeholder               analyzer2                  = new Placeholder();
            SubScopesRemover          subScopesRemover           = new SubScopesRemover();
            ConditionalBranch         emptyNeighborhoodBranch2   = new ConditionalBranch();
            BestQualityMemorizer      bestQualityUpdater         = new BestQualityMemorizer();
            IntCounter                iterationsCounter          = new IntCounter();
            Comparator                iterationsComparator       = new Comparator();
            ConditionalBranch         iterationsTermination      = new ConditionalBranch();

            variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Iterations", new IntValue(0))); // Class TabuSearch expects this to be called Iterations
            variableCreator.CollectedValues.Add(new ValueParameter <BoolValue>("EmptyNeighborhood", new BoolValue(false)));
            variableCreator.CollectedValues.Add(new ValueParameter <ItemList <IItem> >("TabuList", new ItemList <IItem>()));
            variableCreator.CollectedValues.Add(new ValueParameter <VariableCollection>("Memories", new VariableCollection()));
            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 <IntValue>("Iterations"));
            resultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>("Best Quality", null, "BestQuality"));
            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;

            tabuChecker.Name = "TabuChecker (placeholder)";
            tabuChecker.OperatorParameter.ActualName = TabuCheckerParameter.Name;

            subScopesCounter.Name = "Increment EvaluatedMoves";
            subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;

            moveQualitySorter.DescendingParameter.ActualName = MaximizationParameter.Name;
            moveQualitySorter.ValueParameter.ActualName      = MoveQualityParameter.Name;

            tabuSelector.AspirationParameter.Value       = new BoolValue(true);
            tabuSelector.BestQualityParameter.ActualName = "BestQuality";
            tabuSelector.CopySelected = new BoolValue(false);
            tabuSelector.EmptyNeighborhoodParameter.ActualName = "EmptyNeighborhood";
            tabuSelector.MaximizationParameter.ActualName      = MaximizationParameter.Name;
            tabuSelector.MoveQualityParameter.ActualName       = MoveQualityParameter.Name;
            tabuSelector.MoveTabuParameter.ActualName          = MoveTabuParameter.Name;

            moveMakingProcessor.Name = "MoveMaking processor (UniformSubScopesProcessor)";

            emptyNeighborhoodBranch1.Name = "Neighborhood empty?";
            emptyNeighborhoodBranch1.ConditionParameter.ActualName = "EmptyNeighborhood";

            tabuMaker.Name = "TabuMaker (placeholder)";
            tabuMaker.OperatorParameter.ActualName = TabuMakerParameter.Name;

            moveMaker.Name = "MoveMaker (placeholder)";
            moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;

            analyzer2.Name = "Analyzer (placeholder)";
            analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;

            subScopesRemover.RemoveAllSubScopes = true;

            bestQualityUpdater.Name = "Update BestQuality";
            bestQualityUpdater.MaximizationParameter.ActualName = MaximizationParameter.Name;
            bestQualityUpdater.QualityParameter.ActualName      = QualityParameter.Name;
            bestQualityUpdater.BestQualityParameter.ActualName  = "BestQuality";

            iterationsCounter.Name      = "Iterations Counter";
            iterationsCounter.Increment = new IntValue(1);
            iterationsCounter.ValueParameter.ActualName = "Iterations";

            iterationsComparator.Name       = "Iterations >= MaximumIterations";
            iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
            iterationsComparator.LeftSideParameter.ActualName  = "Iterations";
            iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
            iterationsComparator.ResultParameter.ActualName    = "Terminate";

            emptyNeighborhoodBranch2.Name = "Neighborhood empty?";
            emptyNeighborhoodBranch2.ConditionParameter.ActualName = "EmptyNeighborhood";

            iterationsTermination.Name = "Iterations Termination Condition";
            iterationsTermination.ConditionParameter.ActualName = "Terminate";
            #endregion

            #region Create operator graph
            OperatorGraph.InitialOperator = variableCreator;
            variableCreator.Successor     = subScopesProcessor0;
            subScopesProcessor0.Operators.Add(bestQualityInitializer);
            subScopesProcessor0.Successor    = resultsCollector1;
            bestQualityInitializer.Successor = analyzer1;
            analyzer1.Successor         = null;
            resultsCollector1.Successor = solutionProcessor;
            solutionProcessor.Operators.Add(moveGenerator);
            solutionProcessor.Successor          = iterationsCounter;
            moveGenerator.Successor              = moveEvaluationProcessor;
            moveEvaluationProcessor.Operator     = moveEvaluator;
            moveEvaluationProcessor.Successor    = subScopesCounter;
            moveEvaluator.Successor              = tabuChecker;
            tabuChecker.Successor                = null;
            subScopesCounter.Successor           = moveQualitySorter;
            moveQualitySorter.Successor          = tabuSelector;
            tabuSelector.Successor               = emptyNeighborhoodBranch1;
            emptyNeighborhoodBranch1.FalseBranch = moveMakingProcessor;
            emptyNeighborhoodBranch1.TrueBranch  = null;
            emptyNeighborhoodBranch1.Successor   = subScopesRemover;
            moveMakingProcessor.Operators.Add(new EmptyOperator());
            moveMakingProcessor.Operators.Add(selectedMoveMakingProcesor);
            moveMakingProcessor.Successor        = mergingReducer;
            selectedMoveMakingProcesor.Operator  = tabuMaker;
            selectedMoveMakingProcesor.Successor = null;
            tabuMaker.Successor                  = moveMaker;
            moveMaker.Successor                  = null;
            mergingReducer.Successor             = analyzer2;
            analyzer2.Successor                  = null;
            subScopesRemover.Successor           = null;
            iterationsCounter.Successor          = iterationsComparator;
            iterationsComparator.Successor       = emptyNeighborhoodBranch2;
            emptyNeighborhoodBranch2.TrueBranch  = null;
            emptyNeighborhoodBranch2.FalseBranch = iterationsTermination;
            emptyNeighborhoodBranch2.Successor   = null;
            iterationsTermination.TrueBranch     = null;
            iterationsTermination.FalseBranch    = solutionProcessor;
            #endregion
        }
Example #28
0
        public AlpsOffspringSelectionGeneticAlgorithm()
            : 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 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 FixedValueParameter <IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
            Parameters.Add(new FixedValueParameter <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 ConstrainedValueParameter <IManipulator>("Mutator", "The operator used to mutate solutions."));
            Parameters.Add(new FixedValueParameter <PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
            Parameters.Add(new FixedValueParameter <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 FixedValueParameter <DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
            Parameters.Add(new FixedValueParameter <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(1)));
            Parameters.Add(new FixedValueParameter <DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
            Parameters.Add(new FixedValueParameter <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 FixedValueParameter <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 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
            });

            Parameters.Add(new FixedValueParameter <EnumValue <AgingScheme> >("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue <AgingScheme>(ALPS.AgingScheme.Polynomial)));
            Parameters.Add(new FixedValueParameter <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 FixedValueParameter <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 FixedValueParameter <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 FixedValueParameter <IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1))
            {
                Hidden = true
            });
            Parameters.Add(new FixedValueParameter <BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true))
            {
                Hidden = true
            });

            Parameters.Add(new FixedValueParameter <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 AlpsOffspringSelectionGeneticAlgorithmMainLoop();
            #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.SuccessRatioParameter.ActualName                     = SuccessRatioParameter.Name;
            mainLoop.ComparisonFactorParameter.ActualName                 = ComparisonFactorParameter.Name;
            mainLoop.MaximumSelectionPressureParameter.ActualName         = MaximumSelectionPressureParameter.Name;
            mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
            mainLoop.FillPopulationWithParentsParameter.ActualName        = FillPopulationWithParentsParameter.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 operators
            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();
            selectionPressureAnalyzer      = new ValueAnalyzer();
            layerSelectionPressureAnalyzer = new ValueAnalyzer();
            currentSuccessRatioAnalyzer    = new ValueAnalyzer();
            #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();
        }
Example #29
0
        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();
        }
        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();
        }