pycellga is a Python package that implements cellular genetic algorithms (CGAs) for optimizing complex problems. CGAs combine the principles of cellular automata and traditional genetic algorithms, utilizing a spatially structured population organized in a grid-like topology. This structure allows each individual to interact only with its neighboring individuals, promoting diversity and maintaining a balance between exploration and exploitation during the optimization process. pycellga has machine coded operators with byte implementations. Beside it has Alpha-male CGA, Machine Coded Compact CGA and Improved CGA with Machine Coded Operaors for real-valued optimization problems. The pycellga package is designed to handle a wide range of optimization problems, including binary, real-valued, and permutation-based challenges, making it a versatile tool for diverse applications in evolutionary computation.

• Cellular Genetic Algorithm (cga): Efficient implementation of CGAs with various built-in functions for diverse applications.
• Improved CGA with Machine-Coded Operators: Enhanced performance in real-valued optimization problems through the use of machine-coded byte operators.
• Synchronous Cellular Genetic Algorithm (sync_cga): Simultaneous update of all individuals (cells) in each iteration for synchronized evolution.
• Alpha Male Cellular Genetic Algorithm (alpha_cga): Population divided into social groups, with each group consisting of females selecting the same alpha male.
• Compact Cellular Genetic Algorithm (ccga): Integrates the principles of Cellular Genetic Algorithms with those of Compact Genetic Algorithms for memory efficiency.
• Machine-Coded Compact Cellular Genetic Algorithm (mcccga): Applies machine-coded compact GA to a cellular structure for optimizing real-valued problems.
• Customizable: Offers various customization options to adapt to different optimization problems.

You can install pycellga via pip:

pip install pycellga

For full documentation, visit here or click the badge below:

In this section, we'll explain cga method in the optimizer and provide an example of how to use it. The package includes various ready-to-use crossover and mutation operators, along with real-valued, binary, and permutation functions that you can run directly. Examples for other methods are available in the example folder, while an example for cga is provided below.

cga is a type of genetic algorithm where the population is structured as a grid (or other topologies), and each individual interacts only with its neighbors. This structure helps maintain diversity in the population and can prevent premature convergence. To specialize the CGA for real-valued optimization problems, ICGA (Improved CGA) with machine-coded representation can be used, applying byte operators. The encoding and decoding of numbers follow the IEEE 754 standard for floating-point arithmetic, yielding better results for continuous functions.

Suppose we have a problem that we want to minimize using a Cellular Genetic Algorithm (CGA). The problem is defined as a simple sum of squares function, where the goal is to find a chromosome (vector) that minimizes the function.

The sum of squares function computes the sum of the squares of each element in the chromosome. This function reaches its global minimum when all elements of the chromosome are equal to 0. The corresponding function value at this point is 0.

Here’s how we can define this problem in Python using the ExampleProblem class:

from mpmath import power as pw
import pycellga 

class ExampleProblem:
    
    def __init__(self):
        pass
    
    def f(self, x):
        
        return sum(pw(xi, 2) for xi in x)

Usage:

result = pycellga.optimizer.cga(
    n_cols=5,
    n_rows=5,
    n_gen=100,
    ch_size=5,
    gen_type=pycellga.optimizer.GeneType.REAL,
    p_crossover=0.9,
    p_mutation=0.2,
    problem=ExampleProblem(),  # Replace with a real problem instance as needed
    selection=pycellga.optimizer.TournamentSelection,
    recombination=pycellga.optimizer.ByteOnePointCrossover,
    mutation=pycellga.optimizer.ByteMutationRandom,
    mins=[-32.768] * 5,  # Minimum values for each gene
    maxs=[32.768] * 5,    # Maximum values for each gene
    seed_par=100  # Ensures the random number generation is repeatable
)

# Print the best solution details
print("Best solution chromosome:", result.chromosome)
print("Best fitness value:", result.fitness_value)
print("Generation found:", result.generation_found)

# Expected Output:
# Best solution chromosome: [0.0, 0.0, 0.0, 0.0, 0.0]
# Best fitness value: 0.0
# Generation found: <generation_number>

We have provided a basic example above. If you're interested in exploring more examples, you have two options:

• Click here to see the other examples available directly in the repository.
• Please click here to see the documentation for more detailed examples and explanations.

Contributions are welcome! Please read the contributing guidelines first.

This project is licensed under the MIT License - see the LICENSE file for details.

Developed by Sevgi Akten Karakaya and Mehmet Hakan Satman. Inspired by traditional genetic algorithms and cellular automata principles with machine coded operators. For more information, please visit the project repository.

If you use pycellga in your research, please cite it as follows:

APA Format

Karakaya, S. A., & Satman, M. H. (2024). An Improved Cellular Genetic Algorithm with Machine-Coded Operators for Real-Valued Optimisation Problems. Journal of Engineering Research and Applied Science, 13(1), 2500-2514.

BibTeX Format

For LaTeX users, please use the following BibTeX entry to cite pycellga:

@article{karakaya2024improved,
  title={An Improved Cellular Genetic Algorithm with Machine-Coded Operators for Real-Valued Optimisation Problems},
  author={Karakaya, Sevgi Akten and Satman, Mehmet Hakan},
  journal={Journal of Engineering Research and Applied Science},
  volume={13},
  number={1},
  pages={2500--2514},
  year={2024}
}