pso.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# <center>Particle Swarm Optimization</center>\n",
        "## <center>Implementación</center>"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import copy\n",
        "import numpy as np\n",
        "\n",
        "class Individuo:\n",
        "    def __init__(self, solucion, velocidad):\n",
        "        self._solucion = solucion\n",
        "        self._velocidad = velocidad\n",
        "        self._b = copy.deepcopy(solucion)\n",
        "        self._b_fitness = np.inf"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-11-03T04:27:34.767Z",
          "iopub.execute_input": "2020-11-03T04:27:34.798Z",
          "iopub.status.idle": "2020-11-03T04:27:36.962Z",
          "shell.execute_reply": "2020-11-03T04:27:36.993Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PSO:\n",
        "    def __init__(self,\n",
        "    cantidad_individuos,\n",
        "    dimensiones,\n",
        "    ro, #Tamaño de vecindad\n",
        "    phi1_max,\n",
        "    phi2_max,\n",
        "    v_max,\n",
        "    problema,\n",
        "    generaciones):\n",
        "        self._cantidad_individuos = cantidad_individuos\n",
        "        self._dimensiones = dimensiones\n",
        "        self._ro = ro\n",
        "        self._phi1_max = phi1_max\n",
        "        self._phi2_max = phi2_max\n",
        "        self._v_max = v_max\n",
        "        self._problema = problema\n",
        "        self._generaciones = generaciones\n",
        "        self._individuos = []\n",
        "        self._rango = self._problema.MAX_VALUE - self._problema.MIN_VALUE\n",
        "        self._mejor = np.inf\n",
        "\n",
        "    def crearIndividuos(self):\n",
        "        for i in range(self._cantidad_individuos):\n",
        "            solucion = np.random.random(size = self._dimensiones) * self._rango + self._problema.MIN_VALUE\n",
        "            velocidad = np.random.random(size = self._dimensiones) * self._v_max * 2 + self._v_max\n",
        "            individuo = Individuo(solucion, velocidad)\n",
        "            individuo._b_fitness = self._problema.fitness(individuo._solucion)\n",
        "            self._individuos.append(individuo)\n",
        "\n",
        "    def mejorIndividuo(self):\n",
        "        for i in self._individuos:\n",
        "            fitness = self._problema.fitness(i._solucion)\n",
        "            if fitness < self._mejor:\n",
        "                self._mejor = fitness\n",
        "\n",
        "    def run(self):\n",
        "        self.crearIndividuos()\n",
        "        self.mejorIndividuo()\n",
        "        generacion = 0\n",
        "        while (generacion <= self._generaciones):\n",
        "            for idx in range(len(self._individuos)):\n",
        "                h = 0\n",
        "                for i in range(-self._ro // 2, self._ro // 2 + 1):\n",
        "                    if i == 0:\n",
        "                        continue\n",
        "                    elif i == -self._ro // 2:\n",
        "                        h = copy.deepcopy(self._individuos[(idx + i) % len(self._individuos)])\n",
        "                    elif self._problema.fitness(self._individuos[(idx + i) % len(self._individuos)]._solucion) < self._problema.fitness(h._solucion):\n",
        "                        h = copy.deepcopy(self._individuos[(idx + i) % len(self._individuos)])\n",
        "                phi1 = np.random.random(size = self._dimensiones) * self._phi1_max\n",
        "                phi2 = np.random.random(size = self._dimensiones) * self._phi2_max\n",
        "                self._individuos[idx]._velocidad = (self._individuos[idx]._velocidad +\n",
        "                np.multiply(phi1, self._individuos[idx]._b - self._individuos[idx]._solucion) +\n",
        "                np.multiply(phi2, h._solucion - self._individuos[idx]._solucion))\n",
        "                for i in range(self._dimensiones):\n",
        "                    if abs(self._individuos[idx]._velocidad[i]) > self._v_max:\n",
        "                        self._individuos[idx]._velocidad[i] = self._v_max / (self._individuos[idx]._velocidad[i])\n",
        "                self._individuos[idx]._solucion = self._individuos[idx]._solucion + self._individuos[idx]._velocidad\n",
        "                fitness_individuo = self._problema.fitness(self._individuos[idx]._solucion)\n",
        "                if fitness_individuo < self._individuos[idx]._b_fitness:\n",
        "                    self._individuos[idx]._b = copy.deepcopy(self._individuos[idx]._solucion)\n",
        "                    self._individuos[idx]._b_fitness = fitness_individuo\n",
        "                    if fitness_individuo < self._mejor:\n",
        "                        self._mejor = fitness_individuo\n",
        "            \n",
        "            if generacion % 100 == 0:\n",
        "                print('Generación ', generacion, ':', self._mejor)\n",
        "            generacion += 1"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-11-03T04:27:38.715Z",
          "iopub.execute_input": "2020-11-03T04:27:38.745Z",
          "iopub.status.idle": "2020-11-03T04:27:38.801Z",
          "shell.execute_reply": "2020-11-03T04:27:38.838Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Rosenbrock:\n",
        "    MIN_VALUE = -2.048\n",
        "    MAX_VALUE = 2.048\n",
        "    def __init__(self):\n",
        "        pass\n",
        "    def fitness(self, vector):\n",
        "        z = 0\n",
        "        for dimension in range(len(vector)-1):\n",
        "            z += 100 * (vector[dimension + 1] - vector[dimension]**2)**2 + (vector[dimension]-1)**2\n",
        "        return z"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-11-03T04:27:40.764Z",
          "iopub.execute_input": "2020-11-03T04:27:40.795Z",
          "iopub.status.idle": "2020-11-03T04:27:40.839Z",
          "shell.execute_reply": "2020-11-03T04:27:40.868Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def main():\n",
        "    rosen = Rosenbrock()\n",
        "    rango = rosen.MAX_VALUE - rosen.MIN_VALUE\n",
        "    cantidad_individuos = 30\n",
        "    dimensiones = 8\n",
        "    ro = 8\n",
        "    phi1_max = 1.7\n",
        "    phi2_max = 2.0\n",
        "    v_max = rango * 0.01\n",
        "    generaciones = 2000\n",
        "    pso = PSO(cantidad_individuos, dimensiones, ro, phi1_max, phi2_max, v_max, rosen, generaciones)\n",
        "    pso.run()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-11-03T04:28:15.779Z",
          "iopub.execute_input": "2020-11-03T04:28:15.810Z",
          "iopub.status.idle": "2020-11-03T04:28:15.864Z",
          "shell.execute_reply": "2020-11-03T04:28:15.891Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "main()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-11-03T04:28:18.447Z",
          "iopub.execute_input": "2020-11-03T04:28:18.492Z",
          "iopub.status.idle": "2020-11-03T04:30:43.670Z",
          "shell.execute_reply": "2020-11-03T04:30:43.716Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.3",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernelspec": {
      "argv": [
        "python",
        "-m",
        "ipykernel_launcher",
        "-f",
        "{connection_file}"
      ],
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "nteract": {
      "version": "0.26.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}