#
Distributed and Asynchronous Population-Based Optimization Applied to the Optimal Design of Fuzzy Controllers^{ †}

^{1}

^{2}

^{*}

^{†}

## Abstract

**:**

## 1. Introduction

## 2. State of the Art

## 3. Materials and Methods

#### 3.1. Populations and Workers

#### 3.2. Message Queues

`input queue.`This queue receives populations that need to be sent to workers. When the algorithm starts, populations in their initial state are sent to this queue. Moreover, the mixing process sends combined populations to continue with the multi-population cycle. Workers constantly pull populations from this queue.`output queue.`Workers push the evolved populations to this queue. At the same time, the mixing process pulls populations from this queue to combine two or more populations.

`input queue`; this is a blocking operation. After a population is pulled from the queue and has valid data, the metaheuristic algorithm specified is executed, starting from the current state of the population. After the execution is finished, the resulting population is pushed to the

`output queue`, and the loop continues, pulling another population.

#### 3.3. Mixer

**Setup**This is a one-time running task consisting of reading the algorithm’s configuration, creating the initial population structures, and pushing the messages to the`input queue`.**Finishing the algorithm**The mixer also keeps track of the number of populations that have been pulled from the`output queue`. It stops the algorithm if one of these two conditions is true: (1) the number of cycles has been reached, or (2) the error of the best controller found so far meets the desired criteria.

`input queue`(2). Worker containers (3) pull the population messages as described in Section 3.1, execute a metaheuristic, and pushes the resulting population state to the

`output queue`(4). The mixing process pulls populations from the

`output queue`and follows the process described in Section 3.3. It stops the execution if conditions are met (5) or proceeds to swap the k-top individuals in the buffer with the worst k in the current population (6). Finally, it pushes the resulting population to the

`input queue`to complete the loop.

#### 3.4. Controller Optimization and Simulations

## 4. Experimental Setup

#### 4.1. Rear-Wheel Feedback and Kinematic Model

#### 4.2. Parametrizable Membership Functions

#### 4.3. Multi-Population Algorithm Setup

## 5. Results

#### 5.1. RMSE

**0.00536160**, the second-best result is the distributed heterogeneous version of the PSO-GA with a median of 0.00610783; this result is very close to the multi-algorithm version PSO with an RMSE of 0.00628949. After performing a statistical z-test between the distributed and sequential versions of the same algorithms, we did not find enough evidence to reject ${H}_{0}:{\mu}_{seq}\le {\mu}_{dist}$ with $\alpha =0.05$. These results indicate that the results from the distributed and sequential versions are about the same, and the random parametrization of the multi-population version could be used, even having marginal benefits over the homogeneous version, without the need to find appropriate values for the parameters.

#### 5.2. Execution Time Speedup

#### 5.3. Discussion

## 6. Conclusions

## Author Contributions

## Funding

## Institutional Review Board Statement

## Informed Consent Statement

## Data Availability Statement

## Conflicts of Interest

## References

- Kalman, R.E. A New Approach to Linear Filtering and Prediction Problems. J. Basic Eng.
**1960**, 82, 35–45. [Google Scholar] [CrossRef] - Fu, K. Learning control systems and intelligent control systems: An intersection of artifical intelligence and automatic control. IEEE Trans. Autom. Control
**1971**, 16, 70–72. [Google Scholar] - Mamdani, E.H. Application of fuzzy algorithms for control of simple dynamic plant. Proc. Inst. Electr. Eng.
**1974**, 121, 1585–1588. [Google Scholar] [CrossRef] - Driankov, D.; Saffiotti, A. Fuzzy Logic Techniques for Autonomous Vehicle Navigation; Physica: Heidelberg, Germany, 2013; Volume 61. [Google Scholar]
- Sutton, R.S.; Barto, A.G. Reinforcement Learning: An Introduction; MIT Press: Cambridge, MA, USA, 2018. [Google Scholar]
- Ahn, H.S.; Chen, Y.; Moore, K.L. Iterative learning control: Brief survey and categorization. IEEE Trans. Syst. Man Cybern. Part C (Appl. Rev.)
**2007**, 37, 1099–1121. [Google Scholar] [CrossRef] - Bisoffi, A.; De Persis, C.; Tesi, P. Data-driven control via Petersen’s lemma. Automatica
**2022**, 145, 110537. [Google Scholar] - Brunton, S.L.; Kutz, J.N. Data-Driven Science and Engineering: Machine Learning, Dynamical Systems, and Control; Cambridge University Press: Cambridge, UK, 2022. [Google Scholar]
- Salem, M.; Mora, A.M.; Guervós, J.J.M.; García-Sánchez, P. Evolving a TORCS Modular Fuzzy Driver Using Genetic Algorithms. In Proceedings of the Applications of Evolutionary Computation—21st International Conference, EvoApplications 2018, Parma, Italy, 4–6 April 2018; Sim, K., Kaufmann, P., Eds.; Lecture Notes in Computer Science. Springer: Berlin/Heidelberg, Germany, 2018; Volume 10784, pp. 342–357. [Google Scholar] [CrossRef]
- Holland, J.H. Outline for a logical theory of adaptive systems. J. ACM (JACM)
**1962**, 9, 297–314. [Google Scholar] [CrossRef] - Back, T. Evolutionary Algorithms in Theory and Practice: Evolution Strategies, Evolutionary Programming, Genetic Algorithms; Oxford University Press: Oxford, UK, 1996. [Google Scholar]
- Kennedy, J. Swarm intelligence. In Handbook of Nature-Inspired and Innovative Computing; Springer: Berlin/Heidelberg, Germany, 2006; pp. 187–219. [Google Scholar]
- Castillo, O.; Melin, P. A review on the design and optimization of interval type-2 fuzzy controllers. Appl. Soft Comput.
**2012**, 12, 1267–1278. [Google Scholar] [CrossRef] - Mancilla, A.; Castillo, O.; Valdez, M.G. Optimization of Fuzzy Logic Controllers with Distributed Bio-Inspired Algorithms. In Recent Advances of Hybrid Intelligent Systems Based on Soft Computing; Springer International Publishing: Cham, Switzerland, 2021; pp. 1–11. [Google Scholar] [CrossRef]
- Mancilla, A.; Castillo, O.; Valdez, M.G. Evolutionary Approach to the Optimal Design of Fuzzy Controllers for Trajectory Tracking. In Proceedings of the Intelligent and Fuzzy Techniques for Emerging Conditions and Digital Transformation, Istanbul, Turkey, 24–26 August 2021; Kahraman, C., Cebi, S., Cevik Onar, S., Oztaysi, B., Tolga, A.C., Sari, I.U., Eds.; Springer International Publishing: Cham, Switzerland, 2022; pp. 461–468. [Google Scholar]
- Mancilla, A.; García-Valdez, M.; Castillo, O.; Merelo-Guervós, J.J. Optimal Fuzzy Controller Design for Autonomous Robot Path Tracking Using Population-Based Metaheuristics. Symmetry
**2022**, 14, 202. [Google Scholar] [CrossRef] - Cortes-Rios, J.C.; Gómez-Ramírez, E.; Ortiz-de-la Vega, H.A.; Castillo, O.; Melin, P. Optimal design of interval type 2 fuzzy controllers based on a simple tuning algorithm. Appl. Soft Comput.
**2014**, 23, 270–285. [Google Scholar] [CrossRef] - Oh, S.K.; Jang, H.J.; Pedrycz, W. The design of a fuzzy cascade controller for ball and beam system: A study in optimization with the use of parallel genetic algorithms. Eng. Appl. Artif. Intell.
**2009**, 22, 261–271. [Google Scholar] - Ciurea, S. Determining the parameters of a Sugeno fuzzy controller using a parallel genetic algorithm. In Proceedings of the 2013 19th IEEE International Conference on Control Systems and Computer Science, Washington, DC, USA, 29–31 May 2013; pp. 36–43. [Google Scholar]
- Malawski, M.; Gajek, A.; Zima, A.; Balis, B.; Figiela, K. Serverless execution of scientific workflows: Experiments with HyperFlow, AWS Lambda and Google Cloud Functions. Future Gener. Comput. Syst.
**2020**, 110, 502–514. [Google Scholar] [CrossRef] - Gilbert, J. Cloud Native Development Patterns and Best Practices: Practical Architectural Patterns for Building Modern, Distributed Cloud-Native Systems; Packt Publishing Ltd.: Birmingham, UK, 2018. [Google Scholar]
- Kratzke, N.; Quint, P.C. Understanding cloud-native applications after 10 years of cloud computing-a systematic mapping study. J. Syst. Softw.
**2017**, 126, 1–16. [Google Scholar] [CrossRef] - Scholl, B.; Swanson, T.; Jausovec, P. Cloud Native: Using Containers, Functions, and Data to Build Next-Generation Applications; O’Reilly Media, Inc.: Sebastopol, CA, USA, 2019. [Google Scholar]
- Starkweather, T.; Whitley, D.; Mathias, K. Optimization using distributed genetic algorithms. In Proceedings of the International Conference on Parallel Problem Solving from Nature, Jerusalem, Israel, 9–14 October 1990; Springer: Berlin/Heidelberg, Germany, 1990; pp. 176–185. [Google Scholar]
- Ma, H.; Shen, S.; Yu, M.; Yang, Z.; Fei, M.; Zhou, H. Multi-population techniques in nature inspired optimization algorithms: A comprehensive survey. Swarm Evol. Comput.
**2019**, 44, 365–387. [Google Scholar] - Alba, E.; Tomassini, M. Parallelism and evolutionary algorithms. IEEE Trans. Evol. Comput.
**2002**, 6, 443–462. [Google Scholar] - Li, Y.; Zeng, X. Multi-population co-genetic algorithm with double chain-like agents structure for parallel global numerical optimization. Appl. Intell.
**2010**, 32, 292–310. [Google Scholar] - García-Valdez, M.; Merelo, J.J. Event-Driven Multi-algorithm Optimization: Mixing Swarm and Evolutionary Strategies. In Proceedings of the International Conference on the Applications of Evolutionary Computation (Part of EvoStar), Virtual Event, 7–9 April 2021; Springer: Berlin/Heidelberg, Germany, 2021; pp. 747–762. [Google Scholar]
- Mancilla, A.; Castillo, O.; Valdez, M.G. Mixing Population-Based Metaheuristics: An Approach Based on a Distributed-Queue for the Optimal Design of Fuzzy Controllers. In Proceedings of the International Conference on Intelligent and Fuzzy Systems; Springer: Berlin/Heidelberg, Germany, 2022; pp. 839–846. [Google Scholar]
- Talukdar, S.; Baerentzen, L.; Gove, A.; De Souza, P. Asynchronous teams: Cooperation schemes for autonomous agents. J. Heuristics
**1998**, 4, 295–321. [Google Scholar] - Singh, S.; Kaur, J.; Sinha, R.S. A comprehensive survey on various evolutionary algorithms on GPU. In Proceedings of the International Conference on Communication, Computing and Systems, Washington, DC, USA, 18–21 December 2014; pp. 83–88. [Google Scholar]
- Jankee, C.; Verel, S.; Derbel, B.; Fonlupt, C. A fitness cloud model for adaptive metaheuristic selection methods. In Proceedings of the International Conference on Parallel Problem Solving from Nature, Edinburgh, UK, 17–21 September 2016; Springer: Berlin/Heidelberg, Germany, 2016; pp. 80–90. [Google Scholar]
- Veeramachaneni, K.; Arnaldo, I.; Derby, O.; O’Reilly, U.M. FlexGP. J. Grid Comput.
**2015**, 13, 391–407. [Google Scholar] - Dziurzanski, P.; Zhao, S.; Przewozniczek, M.; Komarnicki, M.; Indrusiak, L.S. Scalable distributed evolutionary algorithm orchestration using Docker containers. J. Comput. Sci.
**2020**, 40, 101069. [Google Scholar] - Salza, P.; Ferrucci, F. Speed up genetic algorithms in the cloud using software containers. Future Gener. Comput. Syst.
**2019**, 92, 276–289. [Google Scholar] [CrossRef] - Merelo Guervós, J.J.; García-Valdez, J.M. Introducing an event-based architecture for concurrent and distributed evolutionary algorithms. In Proceedings of the International Conference on Parallel Problem Solving from Nature, Coimbra, Portugal, 8–12 September 2018; Springer: Berlin/Heidelberg, Germany, 2018; pp. 399–410. [Google Scholar]
- Valdez, M.G.; Merelo-Guervós, J.J. A container-based cloud-native architecture for the reproducible execution of multi-population optimization algorithms. Future Gener. Comput. Syst.
**2021**, 116, 234–252. [Google Scholar] - Ivanovic, M.; Simic, V. Efficient evolutionary optimization using predictive auto-scaling in containerized environment. Appl. Soft Comput.
**2022**, 129, 109610. [Google Scholar] - Arellano-Verdejo, J.; Godoy-Calderon, S.; Alonso-Pecina, F.; Guzmán-Arenas, A.; Cruz-Chavez, M.A. A New Efficient Entropy Population-Merging Parallel Model for Evolutionary Algorithms. Int. J. Comput. Intell. Syst.
**2017**, 10, 1186–1197. [Google Scholar] - Roy, G.; Lee, H.; Welch, J.L.; Zhao, Y.; Pandey, V.; Thurston, D. A distributed pool architecture for genetic algorithms. In Proceedings of the 2009 IEEE Congress on Evolutionary Computation, Trondheim, Norway, 18–21 May 2009; pp. 1177–1184. [Google Scholar]
- Merelo, J.J.; Fernandes, C.M.; Mora, A.M.; Esparcia, A.I. SofEA: A pool-based framework for evolutionary algorithms using couchdb. In Proceedings of the 14th Annual Conference Companion on Genetic and Evolutionary Computation, Lille, France, 10–14 July 2012; pp. 109–116. [Google Scholar]
- García-Valdez, M.; Trujillo, L.; Fernández de Vega, F.; Merelo Guervós, J.J.; Olague, G. EvoSpace: A distributed evolutionary platform based on the tuple space model. In Proceedings of the European Conference on the Applications of Evolutionary Computation, Vienna, Austria, 3–5 April 2013; Springer: Berlin/Heidelberg, Germany, 2013; pp. 499–508. [Google Scholar]
- García-Valdez, M.; Trujillo, L.; Merelo, J.J.; Fernandez de Vega, F.; Olague, G. The EvoSpace model for pool-based evolutionary algorithms. J. Grid Comput.
**2015**, 13, 329–349. [Google Scholar] - García-Valdez, M.; Merelo, J. evospace-js: Asynchronous pool-based execution of heterogeneous metaheuristics. In Proceedings of the Genetic and Evolutionary Computation Conference Companion, Berlin, Germany, 15–19 July 2017; pp. 1202–1208. [Google Scholar]
- Li, C.; Nguyen, T.T.; Yang, M.; Yang, S.; Zeng, S. Multi-population methods in unconstrained continuous dynamic environments: The challenges. Inf. Sci.
**2015**, 296, 95–118. [Google Scholar] [CrossRef] - Pamucar, D.; Ćirović, G. Vehicle route selection with an adaptive neuro fuzzy inference system in uncertainty conditions. Decis. Mak. Appl. Manag. Eng.
**2018**, 1, 13–37. [Google Scholar] [CrossRef] - De Luca, A.; Oriolo, G.; Samson, C. Feedback control of a nonholonomic car-like robot. In Robot Motion Planning and Control; Springer: Berlin/Heidelberg, Germany, 1998; pp. 171–253. [Google Scholar]
- Paden, B.; Čáp, M.; Yong, S.Z.; Yershov, D.; Frazzoli, E. A survey of motion planning and control techniques for self-driving urban vehicles. IEEE Trans. Intell. Veh.
**2016**, 1, 33–55. [Google Scholar] - Yang, X.S.; Cui, Z.; Xiao, R.; Gandomi, A.H.; Karamanoglu, M. Swarm Intelligence and Bio-Inspired Computation: Theory and Applications; Newnes: Newton, MA, USA, 2013. [Google Scholar]
- Gong, Y.; Fukunaga, A. Distributed island-model genetic algorithms using heterogeneous parameter settings. In Proceedings of the 2011 IEEE Congress of Evolutionary Computation (CEC), New Orleans, LA, USA, 5–8 June 2011; pp. 820–827. [Google Scholar]
- Touati, S.A.A.; Worms, J.; Briais, S. The Speedup-Test: A statistical methodology for programme speedup analysis and computation. Concurr. Comput. Pract. Exp.
**2013**, 25, 1410–1426. [Google Scholar] [CrossRef][Green Version] - Kiraz, M.U.; Yilmaz, A. Comparison of ML algorithms to detect vulnerabilities of RPL-based IoT devices in intelligent and fuzzy systems. In Proceedings of the International Conference on Intelligent and Fuzzy Systems, Turkey, Bornova, 19–21 July 2022; Springer: Berlin/Heidelberg, Germany, 2022; pp. 254–262. [Google Scholar]

**Figure 1.**The multi-population cycle consists of a set of populations P, each in a current state j, and a set (W) of w workers. Each population ($populatio{n}_{i}$) is received by one of the workers. Then, after executing a metaheuristic, it sends the evolved population (${X}_{j+1}$) to the mixer. In turn, the mixer swaps some candidate solutions between two populations, changing their state again and sending the resulting populations again to be processed by workers, closing the cycle.

**Figure 2.**The diagram shows the worker’s infinite loop operation and communication through the input and

`output queue`s. Inside each worker, there is a main method executing an infinite loop, constantly pulling messages from the

`input queue`and blocking until a message is received. The message includes the population and the specified metaheuristic to execute. Workers are capable of executing all metaheuristics available. Once the message is received, the main method calls the worker object to execute the algorithm. After the algorithm runs, the worker pushes a message to the

`output queue`; the message includes the resulting population.

**Figure 3.**The proposed architecture diagram shows each process in a swimlane, along with the message dataflow, message queues, and high-level responsibilities of each component. Numbers in yellow boxes indicate the order in which actions happen, and the details of each step is explained in the main text.

**Figure 4.**The diagram shows the data flow of the higher-level components required to optimize the parameters of a fuzzy controller. The input is the collection of parameters representing a candidate solution, and the output is the fitness or quality measure of the candidate solution. It shows the FIS controller creation component, which generates a controller instance from the input parameters. The controller instance is then put to the test on a control problem. A control problem includes a simulation model that includes the kinematic model and the code needed to execute a simulation. The controller can be tested on several problem instances. For example, a path-tracking controller can be tested on different paths. We measure the error as the robot follows the path, and the final output is the average of these errors.

**Figure 5.**Illustration of the feedback variables used for rear-wheel-based control. The transverse error e is the distance from the rear wheel to the nearest point in the path $s\left(t\right)$. When the error is positive, the wheel is to the right of the path. The wheel is to the left if the error has a negative sign. ${\theta}_{e}$ is the difference between the tangent at the nearest point in the path and the heading $\theta $. The unit tangent to the path at $s\left(t\right)$ is shown in blue $\widehat{t}$. The controller outputs the heading rate $\omega $, the variable we need to establish the steering angle $\delta $ (see Equation (2)).

**Figure 6.**Boxplot of the execution time in seconds for 30 runs of the distributed versions of the multi-population-based algorithms: GA, PSO, and the combined version PSO-GA. The homogeneous versions are on the left side (with black outlines and the _HO suffix) and the heterogeneous versions are on the right (with orange outlines and the suffix _HE).

Method | Infrastructure | Orchestration | Application | Multi–Algorithm | Parallelization | Migration |
---|---|---|---|---|---|---|

FlexGP [33] | AWS EC2 VMs | FlexGP | Regression | Multi GP Solvers | Multiple learners | Ensemble |

distributed | with their own | Global in each | learning | |||

launch protocol | parameters | learner | ||||

EvoSpace [43] | Heroku, | Python Script | P-Peals | Multiple GA | Pool-Based | Not needed |

PiCloud | Discrete Opt. | workers | ||||

evospace-js [44] | Containers, | Python Script | Continuous | Multiple GA | Pool-Based | Not needed |

node.js | using Docker | benchmark | workers | |||

API | functions | |||||

KafkEO [36] | Serverless | OpenWhisk, | Continuous | Multiple GA | Multi-Population | Partition & |

functions | IBM BlueMix | benchmark | Islands | Kafka Queue | Crossover | |

functions | ||||||

Salza & | Containers, | Fleet, | Experimental | Single GA | Global, | Not needed |

Ferrucci [35] | Core OS, | Continuous | Primary/Sub | |||

RabbitMQ | Integration | |||||

Dziurzanski | Containers | Kubernetes, | Multi | Multiple GA | Multi-Population, | Island |

et al. [34] | AWS EKS | Custom | objective | Islands | Message Queue | Merging |

auto-scaler | optimization | Elastic Workers | ||||

EvoSwarm [37] | Containers | docker-compose | Continuous | Multi-Algorithm | Multi-Population, | Partition & |

benchmark | GA-PSO | Message Queue | Crossover | |||

functions | Islands | |||||

Ivanovic & | Containers | Custom PETA | Real-world | Single GA | Global | Not needed |

Simic [38] | Auto-scaler, | applications | Primary/Sub, | |||

Kubernetes | Elastic Workers | |||||

Current Work | Containers | docker-compose | Fuzzy | Multi-Algorithm | Multi-Population, | Buffer-based, |

control | GA-PSO | Message Queue | Top-N | |||

optimization | Islands |

**Table 2.**Ten parameter configuration for the fuzzy controller with a granularity of five symmetric MFs. Parameters for the output variable have constant values.

Variable | Linguistic Value | MF | Parameters |
---|---|---|---|

${\theta}_{e}$ | high negative | ${\mu}_{trap}$ | $[-50,-5,-b,-b+c]$ |

${\theta}_{e}$ | medium negative | ${\mu}_{tria}$ | $[-d-e,-d,-d+e]$ |

${\theta}_{e}$ | low | ${\mu}_{tria}$ | $[-a,0,a]$ |

${\theta}_{e}$ | medium positive | ${\mu}_{tria}$ | $[-d-e,d,d+e]$ |

${\theta}_{e}$ | high positive | ${\mu}_{trap}$ | $[b-c,b,5,50]$ |

$error$ | high negative | ${\mu}_{trap}$ | $[-50,-5,-g,-g+h]$ |

$error$ | medium negative | ${\mu}_{tria}$ | $[-i-j,-i,-i+j]$ |

$error$ | low | ${\mu}_{tria}$ | $[-f,0,f]$ |

$error$ | medium positive | ${\mu}_{tria}$ | $[-i-j,i,i+j]$ |

$error$ | high positive | ${\mu}_{trap}$ | $[g-h,g,5,50]$ |

$\omega $ | high negative | ${\mu}_{trap}$ | $[-50,-5,-1,-0.5]$ |

$\omega $ | medium negative | ${\mu}_{tria}$ | $[-1,-0.5,0]$ |

$\omega $ | low | ${\mu}_{tria}$ | $[-0.5,0,0.5]$ |

$\omega $ | medium positive | ${\mu}_{tria}$ | $[0,0.5,1]$ |

$\omega $ | high positive | ${\mu}_{trap}$ | $[0.5,1,5,50]$ |

Parameter | Range | Parameter | Range |
---|---|---|---|

a | [0,1] | f | [0, 1] |

b | [0.5,2] | g | [0.5, 2] |

c | [0,2] | h | [0, 2] |

d | [0.5,1.5] | i | [0.5,1.5] |

e | [0,1] | j | [0, 1] |

Rule 1: | If ${\mathit{\theta}}_{\mathit{e}}$ is | hi_neg | and e is | hi_neg | then $\mathit{\omega}$ is | hi_pos |

Rule 2: | If ${\theta}_{e}$ is | hi_neg | and e is | med_neg | then $\omega $ is | hi_pos |

Rule 3: | If ${\theta}_{e}$ is | hi_neg | and e is | low | then $\omega $ is | hi_pos |

Rule 4: | If ${\theta}_{e}$ is | hi_neg | and e is | med_pos | then $\omega $ is | med_pos |

Rule 6: | If ${\theta}_{e}$ is | med_neg | and e is | hi_neg | then $\omega $ is | med_pos |

Rule 7: | If ${\theta}_{e}$ is | med_neg | and e is | med_neg | then $\omega $ is | med_pos |

Rule 8: | If ${\theta}_{e}$ is | med_neg | and e is | low | then $\omega $ is | med_pos |

Rule 9: | If ${\theta}_{e}$ is | med_neg | and e is | med_pos | then $\omega $ is | med_pos |

Rule 10: | If ${\theta}_{e}$ is | med_neg | and e is | hi_pos | then $\omega $ is | low |

Rule 11: | If ${\theta}_{e}$ is | low | and e is | hi_neg | then $\omega $ is | hi_pos |

Rule 12: | If ${\theta}_{e}$ is | low | and e is | med_neg | then $\omega $ is | low |

Rule 13: | If ${\theta}_{e}$ is | low | and e is | low | then $\omega $ is | low |

Rule 14: | If ${\theta}_{e}$ is | low | and e is | med_pos | then $\omega $ is | low |

Rule 15: | If ${\theta}_{e}$ is | low | and e is | hi_pos | then $\omega $ is | hi_neg |

Rule 16: | If ${\theta}_{e}$ is | med_pos | and e is | hi_neg | then $\omega $ is | low |

Rule 17: | If ${\theta}_{e}$ is | med_pos | and e is | med_neg | then $\omega $ is | med_neg |

Rule 18: | If ${\theta}_{e}$ is | med_pos | and e is | low | then $\omega $ is | med_neg |

Rule 19: | If ${\theta}_{e}$ is | med_pos | and e is | med_pos | then $\omega $ is | med_neg |

Rule 20: | If ${\theta}_{e}$ is | med_pos | and e is | hi_pos | then $\omega $ is | med_neg |

Rule 21: | If ${\theta}_{e}$ is | hi_pos | and e is | hi_neg | then $\omega $ is | low |

Rule 22: | If ${\theta}_{e}$ is | hi_pos | and e is | med_neg | then $\omega $ is | med_neg |

Rule 23: | If ${\theta}_{e}$ is | hi_pos | and e is | low | then $\omega $ is | hi_neg |

Rule 24: | If ${\theta}_{e}$ is | hi_pos | and e is | med_pos | then $\omega $ is | hi_neg |

Rule 25: | If ${\theta}_{e}$ is | hi_pos | and e is | hi_pos | then $\omega $ is | hi_neg |

**Table 5.**Summary of the parameters for the sequential GA and PSO algorithms compared. The general parameters section indicates the parameters that are the same for both algorithms.

Algorithm | Parameter | Value |
---|---|---|

GA | Selection | Tournament Selection (k = 3) |

Mutation | Gaussian ($\mu =0.0$ and $\sigma =0.2$) | |

Mutation probability | 0.3 | |

Crossover | One point (probability = 0.7) | |

PSO | Topology | Fully connected |

Speed limit | Min = −0.25, Max = 0.25 | |

Cognitive and Social | ${C}_{1}=2,{C}_{2}=2$ | |

General Parameters | ||

Population Size | 50 | |

Number of Iterations | 20 | |

Number of Function Evaluations | 1000 |

**Table 6.**Summary of parameters for the multi-population versions of the GA and PSO algorithms. In the top section, we have the case in which all islands have the same parameters (homogeneous parametrization). In the next section, we have the heterogeneous parametrization, in this case, some parameters are randomly obtained from a range of values. Finally, the general multi-population parameters section indicates parameters that are the same for both algorithms.

Homogeneous Parametrization | ||
---|---|---|

Algorithm | Parameter | Value |

GA | Selection | Tournament Selection (k = 3) |

Mutation | Gaussian ($\mu =0.0$ and $\sigma =0.2$) | |

Mutation probability | 0.3 | |

Crossover | One point (probability = 0.7) | |

PSO | Topology | Fully connected |

Speed limit | Min = −0.25, Max = 0.25 | |

Cognitive and Social | ${C}_{1}=2,{C}_{2}=2$ | |

Heterogeneous Parametrization | ||

Algorithm | Parameter | Value or Random Range |

GA | Selection | Tournament Selection (k = 3) |

Mutation | Gaussian ($\mu =0.0$ and $\sigma =0.2$) | |

Mutation probability | [0.1, 0.5] | |

Crossover | One point (probability = [0.3, 0.9]) | |

PSO | Topology | Fully connected |

Speed limit | Min = [−0.20, −0.30], Max = [0.20, 0.30] | |

Cognitive and Social | ${C}_{1}=[1.0,2.0],{C}_{2}=[1.0,2.0]$ | |

General Multi-Population Parameters | ||

Population Size | 9 | |

Number of Populations | 7 | |

Iterations per pull | 4 | |

Cycles | 4 | |

Number of Function Evaluations | 1008 |

Parameter | Value |
---|---|

Wheel-base | $l=2.5$ |

Steering limit | $\left|\delta \right|\le \frac{\pi}{4}$ |

Initial configuration | ${x}_{r}\left(0\right),{y}_{r}\left(0\right),\theta \left(0\right)=(0,0,0)$ |

Velocity controller configuration | ${K}_{p}=1,v\left(0\right)=0,a\left(0\right)=0$ |

Target velocity | ${v}_{r}=\frac{10}{3}$ |

Maximum time | 50 |

Path 1 | $ax=[0,6,12,5,7.5,3,-1]$ |

$ay=[0,0,5,6.5,3,5,-2]$ | |

Path 2 | $ax=[0,1,2.5,5,7.5,3,-1]$ |

$ay=[0,-4,6,6.5,3,5,-2]$ | |

Path 3 | $ax=[0,2,2.5,5,7.5,-3,-1]$ |

$ay=[0,3,6,6.5,5,5,-2]$ |

**Table 8.**Results of the execution of 30 runs of the presented algorithms. The controller error is expressed as the RMSE obtained by the best controller found in each run. The table shows the results for the sequential (first two columns) and distributed versions of the multi-population-based algorithms: GA, PSO, and the combined version PSO-GA. The homogeneous versions are on the left-hand side and heterogeneous versions are on the right. The best result is shown in boldface; second best is underlined.

Homogeneous Parameters | Heterogeneous Parameters | |||||||
---|---|---|---|---|---|---|---|---|

Sequential | Distributed | |||||||

GA | PSO | GA | PSO | PSO-GA | GA | PSO | PSO-GA | |

Average | 0.01564106 | 0.00546486 | 0.01091576 | 0.00645341 | 0.00656220 | 0.01029059 | 0.00632935 | 0.00634867 |

Std. Dev. | 0.03163634 | 0.00202007 | 0.00600245 | 0.00148185 | 0.00185666 | 0.00332792 | 0.00165840 | 0.00135594 |

Median | 0.00918906 | 0.00536160 | 0.00955549 | 0.00643669 | 0.00625087 | 0.01021287 | 0.00628949 | 0.00610783 |

Min | 0.00574378 | 0.00158063 | 0.00384490 | 0.00360178 | 0.00336501 | 0.00399671 | 0.00310301 | 0.00388684 |

Max | 0.18205041 | 0.01026034 | 0.03455102 | 0.01000582 | 0.01168791 | 0.01584733 | 0.00891131 | 0.00889502 |

**Table 9.**Results from 30 observations of the execution time for each of the presented algorithms. blueThe table shows execution times in seconds and the speedup against the sequential alternative in subscripts. The table shows the results for the sequential (first two columns) and distributed versions of the multi-population-based algorithms: GA, PSO, and the combined version PSO-GA. The homogeneous versions are on the left side and heterogeneous versions on the right.

Homogeneous Parameters | Heterogeneous Parameters | |||||||
---|---|---|---|---|---|---|---|---|

Sequential | Distributed | |||||||

GA | PSO | GA | PSO | PSO-GA | GA | PSO | PSO-GA | |

Average | 1999.34 | 2851.61 | ${421.67}_{4.74}$ | ${415.64}_{\mathbf{6.86}}$ | ${431.52}_{6.60}$ | ${395.75}_{5.05}$ | ${415.79}_{6.84}$ | ${409.90}_{\underline{6.95}}$ |

Std. Dev. | 82.44 | 278.73 | 28.54 | 23.47 | 22.60 | 26.54 | 20.47 | 24.85 |

Median | 1990.46 | 2770.62 | ${417.84}_{4.72}$ | ${412.68}_{\mathbf{6.71}}$ | ${432.36}_{6.40}$ | ${392.80}_{5.06}$ | ${414.66}_{6.66}$ | ${408.48}_{\underline{6.79}}$ |

Min | 1876.40 | 2457.98 | 364.65 | 365.81 | 394.61 | 340.65 | 374.83 | 372.20 |

Max | 2253.71 | 3822.01 | 526.76 | 467.47 | 478.80 | 461.46 | 461.96 | 465.27 |

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |

© 2023 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

García-Valdez, M.; Mancilla, A.; Castillo, O.; Merelo-Guervós, J.J.
Distributed and Asynchronous Population-Based Optimization Applied to the Optimal Design of Fuzzy Controllers. *Symmetry* **2023**, *15*, 467.
https://doi.org/10.3390/sym15020467

**AMA Style**

García-Valdez M, Mancilla A, Castillo O, Merelo-Guervós JJ.
Distributed and Asynchronous Population-Based Optimization Applied to the Optimal Design of Fuzzy Controllers. *Symmetry*. 2023; 15(2):467.
https://doi.org/10.3390/sym15020467

**Chicago/Turabian Style**

García-Valdez, Mario, Alejandra Mancilla, Oscar Castillo, and Juan Julián Merelo-Guervós.
2023. "Distributed and Asynchronous Population-Based Optimization Applied to the Optimal Design of Fuzzy Controllers" *Symmetry* 15, no. 2: 467.
https://doi.org/10.3390/sym15020467