DifferentialEvolutionOptimizer Class

public sealed class DifferentialEvolutionOptimizer : PopulationBasedOptimizer<Population<Candidate>, Candidate>

Public NotInheritable Class DifferentialEvolutionOptimizer
	Inherits PopulationBasedOptimizer(Of Population(Of Candidate), Candidate)

public ref class DifferentialEvolutionOptimizer sealed : public PopulationBasedOptimizer<Population<Candidate>^, Candidate>

[<SealedAttribute>]
type DifferentialEvolutionOptimizer = 
    class
        inherit PopulationBasedOptimizer<Population<Candidate>, Candidate>
    end

Inheritance

Object  →  ManagedIterativeAlgorithm<Vector<Double>, Double, OptimizationSolutionReport<Vector<Double>>>  →  MultidimensionalOptimizer<Vector<Double>, OptimizationSolutionReport<Vector<Double>>>  →  PopulationBasedOptimizer<Vector<Double>, Population<Candidate>, Candidate>  →  PopulationBasedOptimizer<Population<Candidate>, Candidate>  →  DifferentialEvolutionOptimizer

Use the DifferentialEvolutionOptimizer class to find an extremum of an objective function through population-based evolutionary optimization. The algorithm maintains a population of candidate solutions and creates new candidates through mutation and crossover operations.

The main advantage of this method is its robustness and ability to find global optima for non-convex, non-linear, and multimodal functions. It requires minimal tuning of control parameters and does not use gradient information.

The objective function must be supplied as a multivariate function delegate to the ObjectiveFunction property.

Before the algorithm is run, you must set the LowerBounds and UpperBounds properties to specify the search space constraints. The ExtremumType property specifies whether a minimum or a maximum of the objective function is desired.

The following example attempts to find a minimum for the Rastrigin function using the Differential Evolution optimizer.

The Rastrigin function is a challenging test problem for global optimization algorithms. The function has many local minima, which makes it tricky for an optimizer to find the global minimum.

// Define the Rastrigin function
Func<Vector<double>, double> rastrigin = (x) =>
{
    int n = x.Length;
    double A = 10;
    double sum = A * n;
    for (int i = 0; i < n; i++)
    {
        sum += x[i] * x[i] - A * Math.Cos(2 * Math.PI * x[i]);
    }
    return sum;
};

// Define the lower and upper bounds
Vector<double> lowerBounds = Vector.Create<double>(-5.12, -5.12);
Vector<double> upperBounds = Vector.Create<double>(5.12, 5.12);

// Create the optimizer
var optimizer = new DifferentialEvolutionOptimizer(
    objectiveFunction: rastrigin,
    lowerBounds: lowerBounds,
    upperBounds: upperBounds
);

// Run the optimization
optimizer.FindMinimum();

// Get the result
Vector<double> solution = optimizer.Extremum;
double value = optimizer.ValueAtExtremum;

Reference