kgal-core/kgal.distributed/DistributedGA

DistributedGA

interface DistributedGA<V, F> : GA<V, F>

DistributedGA - also known as the island genetic algorithm (dGA).

F - fitness value of Chromosome

DistributedGA is an algorithm that divides a large population into subpopulations and runs the genetic algorithm on each subpopulation independently. Kgal offers a broader and more universal definition for a DistributedGA: dGA is an algorithm that controls the evolutionary processes of child genetic algorithms (children).

The launched evolutionary processes of child GAs are calculated independently of each other, which allows for efficient and safe use of parallelism: set the value ParallelismConfig.workersCount equal to the number of child GAs (children.size), this will allow children to be launched on separate parallel coroutines that achieves almost linear speedup compared to the classical version of the genetic algorithm.

dGA(...) {
    parallelismConfig {
        // distributed parallelism:
        // run each child GA independently in their own coroutine!
        workersCount = DISTRIBUTED_GA_COUNT
    }
}

The most popular type for DistributedGA is the island GA model, island evolutionary strategy includes:

launching child genetic algorithms (including parallel mode) default
synchronization of genetic algorithms (waiting for all to complete) default
checking stop conditions (NOTE don't forget to set a limit on the number of iterations with stopBy(DISTRIBUTED_MAX_ITERATION), otherwise the evolution will happen endlessly)
using genetic operators to interact between populations (for example: migration)

The first two steps are automated by kgal in the default behavior of the function DistributedConfigScope.evolve, so the island evolutionary strategy can be specified as:

evolve {
    // maxIteration stop condition is necessary!
    stopBy(maxIteration = DISTRIBUTED_MAX_ITERATION)
    migration(percent = 0.1)
}

DistributedGA supports Shared statistics, see statisticsProvider.

Creates with Kotlin DSL by dGA.

Types

Companion

object Companion

Properties

activeTimeTotal

val <V, F> GA<V, F>.activeTimeTotal: Duration

Duration between all subsessions of Session.

allSessions

val GA<*, *>.allSessions: SessionsInfo

Creates SessionsInfo that describes all activity of GA.

best

val <V, F> GA<V, F>.best: Chromosome<V, F>?

The best Chromosome in Population by fitness.

bestFitness

val <V, F> GA<V, F>.bestFitness: F?

The best fitness of Chromosome in Population.

children

abstract val children: List<GA<V, F>>

Contains current child genetic algorithms.

factory

val <V, F> GA<V, F>.factory: PopulationFactory<V, F>

Population Factory of GA.

fitnessFunction

abstract var fitnessFunction: (V) -> F

Fitness function - a function that evaluates the quality or "fitness" of each individual (chromosome) in a population. The fitness function determines how well a particular solution matches the target problem. It can be changed.

isActive

abstract val isActive: Boolean

Return true if GA is active.

iteration

abstract val iteration: Int

Current iteration of genetic algorithm.

mean

@get:JvmName(name = "getMeanDouble")

val GA<*, Double>.mean: Double

@get:JvmName(name = "getMeanInt")

val GA<*, Int>.mean: Double

@get:JvmName(name = "getMeanLong")

val GA<*, Long>.mean: Double

Mean fitness value of chromosomes in Population

median

@get:JvmName(name = "getMedianDouble")

val GA<*, Double>.median: Double

@get:JvmName(name = "getMedianInt")

val GA<*, Int>.median: Double

@get:JvmName(name = "getMedianLong")

val GA<*, Long>.median: Double

Median fitness value of chromosomes in Population

name

val GA<*, *>.name: String

Population Name of GA.

population

abstract override val population: DistributedPopulation<V, F>

The DistributedGA does not have its own population, but kgal defines this property as the total population of all subpopulations of child GAs (children).

random

abstract val random: Random

Random associated with GA. Defines a pseudorandom number generator for predictive calculations.

size