Relation between population size and function count for genetic algorithm

I am working on an integer parameter optimization with nonlinear constraints by genetic algorithm. I would like to know the relation between population size and function count.

Specifically, my problem has 36 variables and I set the population size 100. When I ran ga, the first generation has 200 func-count and it adds 95 after second generation.

I wonder why it does not increase by 100 in each generation.

                                  Best          Mean         Stall
Generation      Func-count     Penalty         Penalty    Generations
    1              200      -1.166e+06      -1.166e+06        0
    2              295      -1.166e+06       -5.83e+04        1
    3              390      -1.166e+06       -5.83e+04        2
    4              485      -1.166e+06       -5.83e+04        3
    5              580      -1.166e+06       -5.83e+04        4
    6              675      -1.166e+06       -5.83e+04        5
    7              770      -1.166e+06       -5.83e+04        6
    8              865      -1.166e+06       -5.83e+04        7
    9              960      -1.166e+06       -5.83e+04        8
   10             1055      -1.166e+06       -5.83e+04        9
   11             1150      -1.166e+06       -5.83e+04       10
Optimization terminated: average change in the penalty fitness value less than options.FunctionTolerance
and constraint violation is less than options.ConstraintTolerance.

I tired to set population size to 200 and the result was as follows. The first generation has 400 and it adds up 195 by generations.

                                  Best          Mean         Stall
Generation      Func-count     Penalty         Penalty    Generations
    1              400      -1.166e+06      -1.166e+06        0
    2              595      -1.166e+06      -2.915e+04        1
    3              790      -1.166e+06      -2.915e+04        2
    4              985      -1.166e+06      -2.915e+04        3
    5             1180      -1.166e+06      -2.915e+04        4
    6             1375      -1.166e+06      -1.166e+06        5
    7             1570      -1.166e+06      -2.915e+04        6
    8             1765      -1.166e+06      -1.166e+06        7
    9             1960      -1.166e+06      -2.915e+04        8
   10             2155      -1.166e+06      -2.915e+04        9
   11             2350      -1.166e+06      -2.915e+04       10

Here is the options for my problem.

   options = 
  ga オプション:
   設定されているプロパティ:
             ConstraintTolerance: 0.5000
                     CreationFcn: []
                         Display: 'iter'
         InitialPopulationMatrix: [1×36 double]
                  MaxGenerations: 10000
             MaxStallGenerations: 10
                         PlotFcn: {@gaplotbestf}
                     UseParallel: 1
   既定のプロパティ:
                    CrossoverFcn: @crossoverscattered
               CrossoverFraction: 0.8000
                      EliteCount: '0.05*PopulationSize'
                    FitnessLimit: -Inf
               FitnessScalingFcn: @fitscalingrank
               FunctionTolerance: 1.0000e-06
                       HybridFcn: []
          InitialPopulationRange: []
             InitialScoresMatrix: []
                    MaxStallTime: Inf
                         MaxTime: Inf
                     MutationFcn: {@mutationgaussian  [1]  [1]}
    NonlinearConstraintAlgorithm: 'auglag'
                       OutputFcn: []
                  PopulationSize: '50 when numberOfVariables <= 5, else 200'
                  PopulationType: 'doubleVector'
                    SelectionFcn: @selectionstochunif
                   UseVectorized: 0

Could you tell me why func-count does not add up the size of population size by generation?

And why is the first generation has twice size of the population size?

It would be very helpful for me if you could give me some advice.

Thank you.

Answer 1

[Alan Weiss]

The answer is that some population members are "elite," and they do not have to be evaluated again. See How the Genetic Algorithm Works.

Alan Weiss

MATLAB mathematical toolbox documentation

[Yohei]

Thank you so much for the answer. I understood that elite was not calculated. I will read the reference you gave also.

But I still don’t understand why does the first generation has twice number of function count as population size setting. Could you please tell me the reason for this?

[Alan Weiss]

I am not completely sure, but the reason that the first generation takes twice as many function evaluations as population members could be that there are two steps:

• Create the initial population and score it, meaning evaluate the population at all the created individuals
• Create the next generation, which involves evaluating the new population

The reason that I might be wrong about this is that the next generation should take N - EliteCount evaluations, where N is the population size. But you show that it takes N evaluations. So I am a bit puzzled.

On a related subject, I wonder if you have seen the advice in Effective Integer ga. The recommendations are to take a much larger population than you are using.

Good luck,

Alan Weiss

MATLAB mathematical toolbox documentation

[Yohei]

Thank you for the explanation. It is conducive to my understanding.

I will also try some trials with different number of population size.