5-shifted-Rosenbrock/shifted_rosenbrock_d50.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import math\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from numba import jit\n",
    "import pygmo as pg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcs = {\"sphere\": 0, \"schwefel\": 1, \"rosenbrock\": 2, \"rastrigin\": 3, \"griewank\": 4, \"ackley\": 5}\n",
    "funcs_dispname = {\"sphere\": \"F1 : Shifted Sphere Function\", \n",
    "                  \"schwefel\": \"F2 : Schwefel’s Problem 2.21\",\n",
    "                  \"rosenbrock\": \"F3 : Shifted Rosenbrock’s Function\",\n",
    "                  \"rastrigin\": \"F4 : Shifted Rastrigin’s Function\",\n",
    "                  \"griewank\": \"F5 : Shifted Griewank’s Function\",\n",
    "                  \"ackley\": \"F6 : Shifted Ackley’s Function\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_values(func):\n",
    "    val_path = os.path.join('../data/', func + '.csv')\n",
    "    bias_path = '../data/f_bias.csv'\n",
    "    ss_path = '../data/search_space.csv'\n",
    "    \n",
    "    func_df = pd.read_csv(val_path)\n",
    "    bias_df = pd.read_csv(bias_path)\n",
    "    searchspace_df = pd.read_csv(ss_path)\n",
    "\n",
    "    funcval = func_df.fvalue.values\n",
    "    funcbias = bias_df.fvalue.values[funcs[func]]\n",
    "    search_space = list(searchspace_df.iloc[funcs[func],])\n",
    "    return funcval, funcbias, search_space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function evaluation definitions\n",
    "\n",
    "@jit(nopython=True)\n",
    "def eval_cost(x, dim):\n",
    "    \n",
    "    if func_name == \"sphere\":\n",
    "        F = 0\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F += z * z\n",
    "        result = F + funcbias\n",
    "    elif func_name == \"schwefel\":\n",
    "        F = abs(x[0]- funcval[0])\n",
    "        for i in range(1,dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F = max(F, abs(z))\n",
    "        result = F + funcbias\n",
    "    elif func_name == \"rosenbrock\":\n",
    "        F = 0\n",
    "        y = np.empty(dim)\n",
    "        for i in range(dim - 1):\n",
    "            y[i] = x[i] - funcval[i] +1\n",
    "        for i in range(dim-2):\n",
    "            F += 100 * ((y[i]**2-y[i+1])**2) + (y[i]-1)**2\n",
    "        result = F + funcbias\n",
    "    elif func_name == \"rastrigin\":\n",
    "        F = 0\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F += z ** 2 - 10 * math.cos(2 * math.pi * z) + 10\n",
    "        result = F + funcbias\n",
    "        \n",
    "    elif func_name == \"griewank\":\n",
    "        F1 = 0\n",
    "        F2 = 1\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F1 += z ** 2 / 4000\n",
    "            F2 += math.cos(z / math.sqrt(i + 1))\n",
    "        result = F1 - F2 + 1 + funcbias\n",
    "    elif func_name == \"ackley\":\n",
    "        Sum1 = 0\n",
    "        Sum2 = 0\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            Sum1 += z ** 2\n",
    "            Sum2 += math.cos(2 * math.pi * z)\n",
    "        result = -20 * math.exp(-0.2 * math.sqrt(Sum1 / dim)) - math.exp(Sum2 / dim) + 20 + math.e + funcbias\n",
    "    else:\n",
    "        result = 0\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define UDP problem Class\n",
    "\n",
    "class My_problem:\n",
    "    def __init__(self, dim, bounds, glob_opt):\n",
    "        self.lower_bound = bounds[0]\n",
    "        self.upper_bound = bounds[1]\n",
    "        self.dimension = dim\n",
    "        self.fitness_per_eval = []\n",
    "        self.glob_opt = glob_opt\n",
    "\n",
    "    def fitness(self, x):\n",
    "        result = abs(eval_cost(x, self.dimension)-funcbias)\n",
    "        return [result]\n",
    "\n",
    "    def get_bounds(self):\n",
    "        x_min = self.lower_bound * np.ones(self.dimension)\n",
    "        x_max = self.upper_bound * np.ones(self.dimension)\n",
    "        return x_min, x_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to run selected algorithm on defined problem\n",
    "\n",
    "def solve_pb(dim, my_algo, bounds, optim, popsize):\n",
    "    pop = None\n",
    "    prob = pg.problem(My_problem(dim, bounds, optim))\n",
    "    pop = pg.population(prob, popsize)\n",
    "\n",
    "    my_algo.set_verbosity(100)\n",
    "\n",
    "    t1 = time.time()\n",
    "    pop = my_algo.evolve(pop)\n",
    "    t2 = time.time()\n",
    "\n",
    "    time_diff = t2-t1\n",
    "    \n",
    "    if my_algo.get_name().split(\":\")[0] == \"PSO\":\n",
    "        extract_algo = my_algo.extract(pg.pso)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"GPSO\":\n",
    "        extract_algo = my_algo.extract(pg.pso_gen)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"DE\":\n",
    "        extract_algo = my_algo.extract(pg.de)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"saDE\":\n",
    "        extract_algo = my_algo.extract(pg.sade)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"sa-DE1220\":\n",
    "        extract_algo = my_algo.extract(pg.de1220)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"SGA\":\n",
    "        extract_algo = my_algo.extract(pg.sga)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"ABC\":\n",
    "        extract_algo = my_algo.extract(pg.bee_colony)\n",
    "    \n",
    "    log = extract_algo.get_log()\n",
    "    curve = [x[2] for x in log]\n",
    "    niter = log[-1][0]\n",
    "    \n",
    "    return pop, curve, niter, time_diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to make print report of function solving\n",
    "\n",
    "def print_solution(dimension, my_algo, pop_evolved, log, niter, duration):\n",
    "    algorithm_name = my_algo.get_name()\n",
    "    parameters = my_algo.get_extra_info()\n",
    "    solution_x = pop_evolved.champion_x\n",
    "    fitness = pop_evolved.champion_f[0]\n",
    "    n_evals = pop_evolved.problem.get_fevals()\n",
    "    print('-'*60)\n",
    "    print(\"Function: %s\" % funcs_dispname[func_name])\n",
    "    print(\"Problem dimension: %d\" % dimension)\n",
    "    print(\"Search Space : \", search_space)\n",
    "    print(\"Global Optimum: %.2f\" % funcbias)\n",
    "    print('-'*60)\n",
    "    print(\"Algorithm: %s\" % algorithm_name)\n",
    "    print(\"Parameters: \\n%s\" % parameters)\n",
    "    print('-'*60)\n",
    "    print(\"Fitness: %f\" % fitness)\n",
    "    print(\"Solution: \")\n",
    "    with pd.option_context('display.max_rows',8):\n",
    "        print(pd.DataFrame(solution_x, columns=['X']))\n",
    "    print('-'*60)\n",
    "    print(\"Nb of functions evaluations: %d\" % n_evals)\n",
    "    print(\"Stopping criterion: after %d iterations\" % niter)\n",
    "    print(\"computational time: %.3f seconds\" % duration)\n",
    "\n",
    "    plt.plot(log)\n",
    "    plt.xlabel(\"iterations (x100)\")\n",
    "    plt.ylabel(\"fitness: f(x)-f(x*)\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select function of problem to be solved\n",
    "# function to choose: sphere, schwefel, rosenbrock, rastrigin, griewank, ackley\n",
    "func_name = 'rosenbrock'\n",
    "funcval, funcbias, search_space = read_values(func_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define algorithm\n",
    "gen=2000\n",
    "algo = pg.algorithm(pg.de(gen=gen, \n",
    "                          F=0.6, \n",
    "                          CR=0.95, \n",
    "                          variant=3, \n",
    "                          ftol=1e-5, \n",
    "                          xtol=1e-5\n",
    "                         ))\n",
    "\n",
    "pop_size = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------\n",
      "Function: F3 : Shifted Rosenbrock’s Function\n",
      "Problem dimension: 50\n",
      "Search Space :  [-100, 100]\n",
      "Global Optimum: 390.00\n",
      "------------------------------------------------------------\n",
      "Algorithm: DE: Differential Evolution\n",
      "Parameters: \n",
      "\tGenerations: 2000\n",
      "\tParameter F: 0.600000\n",
      "\tParameter CR: 0.950000\n",
      "\tVariant: 3\n",
      "\tStopping xtol: 0.000010\n",
      "\tStopping ftol: 0.000010\n",
      "\tVerbosity: 100\n",
      "\tSeed: 3320236983\n",
      "------------------------------------------------------------\n",
      "Fitness: 0.000004\n",
      "Solution: \n",
      "            X\n",
      "0  -75.427494\n",
      "1  -35.731714\n",
      "2  -57.595634\n",
      "3   38.909831\n",
      "..        ...\n",
      "46  88.444401\n",
      "47 -34.270605\n",
      "48 -43.835599\n",
      "49 -24.464283\n",
      "\n",
      "[50 rows x 1 columns]\n",
      "------------------------------------------------------------\n",
      "Nb of functions evaluations: 273450\n",
      "Stopping criterion: after 1801 iterations\n",
      "computational time: 1.144 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run algorithm and print solution\n",
    "DIM = 50\n",
    "\n",
    "pop_evolv, logs, nit, compute_time = solve_pb(dim=DIM, \n",
    "                                              my_algo=algo, \n",
    "                                              bounds=search_space, \n",
    "                                              optim=funcbias, \n",
    "                                              popsize=pop_size\n",
    "                                             )\n",
    "\n",
    "print_solution(dimension=DIM, \n",
    "               my_algo=algo, \n",
    "               pop_evolved=pop_evolv, \n",
    "               log=logs, \n",
    "               niter=nit, \n",
    "               duration=compute_time\n",
    "              )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "meta",
   "language": "python",
   "name": "meta"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}