Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.
Awesome Lists | Featured Topics | Projects
https://github.com/ljvmiranda921/pyswarms

A research toolkit for particle swarm optimization in Python
https://github.com/ljvmiranda921/pyswarms
algorithm discrete-optimization global-optimization machine-learning metaheuristics optimization optimization-algorithms optimization-tools particle-swarm-optimization pso swarm-intelligence
Last synced: 25 days ago
JSON representation
A research toolkit for particle swarm optimization in Python
Host: GitHub
URL: https://github.com/ljvmiranda921/pyswarms
Owner: ljvmiranda921
License: mit
Created: 2017-07-12T12:04:45.000Z (over 7 years ago)
Default Branch: master
Last Pushed: 2024-08-06T17:18:34.000Z (3 months ago)
Last Synced: 2024-08-28T09:10:23.633Z (2 months ago)
Topics: algorithm, discrete-optimization, global-optimization, machine-learning, metaheuristics, optimization, optimization-algorithms, optimization-tools, particle-swarm-optimization, pso, swarm-intelligence
Language: Python
Homepage: https://pyswarms.readthedocs.io/en/latest/
Size: 64 MB
Stars: 1,258
Watchers: 39
Forks: 333
Open Issues: 38
Metadata Files:
- Readme: README.md
- Changelog: HISTORY.rst
- Contributing: CONTRIBUTING.rst
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
- Authors: AUTHORS.rst
Awesome Lists containing this project

awesome-python-machine-learning-resources - GitHub - 3% open · ⏱️ 03.07.2022): (Others)
README

        ![PySwarms Logo](https://i.imgur.com/eX8oqPQ.png)

---

[![PyPI version](https://badge.fury.io/py/pyswarms.svg)](https://badge.fury.io/py/pyswarms)

[![Build Status](https://dev.azure.com/ljvmiranda/ljvmiranda/_apis/build/status/ljvmiranda921.pyswarms?branchName=master)](https://dev.azure.com/ljvmiranda/ljvmiranda/_build/latest?definitionId=1&branchName=master)

[![Documentation Status](https://readthedocs.org/projects/pyswarms/badge/?version=latest)](https://pyswarms.readthedocs.io/en/master/?badge=master)

[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg )](https://raw.githubusercontent.com/ljvmiranda921/pyswarms/master/LICENSE)

[![DOI](http://joss.theoj.org/papers/10.21105/joss.00433/status.svg)](https://doi.org/10.21105/joss.00433)

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

[![Gitter Chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/pyswarms/Issues)

> **NOTICE**: I am not actively maintaining this repository anymore. My research interests have changed in the past few years. 

> I highly recommend checking out [scikit-opt](https://github.com/guofei9987/scikit-opt) for metaheuristic methods including PSO. 

PySwarms is an extensible research toolkit for particle swarm optimization

(PSO) in Python.

It is intended for swarm intelligence researchers, practitioners, and

students who prefer a high-level declarative interface for implementing PSO

in their problems. PySwarms enables basic optimization with PSO and

interaction with swarm optimizations. Check out more features below!

* **Free software:** MIT license

* **Documentation:** https://pyswarms.readthedocs.io.

* **Python versions:** 3.5 and above

## Features

* High-level module for Particle Swarm Optimization. For a list of all optimizers, check [this link].

* Built-in objective functions to test optimization algorithms.

* Plotting environment for cost histories and particle movement.

* Hyperparameter search tools to optimize swarm behaviour.

* (For Devs and Researchers): Highly-extensible API for implementing your own techniques.

[this link]: https://pyswarms.readthedocs.io/en/latest/features.html

## Installation

To install PySwarms, run this command in your terminal:

```shell

$ pip install pyswarms

```

This is the preferred method to install PySwarms, as it will always install

the most recent stable release.

In case you want to install the bleeding-edge version, clone this repo:

```shell

$ git clone -b development https://github.com/ljvmiranda921/pyswarms.git

```

and then run

```shell

$ cd pyswarms

$ python setup.py install

```

To install PySwarms on Fedora, use:

```sh

$ dnf install python3-pyswarms

```

## Running in a Vagrant Box

To run PySwarms in a Vagrant Box, install Vagrant by going to 

https://www.vagrantup.com/downloads.html and downloading the proper packaged from the Hashicorp website. 

Afterward, run the following command in the project directory:

```shell

$ vagrant provision

$ vagrant up

$ vagrant ssh

```

Now you're ready to develop your contributions in a premade virtual environment. 

## Basic Usage

PySwarms provides a high-level implementation of various particle swarm

optimization algorithms. Thus, it aims to be user-friendly and customizable.

In addition, supporting modules can be used to help you in your optimization

problem.

### Optimizing a sphere function

You can import PySwarms as any other Python module,

```python

import pyswarms as ps

```

Suppose we want to find the minima of `f(x) = x^2` using global best

PSO, simply import the built-in sphere function,

`pyswarms.utils.functions.sphere()`, and the necessary optimizer:

```python

import pyswarms as ps

from pyswarms.utils.functions import single_obj as fx

# Set-up hyperparameters

options = {'c1': 0.5, 'c2': 0.3, 'w':0.9}

# Call instance of PSO

optimizer = ps.single.GlobalBestPSO(n_particles=10, dimensions=2, options=options)

# Perform optimization

best_cost, best_pos = optimizer.optimize(fx.sphere, iters=100)

```

![Sphere Optimization](https://i.imgur.com/5LtjROf.gif)

This will run the optimizer for `100` iterations, then returns the best cost

and best position found by the swarm. In addition, you can also access

various histories by calling on properties of the class:

```python

# Obtain the cost history

optimizer.cost_history

# Obtain the position history

optimizer.pos_history

# Obtain the velocity history

optimizer.velocity_history

```

At the same time, you can also obtain the mean personal best and mean neighbor

history for local best PSO implementations. Simply call `optimizer.mean_pbest_history`

and `optimizer.mean_neighbor_history` respectively.

### Hyperparameter search tools

PySwarms implements a grid search and random search technique to find the

best parameters for your optimizer. Setting them up is easy. In this example,

let's try using `pyswarms.utils.search.RandomSearch` to find the optimal

parameters for `LocalBestPSO` optimizer.

Here, we input a range, enclosed in tuples, to define the space in which the

parameters will be found. Thus, `(1,5)` pertains to a range from 1 to 5.

```python

import numpy as np

import pyswarms as ps

from pyswarms.utils.search import RandomSearch

from pyswarms.utils.functions import single_obj as fx

# Set-up choices for the parameters

options = {

    'c1': (1,5),

    'c2': (6,10),

    'w': (2,5),

    'k': (11, 15),

    'p': 1

}

# Create a RandomSearch object

# n_selection_iters is the number of iterations to run the searcher

# iters is the number of iterations to run the optimizer

g = RandomSearch(ps.single.LocalBestPSO, n_particles=40,

            dimensions=20, options=options, objective_func=fx.sphere,

            iters=10, n_selection_iters=100)

best_score, best_options = g.search()

```

This then returns the best score found during optimization, and the

hyperparameter options that enable it.

```s

>>> best_score

1.41978545901

>>> best_options['c1']

1.543556887693

>>> best_options['c2']

9.504769054771

```

### Swarm visualization

It is also possible to plot optimizer performance for the sake of formatting.

The plotters module is built on top of `matplotlib`, making it

highly-customizable.

```python

import pyswarms as ps

from pyswarms.utils.functions import single_obj as fx

from pyswarms.utils.plotters import plot_cost_history, plot_contour, plot_surface

import matplotlib.pyplot as plt

# Set-up optimizer

options = {'c1':0.5, 'c2':0.3, 'w':0.9}

optimizer = ps.single.GlobalBestPSO(n_particles=50, dimensions=2, options=options)

optimizer.optimize(fx.sphere, iters=100)

# Plot the cost

plot_cost_history(optimizer.cost_history)

plt.show()

```

![CostHistory](https://i.imgur.com/19Iuz4B.png)

We can also plot the animation...

```python

from pyswarms.utils.plotters.formatters import Mesher, Designer

# Plot the sphere function's mesh for better plots

m = Mesher(func=fx.sphere,

           limits=[(-1,1), (-1,1)])

# Adjust figure limits

d = Designer(limits=[(-1,1), (-1,1), (-0.1,1)],

             label=['x-axis', 'y-axis', 'z-axis'])

```

In 2D,

```python

plot_contour(pos_history=optimizer.pos_history, mesher=m, designer=d, mark=(0,0))

```

![Contour](https://i.imgur.com/H3YofJ6.gif)

Or in 3D!

```python

pos_history_3d = m.compute_history_3d(optimizer.pos_history) # preprocessing

animation3d = plot_surface(pos_history=pos_history_3d,

                           mesher=m, designer=d,

                           mark=(0,0,0))    

```

![Surface](https://i.imgur.com/kRb61Hx.gif)

## Contributing

PySwarms is currently maintained by a small yet dedicated team:

- Lester James V. Miranda ([@ljvmiranda921](https://github.com/ljvmiranda921))

- Siobhán K. Cronin ([@SioKCronin](https://github.com/SioKCronin))

- Aaron Moser ([@whzup](https://github.com/whzup))

- Steven Beardwell ([@stevenbw](https://github.com/stevenbw))

And we would appreciate it if you can lend a hand with the following:

* Find bugs and fix them

* Update documentation in docstrings

* Implement new optimizers to our collection

* Make utility functions more robust.

We would also like to acknowledge [all our

contributors](http://pyswarms.readthedocs.io/en/latest/authors.html), past and

present, for making this project successful!

If you wish to contribute, check out our [contributing guide].

Moreover, you can also see the list of features that need some help in our

[Issues] page.

[contributing guide]: https://pyswarms.readthedocs.io/en/development/contributing.html

[Issues]: https://github.com/ljvmiranda921/pyswarms/issues

**Most importantly**, first-time contributors are welcome to join! I try my

best to help you get started and enable you to make your first Pull Request!

Let's learn from each other!

## Credits

This project was inspired by the [pyswarm] module that performs PSO with

constrained support. The package was created with [Cookiecutter] and the

[`audreyr/cookiecutter-pypackage`] project template.

[pyswarm]: https://github.com/tisimst/pyswarm

[Cookiecutter]: https://github.com/audreyr/cookiecutter

[`audreyr/cookiecutter-pypackage`]: https://github.com/audreyr/cookiecutter-pypackage

## Cite us

Are you using PySwarms in your project or research? Please cite us!

* Miranda L.J., (2018). PySwarms: a research toolkit for Particle Swarm Optimization in Python. *Journal of Open Source Software*, 3(21), 433, [https://doi.org/10.21105/joss.00433](https://doi.org/10.21105/joss.00433)

```bibtex

@article{pyswarmsJOSS2018,

    author  = {Lester James V. Miranda},

    title   = "{P}y{S}warms, a research-toolkit for {P}article {S}warm {O}ptimization in {P}ython",

    journal = {Journal of Open Source Software},

    year    = {2018},

    volume  = {3},

    issue   = {21},

    doi     = {10.21105/joss.00433},

    url     = {https://doi.org/10.21105/joss.00433}

}

```

### Projects citing PySwarms

Not on the list? Ping us in the Issue Tracker!

* Gousios, Georgios. Lecture notes for the TU Delft TI3110TU course Algorithms and Data Structures. Accessed May 22, 2018. http://gousios.org/courses/algo-ds/book/string-distance.html#sop-example-using-pyswarms.

* Nandy, Abhishek, and Manisha Biswas., "Applying Python to Reinforcement Learning." *Reinforcement Learning*. Apress, Berkeley, CA, 2018. 89-128.

* Benedetti, Marcello, et al., "A generative modeling approach for benchmarking and training shallow quantum circuits." *arXiv preprint arXiv:1801.07686* (2018).

* Vrbančič et al., "NiaPy: Python microframework for building nature-inspired algorithms." Journal of Open Source Software, 3(23), 613, https://doi.org/10.21105/joss.00613

* Häse, Florian, et al. "Phoenics: A Bayesian optimizer for chemistry." *ACS Central Science.* 4.9 (2018): 1134-1145. 

* Szynkiewicz, Pawel. "A Comparative Study of PSO and CMA-ES Algorithms on Black-box Optimization Benchmarks." *Journal of Telecommunications and Information Technology* 4 (2018): 5.

* Mistry, Miten, et al. "Mixed-Integer Convex Nonlinear Optimization with Gradient-Boosted Trees Embedded." Imperial College London (2018).

* Vishwakarma, Gaurav. *Machine Learning Model Selection for Predicting Properties of High Refractive Index Polymers* Dissertation. State University of New York at Buffalo, 2018.

* Uluturk Ismail, et al. "Efficient 3D Placement of Access Points in an Aerial Wireless Network." *2019 16th IEEE Anual Consumer Communications and Networking Conference (CCNC)* IEEE (2019): 1-7.

* Downey A., Theisen C., et al. "Cam-based passive variable friction device for structural control." *Engineering Structures* Elsevier (2019): 430-439.

* Thaler S., Paehler L., Adams, N.A. "Sparse identification of truncation errors." *Journal of Computational Physics* Elsevier (2019): vol. 397

* Lin, Y.H., He, D., Wang, Y. Lee, L.J. "Last-mile Delivery: Optimal Locker locatuion under Multinomial Logit Choice Model" https://arxiv.org/abs/2002.10153

* Park J., Kim S., Lee, J. "Supplemental Material for Ultimate Light trapping in free-form plasmonic waveguide" KAIST, University of Cambridge, and Cornell University http://www.jlab.or.kr/documents/publications/2019PRApplied_SI.pdf

* Pasha A., Latha P.H., "Bio-inspired dimensionality reduction for Parkinson's Disease Classification," *Health Information Science and Systems*, Springer (2020).

* Carmichael Z., Syed, H., et al. "Analysis of Wide and Deep Echo State Networks for Multiscale Spatiotemporal Time-Series Forecasting," *Proceedings of the 7th Annual Neuro-inspired Computational Elements* ACM (2019), nb. 7: 1-10 https://doi.org/10.1145/3320288.3320303

* Klonowski, J. "Optimizing Message to Virtual Link Assignment in Avionics Full-Duplex Switched Ethernet Networks" Proquest

* Haidar, A., Jan, ZM. "Evolving One-Dimensional Deep Convolutional Neural Netowrk: A Swarm-based Approach," *IEEE Congress on Evolutionary Computation* (2019) https://doi.org/10.1109/CEC.2019.8790036

* Shang, Z. "Performance Evaluation of the Control Plane in OpenFlow Networks," Freie Universitat Berlin (2020)

* Linker, F. "Industrial Benchmark for Fuzzy Particle Swarm Reinforcement Learning," Liezpic University (2020)

* Vetter, A. Yan, C. et al. "Computational rule-based approach for corner correction of non-Manhattan geometries in mask aligner photolithography," Optics (2019). vol. 27, issue 22: 32523-32535 https://doi.org/10.1364/OE.27.032523

* Wang, Q., Megherbi, N., Breckon T.P., "A Reference Architecture for Plausible Thread Image Projection (TIP) Within 3D X-ray Computed Tomography Volumes" https://arxiv.org/abs/2001.05459

* Menke, Tim, Hase, Florian, et al. "Automated discovery of superconducting circuits and its application to 4-local coupler design," arxiv preprint: https://arxiv.org/abs/1912.03322 

## Others

Like it? Love it? Leave us a star on [Github] to show your appreciation! 

[Github]: https://github.com/ljvmiranda921/pyswarms

## Contributors

Thanks goes to these wonderful people ([emoji key](https://github.com/all-contributors/all-contributors#emoji-key)):

  

    
_Aaron
🚧 💻 📖 ⚠️ 🤔 👀

    
_Carl-K
💻 ⚠️

    
_{Siobhán K Cronin}
💻 🚧 🤔

    
_{Andrew Jarcho}
⚠️ 💻

    
_Mamady
💻

    
_{Jay Speidell}
💻

    
_Eric
🐛 💻

  

  

    
_CPapadim
🐛 💻

    
_JiangHui
💻

    
_{Jericho Arcelao}
💻

    
_{James D. Bohrman}
💻

    
_bradahoward
💻

    
_ThomasCES
💻

    
_{Daniel Correia}
🐛 💻

  

  

    
_fluencer
💡 📖

    
_miguelcocruz
📖 💡

    
_{Steven Beardwell}
💻 🚧 📖 🤔

    
_{Nathaniel Ngo}
📖

    
_{Aneal Sharma}
📖

    
_{Chris McClure}
📖 💡

    
_{Christopher Angell}
📖

  

  

    
_Kutim
🐛

    
_{Jake Souter}
🐛 💻

    
_{Ian Zhang}
📖 💡

    
_Zach
📖

    
_{Michel Lavoie}
🐛

    
_ewekam
📖

    
_{Ivyna Santino}
📖 💡

  

  

    
_{Muhammad Yasirroni}
📖

    
_{Christian Kastner}
📖 📦

    
_{Nishant Rodrigues}
💻

    
_msat59
💻 🐛

    
_Diego
📖

    
_{Shaad Alaka}
📖

    
_{Krzysztof Błażewicz}
🐛

  

  

    
_{Jorge Castillo}
📖

    
_{Philipp Danner}
💻

    
_{Nikhil Sethi}
💻 📖

    
_firefly-cpp
📖

  

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!