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

*[Requirements](#requirements)

*[Implementation](#implementation)

*[Initialization](#initialization)

*[State Machine-based Structure](#state-machine-based-structure)

*[Constraint Handling](#constraint-handling)

*[Boundary Types](#boundary-types)

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

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

*[Creating a Custom Objective Function](#creating-a-custom-objective-function)

*[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 andIntegration](#publications-and-integration)

*[RelatedPublications andRepositories](#related-publications-and-repositories)

*[Licensing](#licensing)

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.

This project requires numpy, pandas, and matplotlib for the full demos. To run the optimizer without visualization, only numpy and pandas are requirements

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

matplotlib==3.8.4

numpy==1.26.4

packaging==24.0

pandas==2.2.3

pillow==10.3.0

pyparsing==3.1.2

python-dateutil==2.9.0.post0

pytz==2025.1

six==1.16.0

tzdata==2025.1

zipp==3.18.1

Optionally, requirements can be installed manually with:

pip install matplotlib, numpy, pandas

This is an example for if you've had a difficult time with the requirements.txt file. Sometimes libraries are packaged together.

LB= func_configs.LB# Lower boundaries, [[0.21, 0, 0.1]]

UB= func_configs.UB# Upper boundaries, [[1, 1, 0.5]]

IN_VARS= func_configs.IN_VARS# Number of input variables (x-values)

OUT_VARS= func_configs.OUT_VARS# Number of output variables (y-values)

TARGETS= func_configs.TARGETS# Target values for output

func_F= func_configs.OBJECTIVE_FUNC# objective function

constr_F= func_configs.CONSTR_FUNC# constraint function

G=70# Reorganize groups every G steps

best_eval=1

parent=None# for the PSO_TEST ONLY

suppress_output=True# Suppress the console output of particle swarm

allow_update=True# Allow objective call to update state

opt_params= {'BOUNDARY': [BOUNDARY],# int boundary 1 = random, 2 = reflecting

'RN': [RN],# Total number of roosters

'HN': [HN],# Total number of hens

'MN': [MN],# Number of mother hens in total hens

'CN': [CN],# Total number of chicks

'G': [G]}# Reorganize groups every G steps

opt_df= pd.DataFrame(opt_params)

mySwarm= swarm(LB,UB,TARGETS,TOL,MAXIT,

func_F, constr_F,

opt_df,

parent=parent)

This optimizer uses a state machine structure to control the movement of the particles, call to the objective function, and the evaluation of current positions. The state machine implementation preserves the initial algorithm while making it possible to integrate other programs, classes, or functions as the objective function.

A controller with a`while loop` to check the completion status of the optimizer drives the process. Completion status is determined by at least 1) a set MAX number of iterations, and 2) the convergence to a given target using the L2 norm. Iterations are counted by calls to the objective function.

Within this`while loop` are three function calls to control the optimizer class:

***complete**: the`complete function` checks the status of the optimizer and if it has met the convergence or stop conditions.

***step**: the`step function` takes a boolean variable (suppress_output) as an input to control detailed printout on current particle (or agent) status. This function moves the optimizer one step forward.

***call_objective**: the`call_objective function` takes a boolean variable (allow_update) to control if the objective function is able to be called. In most implementations, this value will always be true. However, there may be cases where the controller or a program running the state machine needs to assert control over this function without stopping the loop.

Additionally,**get_convergence_data** can be used to preview the current status of the optimizer, including the current best evaluation and the iterations.

The code below is an example of this process:

whilenot myOptimizer.complete():

myOptimizer.step(suppress_output)

myOptimizer.call_objective(allow_update)

iter,eval= myOptimizer.get_convergence_data()

if (eval< best_eval)and (eval!=0):

best_eval=eval

if suppress_output:

ifiter%100==0:#print out every 100th iteration update

print("Iteration")

print(iter)

print("Best Eval")

print(best_eval)

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).

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 optimizer minimizes the absolute value of the difference of the target outputs and the evaluated outputs. Future versions may include options for function minimization when target values are absent.

Custom objective functions can be used by creating a directory with the following files:

* configs_F.py

* constr_F.py

* func_F.py

`configs_F.py` contains lower bounds, upper bounds, the number of input variables, the number of output variables, the target values, and a global minimum if known. This file is used primarily for unit testing and evaluation of accuracy. If these values are not known, or are dynamic, then they can be included experimentally in the controller that runs the optimizer's state machine.

`constr_F.py` contains a function called`constr_F` that takes in an array,`X`, of particle positions to determine if the particle or agent is in a valid or invalid location.

`func_F.py` contains the objective function,`func_F`, which takes two inputs. The first input,`X`, is the array of particle or agent positions. The second input,`NO_OF_OUTS`, is the integer number of output variables, which is used to set the array size. In included objective functions, the default value is hardcoded to work with the specific objective function.

Below are examples of the format for these files.

`configs_F.py`:

OBJECTIVE_FUNC= func_F

CONSTR_FUNC= constr_F

LB= [[0]]# Lower boundaries

UB= [[1]]# Upper boundaries

TARGETS= [0]# Target values for output

GLOBAL_MIN= []# Global minima sample, if they exist.

`constr_F.py`, with no constraints:

defconstr_F(x):

F=True

return F

`constr_F.py`, with constraints:

defconstr_F(X):

F=True

if (X[2]> X[0]/2)or (X[2]<0.1):

F=False

return F

`func_F.py`:

import numpyas np

import time

deffunc_F(X,NO_OF_OUTS=1):

F= np.zeros((NO_OF_OUTS))

noErrors=True

try:

x= X[0]

F= np.sin(5* x**3)+ np.cos(5* x)* (1- np.tanh(x**2))

exceptExceptionas e:

print(e)

noErrors=False

return [F], noErrors

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

<palign="center">

</p>

<palign="center">Plotted Himmelblau Function with 3D Plot on the Left, and a 2D Contour on the Right</p>

<palign="center">Plotted Himmelblau’s Function with 3D Plot on the Left, and a 2D Contour on the Right</p>

| f(-3.779310, -3.283186) = 0| $-5 \leq x,y \leq 5$||

| f(3.584428, -1.848126) = 0| $-5 \leq x,y \leq 5$||

<palign="center">

</p>

<palign="center">Plotted Multi-Objective Function Feasible Decision Space and Objective Space with Pareto Front</p>

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

| 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$|

<palign="center">

</p>

<palign="center">Plotted Single Input, Single-objective Function Feasible Decision Space and Objective Space with Pareto Front</p>

Global minima at $(0.974857, -0.954872)$

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

`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_outputand 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.

`main_test_details.py` provides an example using a parent class, and the self.suppress_outputflag 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_outputand 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.

`main_test_graph.py` provides an example using a parent class, and the self.suppress_outputflag 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.