3-shifted-Sphere/shifted_sphere_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",
    "from scipy import optimize"
   ]
  },
  {
   "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_name + '.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_name]]\n",
    "    search_space = list(searchspace_df.iloc[funcs[func_name],])\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": [
    "def f(x, dim):\n",
    "    result = abs(eval_cost(x, dim)-funcbias)\n",
    "    fitness_per_eval.append(result)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initial_solution(dim, bounds):\n",
    "    xmin, xmax = bounds\n",
    "    x_min = xmin * np.ones(dim)\n",
    "    x_max = xmax * np.ones(dim)\n",
    "    cur_x = np.random.uniform(min(x_min), max(x_max), (1, dim))\n",
    "    return cur_x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_minimize(dim, search_space, method, options):\n",
    "    \n",
    "    cur_x = initial_solution(dim, search_space)\n",
    "    t1 = time.time()\n",
    "    result = optimize.minimize(f, args=(dim), x0=cur_x, method=method, options=options)\n",
    "    t2 = time.time()\n",
    "    \n",
    "    return result, t2-t1, fitness_per_eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to make print report of function solving\n",
    "\n",
    "def print_solution(dimension, method, options, result, log, duration):\n",
    "    \n",
    "    algorithm_name = method\n",
    "    parameters = options\n",
    "    solution_x = result.x\n",
    "    fitness = log[-1]\n",
    "    n_evals = len(log)\n",
    "    niter = result.nit\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\\n\" % 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',10):\n",
    "        print(pd.DataFrame(solution_x, columns=['X']))\n",
    "    print('-'*60)\n",
    "    print(\"Nb of functions evaluations: %d\" % n_evals)\n",
    "    print(\"Stopping criterion: gtol achieved: %.2e\" % options['gtol'])\n",
    "    print(result.message)\n",
    "    print(\"computational time: %.3f seconds\" % duration)\n",
    "\n",
    "    plt.plot(log)\n",
    "    plt.xlabel(\"iterations\")\n",
    "    plt.ylabel(\"fitness: f(x)-f(x*)\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select function of problem to be solved\n",
    "\n",
    "# function to choose: sphere, schwefel, rosenbrock, rastrigin, griewank, ackley\n",
    "func_name = 'sphere'\n",
    "funcval, funcbias, search_space = read_values(func_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define algorithm and parameters to use\n",
    "\n",
    "method = 'BFGS'\n",
    "options = {'maxiter': 100, 'gtol': 1e-5, 'disp': False}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------\n",
      "Function: F1 : Shifted Sphere Function\n",
      "Problem dimension: 500\n",
      "Search Space:  [-100, 100]\n",
      "Global Optimum: -450.00\n",
      "\n",
      "------------------------------------------------------------\n",
      "Algorithm: BFGS\n",
      "Parameters: \n",
      "{'maxiter': 100, 'gtol': 1e-05, 'disp': False}\n",
      "------------------------------------------------------------\n",
      "Fitness: 0.000000\n",
      "Solution: \n",
      "             X\n",
      "0    97.249936\n",
      "1    77.060986\n",
      "2   -19.031151\n",
      "3    25.428700\n",
      "4   -22.908801\n",
      "..         ...\n",
      "495 -70.131730\n",
      "496 -17.071780\n",
      "497 -86.203054\n",
      "498  76.838813\n",
      "499  75.761373\n",
      "\n",
      "[500 rows x 1 columns]\n",
      "------------------------------------------------------------\n",
      "Nb of functions evaluations: 5522\n",
      "Stopping criterion: gtol achieved: 1.00e-05\n",
      "Optimization terminated successfully.\n",
      "computational time: 0.283 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",
    "fitness_per_eval = []\n",
    "\n",
    "result, duration, logs = optimize_minimize(DIM, search_space, method, options)\n",
    "print_solution(dimension=DIM, method=method, options=options, result=result, log=logs, duration=duration)"
   ]
  }
 ],
 "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
}