bnigatu/PSO.ipynb

## PSO.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "__author__      = \"Nigatu, Biz\"\n",
    "__copyright__   = \"Copyright 2020, Nigatu.com\"\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from numpy import array\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sphere(x):\n",
    "    return sum ([y**2 for y in x])\n",
    "\n",
    "#sanity\n",
    "x = [1,2,3]\n",
    "sphere(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem definition\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "utility_function = sphere # cost function\n",
    "n_var = 5; # number of unkown/ decision variables\n",
    "var_size = array([1, n_var]) # matrix size of decision variables\n",
    "var_min = -10 # lower bound of decision variable\n",
    "var_max = 10 # upper bound of decision variables\n",
    "max_velocity = 0.2* (var_max - var_min)\n",
    "min_velocity = -max_velocity\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PSO parameters\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><u>Constriction Coefficients</u>\n",
    "\n",
    "$\\chi = \\frac{2\\kappa}{\\lvert 2-\\phi - \\sqrt{\\phi^2 - 4\\phi} \\rvert} $\n",
    " \n",
    "$where: 0 \\leq \\kappa \\leq 1$\n",
    "<br>\n",
    "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\phi = \\phi_1 + \\phi_2 \\geq 4 $</h3> \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "kappa = 1\n",
    "phi1 = 2.05\n",
    "phi2 = 2.05\n",
    "phi = phi1 + phi1\n",
    "chi = 2 * kappa / abs(2 - phi - math.sqrt(phi**2 - 4* phi))\n",
    "\n",
    "max_iter = 1000 # maximum iteration\n",
    "n_pop = 50 # population/swarm size\n",
    "w = chi # inertia coefficient\n",
    "w_damp = 1 # damping ratio of inertia coefficient\n",
    "c1 = chi * phi1 # personal acceleration coefficient\n",
    "c2 = chi * phi2 # social/ global acceleration coefficient\n",
    "show_iter_info = True # show iteration information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialization\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global_cost = 59.64772423349538\n",
      "global_postion = [ 2.46091651 -3.01579963  5.46084206 -3.12011952 -2.22275165]\n"
     ]
    }
   ],
   "source": [
    "global_best = {'Cost': float('inf'), # global cost for minimization problem before optimization is infinity\n",
    "               'Position': np.zeros(var_size)[0]} # global positoin\n",
    "best_cost = {} # vector of best costs\n",
    "empty_particle = {'Position': [],\n",
    "                  'Velocity': [],\n",
    "                  'Cost': [],\n",
    "                  'BestPosition': [],\n",
    "                  'BestCost': []} # empty dict template variable\n",
    "\n",
    "particle = np.tile(empty_particle, (n_pop,1)) # create particle of size n_pop\n",
    "\n",
    "\n",
    "tmp = [] # temp var\n",
    "for p in particle: \n",
    "    x = np.random.uniform(var_min, var_max, var_size)[0] # generate a random solution\n",
    "    tmp.append({'Position': x, # add particle (i) position for random x\n",
    "                'Velocity': np.zeros(var_size), # intialize velocity to vector of zero's size var_size\n",
    "                'Cost': utility_function(x), # evaluate the cost function\n",
    "                'BestPosition': x, # update personal best to current position\n",
    "                'BestCost': utility_function(x) # update best cost to current cost\n",
    "               })\n",
    "    if utility_function(x) < global_best['Cost']: \n",
    "        global_best['Cost'] = utility_function(x)  # replace global_best[Cost] if current_cost is better\n",
    "        global_best['Position'] = x  # replace global_best[Position] if current_cost is better\n",
    "    \n",
    "particle = tmp    \n",
    "\n",
    "# sanity test\n",
    "print('global_cost =',global_best['Cost'])\n",
    "print('global_postion =',global_best['Position'])\n",
    "#pd.DataFrame(particle).head(2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PSO main loop\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0304527ea42f47e1ae172c211af23591",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "itter: 0 best_cost: 29.748573\n",
      "itter: 50 best_cost: 0.120425\n",
      "itter: 100 best_cost: 0.050334\n",
      "itter: 150 best_cost: 0.010788\n",
      "itter: 200 best_cost: 0.003608\n",
      "itter: 250 best_cost: 0.003002\n",
      "itter: 300 best_cost: 0.002862\n",
      "itter: 350 best_cost: 0.002355\n",
      "itter: 400 best_cost: 0.001341\n",
      "itter: 450 best_cost: 0.001341\n",
      "itter: 500 best_cost: 0.000151\n",
      "itter: 550 best_cost: 0.000114\n",
      "itter: 600 best_cost: 0.000080\n",
      "itter: 650 best_cost: 0.000009\n",
      "itter: 700 best_cost: 0.000003\n",
      "itter: 750 best_cost: 0.000000\n",
      "itter: 800 best_cost: 0.000000\n",
      "itter: 850 best_cost: 0.000000\n",
      "itter: 900 best_cost: 0.000000\n",
      "itter: 950 best_cost: 0.000000\n",
      "itter: 999 best_cost: 0.000000\n",
      "\n",
      "final best_cost: 0.000000 \n",
      "best_position: [-4.06284600e-06 -3.40693044e-06 -3.89274948e-07 -4.04148438e-06\n",
      "  6.15179129e-07]\n"
     ]
    }
   ],
   "source": [
    "for r in tqdm(range(max_iter)):\n",
    "    for i in range(n_pop):\n",
    "        \"\"\"update velocity\"\"\"\n",
    "        particle[i]['Velocity'] = np.squeeze(w * particle[i]['Velocity'] + \\\n",
    "                                  np.multiply((c1 * np.random.rand(var_size[0],var_size[1])[0]), \\\n",
    "                                              (particle[i]['BestPosition'] - particle[i]['Position'][0])) + \\\n",
    "                                  np.multiply((c2 * np.random.rand(var_size[0],var_size[1])[0]), \\\n",
    "                                     (global_best['Position'] - particle[i]['Position']))) # equation 1\n",
    "        \"\"\"apply velocity limits\"\"\"\n",
    "        particle[i]['Velocity'] = np.maximum(particle[i]['Velocity'], min_velocity)\n",
    "        particle[i]['Velocity'] = np.minimum(particle[i]['Velocity'], max_velocity)\n",
    "        \"\"\"update positon\"\"\" \n",
    "        particle[i]['Position'] = np.squeeze(particle[i]['Position'] + particle[i]['Velocity']) # equation 2 \n",
    "        \"\"\"apply lower-upper bound limits\"\"\"\n",
    "        particle[i]['Position'] = np.maximum(particle[i]['Position'], var_min)\n",
    "        particle[i]['Position'] = np.minimum(particle[i]['Position'], var_max)\n",
    "        \"\"\"evaluation\"\"\"\n",
    "        particle[i]['Cost'] = utility_function(particle[i]['Position']) # equation 3\n",
    "        \"\"\"update personal best\"\"\"\n",
    "        if particle[i]['Cost'] < particle[i]['BestCost']: \n",
    "            particle[i]['BestCost'] = particle[i]['Cost']\n",
    "            particle[i]['BestPosition'] = particle[i]['Position'] # equation 4         \n",
    "        \"\"\"update global best\"\"\"\n",
    "        if particle[i]['BestCost'] < global_best['Cost']: # equation 5\n",
    "            global_best['Cost'] = particle[i]['BestCost']\n",
    "            global_best['Position'] = particle[i]['Position']\n",
    "    w *= w_damp\n",
    "    best_cost[r] = global_best['Cost']\n",
    "    if r % 50 == 0 or r == max_iter-1:\n",
    "        print(\"itter: %d best_cost: %f\" % (r, global_best['Cost']))\n",
    "        \n",
    "print(\"final best_cost: %f \\nbest_position: %s\" % (global_best['Cost'], str(global_best['Position']) ))  \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Result\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Best Cost')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "plt.style.use('seaborn-whitegrid')\n",
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "\n",
    "items = sorted(best_cost.items())\n",
    "x, y = zip(*items) \n",
    "\n",
    "ax.plot(x, y);\n",
    "plt.title('PSO Training')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Best Cost')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Best Cost')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.semilogy(x, y )\n",
    "plt.title('PSO Convergence')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Best Cost')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Implementation\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Param(object):\n",
    "    def __init__(self, max_iter = 1000, n_pop = 50, kappa = 1,phi1 = 2.05, phi2 = 2.05, w_damp = 1, show_iter_info = True):\n",
    "        #super(Param, self).__init__(max_iter, n_pop, kappa, phi1, phi2, w_damp, show_iter_info)\n",
    "        self.kappa = kappa\n",
    "        self.phi1 = phi1\n",
    "        self.phi2 = phi2\n",
    "        self.phi = phi1 + phi1\n",
    "        self.chi = 2 * self.kappa / abs(2 - self.phi - math.sqrt(self.phi**2 - 4* self.phi))\n",
    "\n",
    "        self.max_iter = max_iter # maximum iteration\n",
    "        self.n_pop = n_pop # population/swarm size\n",
    "        self.w = self.chi # inertia coefficient\n",
    "        self.w_damp = w_damp # damping ratio of inertia coefficient\n",
    "        self.c1 = self.chi * self.phi1 # personal acceleration coefficient\n",
    "        self.c2 = self.chi * self.phi2 # social/ global acceleration coefficient\n",
    "        self.show_iter_info = show_iter_info # show iteration information\n",
    "        self.global_best = {} # global best\n",
    "        self.best_cost = [] # vector of best costs\n",
    "        self.empty_particle = {} # empty dict template variable\n",
    "        self.particle = {}\n",
    "    def get_particle(self):\n",
    "         raise NotImplementedError\n",
    "    def __repr__(self):\n",
    "        return (\"\"\"\n",
    "                kappa = %r \n",
    "                phi1 = %r\n",
    "                phi2 = %r\n",
    "                phi = %r\n",
    "                chi = %r\n",
    "                max_iter = %r\n",
    "                n_pop = %r\n",
    "                w = %r\n",
    "                w_damp = %r\n",
    "                c1 = %r\n",
    "                c2 = %r\n",
    "                show_iter_info = %r\n",
    "               \"\"\" % (self.kappa,\n",
    "                      self.phi1,\n",
    "                      self.phi2,\n",
    "                      self.phi,\n",
    "                      self.chi,\n",
    "                      self.max_iter,\n",
    "                      self.n_pop,\n",
    "                      self.w,\n",
    "                      self.w_damp,\n",
    "                      self.c1,\n",
    "                      self.c2,\n",
    "                      self.show_iter_info))\n",
    "#sanity        \n",
    "# param = Param()\n",
    "# print(param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Init(Param):\n",
    "    def __init__(self, max_iter = 1000, n_pop = 50, kappa = 1,phi1 = 2.05, phi2 = 2.05, w_damp = 1, show_iter_info = True):\n",
    "        super(Init, self).__init__(max_iter, n_pop, kappa, phi1, phi2, w_damp, show_iter_info)\n",
    "        self.global_best = {'Cost': float('inf'), # global cost for minimization problem before optimization is infinity\n",
    "                            'Position': np.zeros(var_size)[0]} # global positoin\n",
    "        self.best_cost = {} # vector of best costs\n",
    "        self.empty_particle = {'Position': [],\n",
    "                          'Velocity': [],\n",
    "                          'Cost': [],\n",
    "                          'BestPosition': [],\n",
    "                          'BestCost': []} # empty dict template variable\n",
    "        self.particle = self.get_particle() # create particle of size n_pop\n",
    "\n",
    "    def get_particle(self):\n",
    "        particle = np.tile(self.empty_particle, (self.n_pop,1)) # create particle of size n_pop\n",
    "        tmp = [] # temp var\n",
    "        for p in particle: \n",
    "            x = np.random.uniform(var_min, var_max, var_size)[0] # generate a random solution\n",
    "            tmp.append({'Position': x, # add particle (i) position for random x\n",
    "                        'Velocity': np.zeros(var_size), # intialize velocity to vector of zero's size var_size\n",
    "                        'Cost': utility_function(x), # evaluate the cost function\n",
    "                        'BestPosition': x, # update personal best to current position\n",
    "                        'BestCost': utility_function(x) # update best cost to current cost\n",
    "                       })\n",
    "            if utility_function(x) < self.global_best['Cost']: \n",
    "                self.global_best['Cost'] = utility_function(x)  # replace global_best[Cost] if current_cost is better\n",
    "                self.global_best['Position'] = x  # replace global_best[Position] if current_cost is better\n",
    "        return tmp \n",
    "    \n",
    "    def __repr__(self):\n",
    "        return super().__repr__()  + \\\n",
    "               \"\"\"\n",
    "                global_cost = %s\n",
    "                global_postion = %s\n",
    "               \"\"\" % (self.global_best['Cost'], self.global_best['Position'])\n",
    "    \n",
    "# sanity\n",
    "# init = Init()\n",
    "# print(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PSO(Init):\n",
    "    def __init__(self, max_iter = 1000, n_pop = 50, kappa = 1,phi1 = 2.05, phi2 = 2.05, w_damp = 1, show_iter_info = True):\n",
    "        super(PSO, self).__init__(max_iter, n_pop, kappa, phi1, phi2, w_damp, show_iter_info)\n",
    "        pass\n",
    "    \n",
    "    def pso(self):\n",
    "        for r in tqdm(range(self.max_iter)):\n",
    "            for i in range(self.n_pop):\n",
    "                \"\"\"update velocity\"\"\"\n",
    "                self.particle[i]['Velocity'] = np.squeeze(self.w * self.particle[i]['Velocity'] + \\\n",
    "                                          np.multiply((self.c1 * np.random.rand(var_size[0],var_size[1])[0]), \\\n",
    "                                                      (self.particle[i]['BestPosition'] - self.particle[i]['Position'][0])) + \\\n",
    "                                          np.multiply((self.c2 * np.random.rand(var_size[0],var_size[1])[0]), \\\n",
    "                                             (self.global_best['Position'] - self.particle[i]['Position']))) # equation 1\n",
    "                \"\"\"apply velocity limits\"\"\"\n",
    "                self.particle[i]['Velocity'] = np.maximum(self.particle[i]['Velocity'], min_velocity)\n",
    "                self.particle[i]['Velocity'] = np.minimum(self.particle[i]['Velocity'], max_velocity)\n",
    "                \"\"\"update positon\"\"\" \n",
    "                self.particle[i]['Position'] = np.squeeze(self.particle[i]['Position'] + self.particle[i]['Velocity']) # equation 2 \n",
    "                \"\"\"apply lower-upper bound limits\"\"\"\n",
    "                self.particle[i]['Position'] = np.maximum(self.particle[i]['Position'], var_min)\n",
    "                self.particle[i]['Position'] = np.minimum(self.particle[i]['Position'], var_max)\n",
    "                \"\"\"evaluation\"\"\"\n",
    "                self.particle[i]['Cost'] = utility_function(self.particle[i]['Position']) # equation 3\n",
    "                \"\"\"update personal best\"\"\"\n",
    "                if self.particle[i]['Cost'] < self.particle[i]['BestCost']: \n",
    "                    self.particle[i]['BestCost'] = self.particle[i]['Cost']\n",
    "                    self.particle[i]['BestPosition'] = self.particle[i]['Position'] # equation 4         \n",
    "                \"\"\"update global best\"\"\"\n",
    "                if self.particle[i]['BestCost'] < self.global_best['Cost']: # equation 5\n",
    "                    self.global_best['Cost'] = self.particle[i]['BestCost']\n",
    "                    self.global_best['Position'] = self.particle[i]['Position']\n",
    "            self.w *= self.w_damp\n",
    "            self.best_cost[r] = self.global_best['Cost']\n",
    "            if r % 50 == 0 or r == self.max_iter-1:\n",
    "                print(\"itter: %d best_cost: %f\" % (r, self.global_best['Cost']))\n",
    "        print(\"final best_cost: %f \\nbest_position: %s\" % (self.global_best['Cost'], str(self.global_best['Position']) ))\n",
    "        return self.global_best['Cost'], str(self.global_best['Position'])\n",
    "    def display(self, graph='plot'):\n",
    "        if(len(self.best_cost) == 0): return \"Run you_object.pso() first.\"\n",
    "        %matplotlib inline\n",
    "        plt.style.use('seaborn-whitegrid')\n",
    "        fig = plt.figure()\n",
    "        ax = plt.axes()\n",
    "        items = sorted(self.best_cost.items())\n",
    "        x, y = zip(*items) \n",
    "        if (graph=='plot'):\n",
    "            ax.plot(x, y);\n",
    "            plt.title('PSO Training')\n",
    "            plt.xlabel('Iteration')\n",
    "            plt.ylabel('Best Cost')\n",
    "        elif (graph=='semilogy'):\n",
    "            plt.semilogy(x, y )\n",
    "            plt.title('PSO Convergence')\n",
    "            plt.xlabel('Iteration')\n",
    "            plt.ylabel('Best Cost')        \n",
    "    def __repr__(self):\n",
    "        return super().__repr__()  \n",
    "                  \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7737beb0afd74b5aba5bdebb3ff58676",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "itter: 0 best_cost: 33.991001\n",
      "itter: 50 best_cost: 1.036756\n",
      "itter: 100 best_cost: 0.020032\n",
      "itter: 150 best_cost: 0.002777\n",
      "itter: 200 best_cost: 0.000274\n",
      "itter: 250 best_cost: 0.000040\n",
      "itter: 300 best_cost: 0.000004\n",
      "itter: 350 best_cost: 0.000003\n",
      "itter: 400 best_cost: 0.000000\n",
      "itter: 450 best_cost: 0.000000\n",
      "itter: 500 best_cost: 0.000000\n",
      "itter: 550 best_cost: 0.000000\n",
      "itter: 600 best_cost: 0.000000\n",
      "itter: 650 best_cost: 0.000000\n",
      "itter: 700 best_cost: 0.000000\n",
      "itter: 750 best_cost: 0.000000\n",
      "itter: 800 best_cost: 0.000000\n",
      "itter: 850 best_cost: 0.000000\n",
      "itter: 900 best_cost: 0.000000\n",
      "itter: 950 best_cost: 0.000000\n",
      "itter: 999 best_cost: 0.000000\n",
      "\n",
      "final best_cost: 0.000000 \n",
      "best_position: [ 4.61533124e-08 -5.30349479e-09 -3.02241719e-08  1.21532736e-08\n",
      " -2.42517884e-08]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3.807607177069591e-15,\n",
       " '[ 4.61533124e-08 -5.30349479e-09 -3.02241719e-08  1.21532736e-08\\n -2.42517884e-08]')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pso = PSO()\n",
    "pso.pso()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pso.display(graph='plot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pso.display(graph='semilogy')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}