PenguinSwarmAlgorithm

A Swarm Algorithm Modeled After Penguin Behavior

# Penguin Swarm Algorithm

A swarm-based optimization algorithm inspired by the collective behavior of penguins.

## Table of Contents

- [Introduction](#introduction)
- [Installation](#installation)
- [Usage](#usage)
- [Examples](#examples)
- [Contribution](#contribution)
- [License](#license)

## Introduction

The Penguin Swarm Algorithm (PSA) is a swarm-based optimization algorithm inspired by the collective behavior of penguins. Penguins are social animals that live in large colonies and cooperate to survive in harsh environments. They have several behaviors that could be useful for optimization, such as:

- Huddling: Penguins form tight groups to conserve heat and protect themselves from predators. This could be analogous to clustering or local search in optimization.
- Foraging: Penguins search for food in the ocean using different strategies, such as diving deep, following the leader, or exploring new areas. This could be analogous to global search or exploration in optimization.
- Breeding: Penguins mate for life and raise their chicks together. They also exchange pebbles as a sign of affection. This could be analogous to crossover or mutation in optimization.

The PSA uses these behaviors to find the optimal solution of a given problem. The algorithm starts with a population of penguin agents, each with a position and a fitness value. The agents then perform the following steps:

- Huddling: The agents form groups based on their fitness values and proximity. The groups then move towards the best agent in each group, improving their fitness values.
- Foraging: The agents randomly choose one of the foraging strategies and move to a new position. The diving strategy moves the agent to a deeper position in the search space, the following strategy moves the agent towards the best agent in the population, and the exploring strategy moves the agent to a random position in the search space.
- Breeding: The agents randomly choose a mate from their group and exchange their positions or pebbles. The pebbles represent some features or parameters of the problem. The exchange creates new offspring agents with better fitness values.
- Updating trail: The agents update their trail based on the quality of the solution and the pheromone level. The pheromone level is inversely proportional to the fitness value. Agents with higher fitness leave less pheromone on their trail, making them less attractive to other agents. This prevents premature convergence and encourages exploration.

The algorithm repeats these steps until a termination criterion is met, such as reaching a maximum number of iterations or finding an acceptable solution.

## Installation

To use the PSA, you need to have Python 3 installed on your system. You can download Python 3 from [here](^8^).

You also need to install some Python modules, such as numpy and matplotlib. You can install them using pip:

```bash
pip install numpy matplotlib

Then you can clone this repository or download it as a zip file:

git clone https://github.com/YOUR_USERNAME/Penguin-Swarm-Algorithm.git

Usage

To use the PSA, you need to import the PenguinAgent and PenguinSwarmAlgorithm classes from the psa.py file:

from psa import PenguinAgent, PenguinSwarmAlgorithm

Then you need to define your own fitness function that evaluates the quality of a position. For example, a simple sphere function:

def evaluate_fitness(position):
    # A simple sphere function
    fitness = -sum(x ** 2 for x in position)
    return fitness

Then you need to create a population of penguin agents with random positions and fitness values:

agents = []
for i in range(100):
    agents.append(PenguinAgent([random.random() for i in range(2)], [], evaluate_fitness([random.random() for i in range(2)])))

Then you need to create a penguin swarm algorithm with the agents and the number of iterations:

algorithm = PenguinSwarmAlgorithm(agents, 1000)

Then you need to run the algorithm and get the best solution:

algorithm.run()
best_trail = algorithm.get_best_solution()

You can also plot the best trail using matplotlib:

import matplotlib.pyplot as plt

x = [position[0] for position in best_trail]
y = [position[1] for position in best_trail]

plt.plot(x, y, 'b-o')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Best trail of the Penguin Swarm Algorithm')
plt.show()

Examples

Here are some examples of using the PSA to solve some benchmark functions:

Rosenbrock function
Rastrigin function
Ackley function

You can find the code and the results in the examples folder.

Contribution

If you want to contribute to this project, you can fork this repository and make a pull request with your changes. You can also report any issues or suggestions here.

Please follow these guidelines for your contributions:

Use descriptive commit messages and comments.
Follow the PEP 8 style guide for Python code.
Write clear and concise docstrings for your functions and classes.
Add tests and examples for your code.
Update the README file if necessary.

License

This project is licensed under the MIT License. See the LICENSE file for more details.

richardaragon / penguinswarmalgorithm Goto Github PK