4-Schwefel-Problem-2_21/schwefel_problem_221_d500.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": [
    "# function to choose: sphere, schwefel, rosenbrock, rastrigin, griewank, ackley\n",
    "func_name = 'schwefel'\n",
    "funcval, funcbias, search_space = read_values(func_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define algorithm\n",
    "\n",
    "gen = 20000\n",
    "algo = pg.algorithm(pg.sga(gen=gen,\n",
    "                           cr=0.85,\n",
    "                           eta_c=1.0,  \n",
    "                           m=0.01,\n",
    "                           param_m=5,\n",
    "                           param_s=10,\n",
    "                           crossover='sbx',\n",
    "                           mutation='polynomial',\n",
    "                           selection='truncated'))\n",
    "\n",
    "pop_size = 250"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------\n",
      "Function: F2 : Schwefel’s Problem 2.21\n",
      "Problem dimension: 500\n",
      "Search Space :  [-100, 100]\n",
      "Global Optimum: -450.00\n",
      "------------------------------------------------------------\n",
      "Algorithm: SGA: Genetic Algorithm\n",
      "Parameters: \n",
      "\tNumber of generations: 20000\n",
      "\tCrossover:\n",
      "\t\tType: sbx\n",
      "\t\tProbability: 0.85\n",
      "\t\tDistribution index: 1\n",
      "\tMutation:\n",
      "\t\tType: polynomial\n",
      "\t\tProbability: 0.01\n",
      "\t\tDistribution index: 5\n",
      "\tSelection:\n",
      "\t\tType: truncated\n",
      "\t\tTruncation size: 10\n",
      "\tSeed: 4092726710\n",
      "\tVerbosity: 100\n",
      "------------------------------------------------------------\n",
      "Fitness: 5.834709\n",
      "Solution: \n",
      "             X\n",
      "0   -26.606881\n",
      "1    -0.420862\n",
      "2   -59.731135\n",
      "3   -94.206785\n",
      "..         ...\n",
      "496 -96.534566\n",
      "497 -40.607915\n",
      "498 -89.480067\n",
      "499  -5.674990\n",
      "\n",
      "[500 rows x 1 columns]\n",
      "------------------------------------------------------------\n",
      "Nb of functions evaluations: 5000250\n",
      "Stopping criterion: after 19901 iterations\n",
      "computational time: 96.082 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 = 500\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
}