Ackley

---

Mathematical formulation of the Ackley function

Ackely function is a standard function used for benchmarking global optimization solvers. It is chosen for the complexity of the function, its multimodal nature and the known global minima.

An $n$-dimensional Ackley function has the following form

$$f(x) = -a \exp\!\left(-b \sqrt{\frac{1}{n} \sum_{i=1}^{n} x_i^2}\right) - \exp\!\left(\frac{1}{n} \sum_{i=1}^{n} \cos(c x_i)\right) + a + \exp(1)$$

where $a = 20 , b = \frac{1}{5}, c = 2\pi$

The global optima of the function is

$$f(x^{*}) = 0 \quad \text{at} \quad x^{*} = \{0,0,...,0\}$$

Implementation of Ackley function in BQPhy using C++ model file

As an example, we are solving the 2 dimensional Ackley function, whose global optima is

$$f(x^{*}) = 0 \quad \text{where} \quad x^{*} = \{0,0\}$$

The input variables $x_{i}$ are bounded with the following constraints $-10 \leq x_{i} \leq 10 , \quad i \in \{1,2\}$

The bounds for the decision variables are to be passed during the execution in BQPhy

You can get the template for the C++ model file from the BQPhy website and add the objective and constraints.

Assuming the chromosome is a list of length 2 and type double, the objective function can be written as follows.

#include<cmath>

auto objective = [](const std::vector<double>& x, int dimensionality) {
      const double PI = std::acos(-1);
      double fitnessValue = 0.0;
      double a = 20.0;
      double b = 0.2;
      double c = 2*PI;

      fitnessValue = -a*std::exp(-b*std::sqrt(0.5*(x[0]*x[0] + x[1]*x[1]))) - std::exp(0.5*(std::cos(c*x[0]) + std::cos(c*x[1]))) + a + std::exp(1);

      return fitnessValue;
}

The optimization problem does not have any explicit constraints other than that on the decision variables, hence the constraint function is empty.

You can impose the No_Penalty method to solve this problem.

std::vector<std::function<double(const std::vector<double>&, int)>> constraints = {};

std::string penalty_type = "No_Penalty";

You can also create a dummy constraint and solve it with Static_Penalty method and penalty coefficient be set to 0.

auto constraint1 = [](const std::vector<double>& x, int dimensionality) {
       double violation = 0.0;
       return violation;
   };

//------------------------Add the constraints to a vector------------------------//
std::vector<std::function<double(const >std::vector<double>&, int)>> constraints = {constraint1};
//------------------ Penalty coefficients for the constraints -------------------//
// Define penalty parameters
std::string penalty_type = "Static_Penalty"; 
std::vector<double> penaltyCoefficients = {0.0};

Running the model file in BQPhy platform

The code for the model file is attached in the end of the page

Follow the following steps to run the model file

• Add the model file to the platform

  Refer the Models page of the documentation for help on adding the model file

• Create an execution for the model to run the optimization problem. Since the problem consists of 2 continuous decision variables, the following parameters are fixed

  Number of decision variables = 2
  Type of variables            = Continuous
  Upper Bound                  = (Global) 10 
  Lower Bound                  = (Global) -10

  Refer Executions page of the documentation to learn more on the required parameters and on running the model file.

C++ model file for the Ackley function

The model file for this function comes out as follows

#include <cmath>
#include <vector>
#include <cstdlib>
#include <string>
#include <iostream>
#include <functional>
#include "optimizationProblem.h"


//=====================================================================================================
// Set the correct number of design variables. OPTIONAL
extern "C" int calculateDesignVariables()
{
    // TODO: Return the number of variables (e.g., size of the solution vector 'x')
    return 10; // <--- Change this value based on your specific problem
}
//=====================================================================================================
// Define objective and constraint functions, and select penalty type.
extern "C" void defineModel(OptimizationProblem& problem)
{
    //------------------------ Define Objective functions ------------------------//
    auto objective = [](const std::vector<double>& x, int dimensionality) {
        const double PI = std::acos(-1);
      double fitnessValue = 0.0;
      double a = 20.0;
      double b = 0.2;
      double c = 2*PI;

      fitnessValue = -a*std::exp(-b*std::sqrt(0.5*(x[0]*x[0] + x[1]*x[1]))) - std::exp(0.5*(std::cos(c*x[0]) + std::cos(c*x[1]))) + a + std::exp(1);

      return fitnessValue;
    };

    //------------------------Add the constraints to a vector------------------------//
    std::vector<std::function<double(const std::vector<double>&, int)>> constraints = {};
    //------------------ Penalty coefficients for the constraints -------------------//
    // Define penalty parameters
    std::string penalty_type = "No_Penalty"; 
//     std::vector<double> penaltyCoefficients = {100.0, 100.0};

    if(penalty_type == "No_Penalty") {   
        /////////// Using No-Penalty /////////////
        problem.Set_OptimizationProblem(objective, constraints, PenaltyType::No_Penalty);
    }
    else if(penalty_type == "Death_Penalty") {
        /////////// Using Death Penalty /////////////
        problem.Set_OptimizationProblem(objective, constraints, PenaltyType::Death_Penalty);
    }
    else if(penalty_type == "Static_Penalty") {
        ///////////// Using Static Penalty with a fixed penalty value /////////////       
        problem.Set_OptimizationProblem(objective, constraints, PenaltyType::Static_Penalty, penaltyCoefficients);
    }
    else if(penalty_type == "Debs_Penalty") {
        /////////// Using Deb's approach /////////////
        problem.Set_OptimizationProblem(objective, constraints, PenaltyType::Debs_Penalty);
    }
}

//=====================================================================================================
// Process or save results after optimization finishes.  OPTIONAL
extern "C" void postprocess(const std::vector<double>& x, std::string outputFilePath, int Trial_id) 
{
    // TODO: Implement custom logic to process the Best solution vector 'x' after optimization for each Trial
    // Write output to a file using 'outputFilePath'
}