an AntennaCAT compatable chicken swarm optimizer

PLACEHOLDER! 6/3/2024

Basic chicken swarm optimizer written in Python. Modified from the[adaptive timestep PSO optimizer](https://github.com/jonathan46000/pso_python) by[jonathan46000](https://github.com/jonathan46000) to keep a consistent format across optimizers in AntennaCAT.

Now featuring AntennaCAT hooks for GUI integration and user input handling.

*[Chicken Swarm Optimization](#chicken-swarm-optimization)

*[Requirements](#requirements)

*[Implementation](#implementation)

*[Constraint Handling](#constraint-handling)

*[Boundary Types](#boundary-types)

*[Multi-Object Optimization](#multi-object-optimization)

*[Objective Function Handling](#objective-function-handling)

*[Internal Objective Function Example](internal-objective-function-example)

*[Examples](#example-implementations)

*[Basic PSO Example](#basic-pso-example)

*[Detailed Messages](#detailed-messages)

*[Realtime Graph](#realtime-graph)

*[References](#references)

*[Publications and Integration](#publications-and-integration)

*[Licensing](#licensing)

The Chicken Swarm Optimization (CSO) algorithm, introduced by Meng et al. in 2014[1], is inspired by the hierarchy and behaviors observed in a swarm of chickens, including roosters, hens, and chicks. Each type of bird has its own unique movement rules and interactions.

In CSO, there is an absence of a direct random velocity component, which is an important distinction from many PSO variations, though it is not the only variation without a velocity vector. Instead, the movements are based on specific behaviors and social interactions within the swarm. Generally, the movement rules for each type of bird in CSO can be described as:

1) Roosters:

Roosters have the best positions (fitness values) in the swarm. They move based on their current position and the random perturbation to avoid getting stuck in local optima.

2) Hens:

Hens follow roosters. They update their positions based on the positions of the roosters they follow and a randomly selected chicken. This reflects the social hierarchy and interaction in the swarm.

3) Chicks:

Chicks follow their mother hens. They update their positions based on their mother's positions with some random factor to simulate the dependent behavior.

This project requires numpy and matplotlib.

Use 'pip install -r requirements.txt' to install the following dependencies:

contourpy==1.2.1

cycler==0.12.1

fonttools==4.51.0

importlib_resources==6.4.0

kiwisolver==1.4.5

matplotlib==3.8.4

numpy==1.26.4

packaging==24.0

pillow==10.3.0

pyparsing==3.1.2

python-dateutil==2.9.0.post0

six==1.16.0

zipp==3.18.1

Users must create their own constraint function for their problems, if there are constraints beyond the problem bounds. This is then passed into the constructor. If the default constraint function is used, it always returns true (which means there are no constraints).

This optimizers has 4 different types of bounds, Random (Particles that leave the area respawn), Reflection (Particles that hit the bounds reflect), Absorb (Particles that hit the bounds lose velocity in that direction), Invisible (Out of bound particles are no longer evaluated).

Some updates have not incorporated appropriate handling for all boundary conditions. This bug is known and is being worked on. The most consistent boundary type at the moment is Random. If constraints are violated, but bounds are not, currently random bound rules are used to deal with this problem.

The no preference method of multi-objective optimization, but a Pareto Front is not calculated. Instead the best choice (smallest norm of output vectors) is listed as the output.

The optimizer minimizes the absolute value of the difference from the target outputs and the evaluated outputs. Future versions may include options for function minimization absent target values.

The current internal optimization function takes 3 inputs, and has 2 outputs. It was created as a simple 3-variable optimization objective function that would be quick to converge.

<palign="center">

</p>

<palign="center">Function Feasable Decision Space and Objective Space with Pareto Front</p>

| Num. Input Variables| Boundary| Constraints|

|----------|----------|----------|

| 3| $0.21\leq x_1\leq 1$ <br> $0\leq x_2\leq 1$ <br> $0.1 \leq x_3\leq 0.5$| $x_3\gt \frac{x_1}{2}$ or $x_3\lt 0.1$|

This function has three files:

1) configs_F.py - contains imports for the objective function and constraints, CONSTANT assignments for functions and labeling, boundary ranges, the number of input variables, the number of output values, and the target values for the output

2) constr_F.py - contains a function with the problem constraints, both for the function and for error handling in the case of under/overflow.

3) func_F.py - contains a function with the objective function.

Other multi-objective functions can be applied to this project by following the same format (and several have been collected into a compatable library, and will be realeased in a seperate repo)

main_test.py provides a sample use case of the optimizer.

main_test_details.py provides an example using a parent class, and the self.suppress_output and detailedWarnings flags to control error messages that are passed back to the parent class to be printed with a timestamp. This implementation sets up the hooks for integration with AntennaCAT in order to provide the user feedback of warnings and errors.

<palign="center">

</p>

main_test_graph.py provides an example using a parent class, and the self.suppress_output and detailedWarnings flags to control error messages that are passed back to the parent class to be printed with a timestamp. Additionally, a realtime graph shows particle locations at every step.

NOTE: if you close the graph as the code is running, the code will continue to run, but the graph will not re-open.

[1] X. B. Meng, Y. Liu, X. Gao, and H. Zhang, "A new bio-inspired algorithm: Chicken swarm optimization," in Proc. Int. Conf. Swarm Intell. Cham, Switzerland, Springer, 2014, pp. 86–94.

This software works as a stand-alone implementation, and as one of the optimizers integrated into AntennaCAT.

Publications featuring the code in this repo will be added as they become public.

The code in this repository has been released under GPL-2.0