# PSO

En informática, la optimización por nube de partículas u optimización por enjambre de partículas (conocida por sus siglas en inglés: PSO, de «particle swarm optimization») hace referencia a una metaheurística que evoca el comportamiento de las partículas en la naturaleza.

Los métodos PSO se atribuyen originalmente a los investigadores Kennedy, Eberhart1​ y Shi.2​ En un principio fueron concebidos para elaborar modelos de conductas sociales,3​ como el movimiento descrito por los organismos vivos en una bandada de aves o un banco de peces. Posteriormente el algoritmo se simplificó y se comprobó que era adecuado para problemas de optimización. El libro de Kennedy y Eberhart4​ describe numerosos aspectos teóricos de la PSO y la inteligencia de enjambre. Un amplio estudio de las aplicaciones de PSO se puede encontrar en Poli.5​6​

PSO permite optimizar un problema a partir de una población de soluciones candidatas, denotadas como "partículas", moviendo éstas por todo el espacio de búsqueda según reglas matemáticas que tienen en cuenta la posición y la velocidad de las partículas. El movimiento de cada partícula se ve influido por su mejor posición local hallada hasta el momento, así como por las mejores posiciones globales encontradas por otras partículas a medida que recorren el espacio de búsqueda. El fundamento teórico de esto es hacer que la nube de partículas converja rápidamente hacia las mejores soluciones.

PSO es una metaheurística, ya que asume pocas o ninguna hipótesis sobre el problema a optimizar y puede aplicarse en grandes espacios de soluciones candidatas. Sin embargo, como toda metaheurística, PSO no garantiza la obtención de una solución óptima en todos los casos.


```python
#!pip install --upgrade pyswarm
```


```python
%matplotlib inline
from pyswarm import pso
from sympy import *
import numpy as np
import matplotlib.pyplot as plt

init_printing()
```


```python
def fV(x):
    return x**2

lb = [3]
ub = [5]

xopt, fopt = pso(fV, lb, ub)
xopt,fopt

```

    Stopping search: maximum iterations reached --> 100





    (array([ 3.]), array([ 9.]))



## Ejemplo

Una caja rectangular sin tapa se hace con $12 m^2$ de cartón.

Calcule el volumen máximo de esta caja.

Solucion:

Sean $x, y y z$ el largo, el ancho
y la altura, respectivamente, de la caja medidos en metros. Buscamos maximizar

$$V=xyz $$

sujeta a la restricción

$$g(x,y,z) = 2xz + 2yz + xy = 12$$


```python
x,y,z,ld = symbols("x,y,z,lambda")
```


```python
L = x*y*z + ld*(2*x*z + 2*y*z + x*y - 12)
pcs= solve(map(L.diff,[x,y,z,ld]))
pcs
```


```python
L.subs(pcs[0]),L.subs(pcs[0])
```


```python
def fV(X):
    x = X[0]
    y = X[1]
    z = X[2]
    return -x*y*z

def con(X):
    x = X[0]
    y = X[1]
    z = X[2]
    return (2*x*z + 2*y*z + x*y -12)*-1

lb = [0,0,0]
ub = [5,5,5]

#xopt, fopt = pso(fV, lb, ub, f_ieqcons=con,swarmsize=100,maxiter=100)
xopt, fopt = pso(fV, lb, ub, f_ieqcons=con)
xopt,fopt
```

    Stopping search: Swarm best objective change less than 1e-08





    (array([ 1.96045277,  1.92423486,  1.05898198]), -3.9948735026620716)



Nota: 
- PSO minimiza entonces cambie la funcion a -f(x) y las restricciones de signo 
- el fopt da negativo por que cambie negativo el signo.


```python

```


```python

```

## Ejemplo

Un agricultor tiene $2 400$ metros de material y quiere construir una barda para
cercar un campo rectangular que bordea un río recto, de modo que no necesita barda a
lo largo del río. 

¿Cuáles son las dimensiones que debe tener el campo para encerrar el
área más grande?

### Solución

- Queremos maximizar el área $A$ del rectángulo.

$$A(x,y) = xy $$

Ademas tenemos una restriccion, utilizamos la información dada de que la longitud total de la barda es $2400$ metros

$$2x + y = 2400 $$


```python
L = x*y + ld*(2*x + y - 2400)
pcs= solve(map(L.diff,[x,y,ld]))
L.subs(pcs),(x*y).subs(pcs),pcs
```


```python

```


```python
def fV(X):
    return - X[0]*X[1]

def con(X):
    return  -(2*X[0] + X[1] - 2400)

lb = [0,0]
ub = [5000,5000]

xopt, fopt = pso(fV, lb, ub, f_ieqcons=con)
xopt,fopt
```

    Stopping search: maximum iterations reached --> 100





    (array([  592.93321599,  1214.13356731]), -719900.12069964292)




```python

```

## Ejemplo

Se va un fabricar una lata que ha de contener $1 L$ de aceite. Encuentre
las dimensiones que debe tener la lata de manera que minimicen el costo del metal para fabricarla.

De esta manera, el área superficial es
$$A(r,h) = 2\pi r^2 + 2\pi r h  $$

El volumen está dado como $1 L$, que tomamos como $1000$ $cm^3$

$$\pi r^2h=1000 $$




```python
# Multiplicadores de lagrange
r,h= symbols("r,h",real=True)
L = 2*pi*r**2 + 2*pi*r*h  +ld*(pi*r**2*h -1000) 
pcs= solve(map(L.diff,[r,h,ld]))
pcs
L.subs(pcs[0]),N ( (2*pi*r**2 + 2*pi*r*h).subs(pcs[0]) ),pcs
```


```python
N(pcs[0][h]),N(pcs[0][r])
```


```python

```


```python
def fV(X):
    return (2*np.pi*X[0]**2  + 2*np.pi*X[0]*X[1])

def con(X):
    return  (np.pi*X[0]**2*X[1] - 1000)

lb = [0,0]
ub = [500,500]

xopt, fopt = pso(fV, lb, ub, f_ieqcons=con)
xopt,fopt
```

    Stopping search: maximum iterations reached --> 100





    (array([  5.39618166,  10.93143068]), 553.59111372575342)




```python

```

# SwarmPackagePy

Library of swarm optimization algorithms.

SwarmPackagePy is the package, witch contains the following swarm optimization algorithms:

- Artificial Bee Algorithm
- Bat Algorithm
- Bacterial Foraging Optimization
- Cat Swarm Optimization
- Chicken Swarm Optimization
- Cuckoo Search Optimization
- Firefly algorithm
- Firework Algorithm
- Gravitational Search Algorithm
- Grey Wolf Optimizer
- Harmony Search
- Particle Swarm Optimization
- Social Spider Algorithm
- Whale Swarm Algorithm

Every algorithm has arguments listed below:

- n: number of agents
- function: test function
- lb: lower limits for plot axes
- ub: upper limits for plot axes
- dimension: space dimension
- iteration: number of iterations

Every algorithm has methods listed below:

- get_agents(): returns a history of all agents of the algorithm
- get_Gbest(): returns the best position of algorithm


```python
#!pip install SwarmPackagePy
```


```python
import SwarmPackagePy
```


```python
def fV(X):
    return (2*np.pi*X[0]**2  + 2*np.pi*X[0]*X[1])

def con(X):
    return  (np.pi*X[0]**2*X[1] - 1000)

lb = [0,0]
ub = [500,500]

xopt, fopt = pso(fV, lb, ub, f_ieqcons=con)
xopt,fopt
```

    Stopping search: maximum iterations reached --> 100





    (array([  5.42447867,  10.8176797 ]), 553.58155997221195)




```python
SwarmPackagePy.pso?
```


```python
def fV(X):
    return (2*np.pi*X[0]**2  + 2*np.pi*X[0]*X[1]) + X[2]*(np.pi*X[0]**2*X[1] - 1000) 

lb = [0,0,0]
ub = [500,500,500]
            
methodPSO = SwarmPackagePy.pso(100,fV,lb=lb,ub=ub,dimension=3,iteration=1000)
methodPSO.get_Gbest()
```


```python

```


```python

```




```python
import SwarmPackagePy
from SwarmPackagePy import testFunctions as tf
from SwarmPackagePy import animation, animation3D


alh = SwarmPackagePy.pso(50, tf.easom_function, -10, 10, 2, 20,
                         w=0.5, c1=1, c2=1)
animation(alh.get_agents(), tf.easom_function, -10, 10)
animation3D(alh.get_agents(), tf.easom_function, -10, 10)
```


```python

```

a6f1522726f385c4b156faccc0cee3ed9da31ce1
ipynb
Jupyter Notebook
Modulo3Simat/7_PSO/PSO.ipynb
IntroCursos/MachingLearning
a3d858c8c8fbb8b6d3a1cb445cf5045e9971930c
MIT
Modulo3Simat/7_PSO/PSO.ipynb
IntroCursos/MachingLearning
a3d858c8c8fbb8b6d3a1cb445cf5045e9971930c
MIT
Modulo3Simat/7_PSO/PSO.ipynb
IntroCursos/MachingLearning
a3d858c8c8fbb8b6d3a1cb445cf5045e9971930c
MIT
Qwen/Qwen-72B
1. YES
2. YES