AI-Based Optimization of a Neural Discrete-Time Sliding Mode Controller via Bayesian, Particle Swarm, and Genetic Algorithms

Abstract

This work introduces a unified Artificial Intelligence-based framework for the optimal tuning of gains in a neural discrete-time sliding mode controller (SMC) applied to a two-degree-of-freedom robotic manipulator. The novelty lies in combining surrogate-assisted optimization with normalized search spaces to enable a fair comparative analysis of three metaheuristic strategies: Bayesian Optimization (BO), Particle Swarm Optimization (PSO), and Genetic Algorithms (GAs). The manipulator dynamics are identified via a discrete-time recurrent high-order neural network (NN) trained online using an Extended Kalman Filter with adaptive noise covariance updates, allowing the model to accurately capture unmodeled dynamics, nonlinearities, parametric variations, and process/measurement noise. This neural representation serves as the predictive plant for the discrete-time SMC, enabling precise control of joint angular positions under sinusoidal phase-shifted references. To construct the optimization dataset, MATLAB^® simulations sweep the controller gains $(k_0^{*},k_1^{*})$ over a bounded physical domain, logging steady-state tracking errors. These are normalized to mitigate scaling effects and improve convergence stability. Optimization is executed in Python^® using integrated scikit-learn, DEAP, and scikit-optimize routines. Simulation results reveal that all three algorithms reach high-performance gain configurations. Here, the combined cost is the normalized aggregate objective $\tilde{J}$ constructed from the steady-state tracking errors of both joints. Under identical experimental conditions (shared data loading/normalization and a single Python pipeline), PSO attains the lowest error in Joint 1 ($7.36\times {10}^{-5}$ rad) with the shortest runtime (23.44 s); GA yields the lowest error in Joint 2 ($8.18\times {10}^{-3}$ rad) at higher computational expense (≈69.7 s including refinement); and BO is competitive in both joints ($7.81\times {10}^{-5}$ rad, $8.39\times {10}^{-3}$ rad) with a runtime comparable to PSO (23.65 s) while using only 50 evaluations.

1. Introduction

Neural sliding mode control (SMC) has become an effective paradigm for dealing with the nonlinearities and uncertainties inherent in robotic systems. In particular, discrete-time formulations of SMC combined with neural approximators have gained attention for real-time control applications involving robotic manipulators. However, the tuning of control gains in these architectures remains a non-trivial task that directly influences performance, robustness, and stability.

Recent contributions in the literature have explored a variety of approaches to optimize sliding mode controller parameters using nature-inspired and learning-based strategies. For example, in [1], a robust adaptive neural SMC framework was proposed, optimized via Grey Wolf Optimizer to enhance tracking accuracy and robustness in robot manipulators.

Similarly, in [2], a Particle Swarm Optimization (PSO)-tuned SMC was implemented in the context of robotic rehabilitation, highlighting its effectiveness for human–robot interaction. Within physical human–robot collaboration (pHRC), recent work has modeled a robot’s trust in its human co-worker using measurable factors, validated on a collaborative manipulator setup [3]. Other researchers have focused on Bayesian-based strategies, such as adaptive Gaussian process modeling with adaptive kernels to improve sample efficiency in robotic control scenarios [4]. Genetic Algorithms (GAs) have also been investigated for gain optimization in SMC settings; for instance, [5] demonstrated the effectiveness of GA-tuned SMC in mitigating chattering and ensuring precision tracking in multi-DOF manipulators.

Beyond traditional metaheuristics, recent advances have incorporated Artificial Intelligence techniques into the sliding mode framework. For example, in [6], an adaptive neural sliding mode controller for a flexible robotic manipulator was proposed, where the neural network learns online to approximate model uncertainties, ensuring robust tracking despite dynamic variations. In a related direction, in [7], a deep reinforcement learning-based SMC design was introduced for a partially known nonlinear systems, in which a policy gradient method adaptively adjusts the sliding mode control effort, effectively bridging classical robustness with data-driven adaptability. Complementarily, sampled-data admittance control integrated with a data-driven moving-horizon velocity estimator (based on Willems’ fundamental lemma) has been shown to stabilize pHRI under noisy, discontinuous velocity measurements and to improve both transient and steady-state tracking [8].

Despite recent advances in Artificial Intelligence (AI)-based controller design, most studies either focus on continuous-time implementations or lack a unified methodology for comparing multiple optimization strategies under the same normalized framework. Moreover, few works incorporate a surrogate modeling strategy to reduce computational cost during optimization iterations. Also, in real-world control applications, the tuning of controller gains is frequently performed manually, relying on heuristic adjustments and iterative trial-and-error refinements by human experts. This manual approach is not only time-consuming but also prone to suboptimal performance, especially in systems with nonlinear dynamics, modeling errors, or parametric uncertainties. These challenges are amplified when dealing with discrete-time implementations and neural-based controllers, where interactions between gain parameters and recurrent dynamics are not easily interpretable.

To address this, this work proposes a comprehensive methodology to optimize the gains of a neural discrete-time sliding mode controller using three metaheuristic techniques: Bayesian Optimization (BO), Particle Swarm Optimization (PSO), and Genetic Algorithms (GAs). The robot dynamics are first estimated via a recurrent high-order neural network trained with an Extended Kalman Filter (EKF) algorithm that dynamically updates measurement and process noise covariance matrices and where the training is performed online. Then, a dataset of tracking errors and gains is collected by sweeping controller parameters in the physical domain and subsequently normalized. This normalization ensures that all optimization algorithms operate within a common domain ${[0,1]}^2$, enabling fair comparison and improved convergence behavior.

The objective is to identify the optimal control gains $\{k_0^{*},k_1^{*}\}$ that minimize steady-state tracking errors in both joints of a 2-DOF robotic manipulator. By leveraging surrogate models and normalized search spaces, this study demonstrates how each optimization method balances accuracy, computational effort, and robustness, offering valuable insights into controller design for robotic applications.

The main contributions of this work are as follows:

• Discrete-time SMC + recurrent high-order NN integration. It is coupled a discrete-time sliding-mode controller with a recurrent high-order neural network identified online via EKF, with adaptive noise covariance updates. This NN reproduces the 2-DOF robot dynamics used by the controller.
• Unified, normalized benchmark across BO/PSO/GA. All optimizers run in the same pipeline (shared data loading, normalized gain space ${[0,1]}^2$, identical budgets/criteria, common steady-state error objective), enabling a fair, apples-to-apples comparison.
• Surrogate-assisted screening with diagnostics. Integrate GP surrogates and report model adequacy ($R^2$), evaluation counts, and wall-clock time alongside tracking performance.
• Progression and convergence analytics. Progression plots (early/mid/final) and normalized convergence curves of the aggregate objective $\tilde{J}$ are provided to expose exploration–exploitation dynamics and steady-state improvements in discrete time.
• Constraint-aware evaluation. Limits enforced actuator torque via the SMC saturation branch and verifies bounded control actions in simulation, linking optimization outcomes to implementability.
• Actionable guidance. The unified analysis reveals when PSO, BO, or GA is preferable (e.g., PSO is fastest, BO is most sample-efficient, GA is competitive accuracy at higher cost), providing practical guidance for discrete-time SMC with recurrent high-order NN plants.
• Principled alternative to heuristic tuning. Replaced ad hoc trial and error with a reproducible, data-driven pipeline—discrete-time SMC + recurrent high-order NN—optimized under a unified, normalized setup with BO/PSO/GA.

Together, these elements constitute a novel, reproducible benchmarking framework for discrete-time SMC gain tuning with recurrent high-order NN-based plant models in 2-DOF manipulators, extending beyond isolated demonstrations to deliver a systematic methodology and decision-relevant evidence for controller design.

This paper is organized as follows: Section 2 details the proposed methodology, including the discrete-time modeling of the 2-DOF robot manipulator, the identification of the plant using a recurrent high-order NN trained with the EKF, the implementation of the neural discrete-time sliding mode control algorithm, and the organization of the dataset used for training and simulation. It also describes the application of three metaheuristic optimization algorithms—BO, PSO, and GA—for automatic gain tuning. Section 3 presents the main simulation results across the entire dataset, and some tables of the main results, and Section 4 displays a discussion of the findings and their implications.

2. Methodology

2.1. Dynamic Model of the Two-DOF Robotic Manipulator

To show the proposed method, let us describe the mathematical expression of the robot manipulator in general form in continuous time [9,10]:

$$\mathbf{M}\left(\mathbf{q}\right)\ddot{\mathbf{q}}+\mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}}+\mathbf{G}\left(\mathbf{q}\right)+{\mathbf{F}}_v\left(\dot{\mathbf{q}}\right)+{\mathbf{F}}_c\left(\dot{\mathbf{q}}\right)=\tau .$$

(1)

For the particular case of the two degrees of freedom robot, $\mathbf{q}=\left[\begin{array}{c}{q}_1\\ q_2\end{array}\right]$ are the joint positions (rad), $\dot{\mathbf{q}}=\left[\begin{array}{c}{\dot{q}}_1\\ {\dot{q}}_2\end{array}\right]$ are the joint velocities (rad/s), $\mathit{\tau }=\left[\begin{array}{c}{\tau }_1\\ {\tau }_2\end{array}\right]$ are the applied torques N · m. The inertia matrix is $\mathbf{M}\left(\mathbf{q}\right)=\left[\begin{array}{cc}{M}_{11}& M_{12}\\ M_{21}& M_{22}\end{array}\right],$ where

$$\begin{array}{cc}\hfill M_{11}& =m_1{l}_{c1}^2+m_2\left(l_1^2+l_{c2}^2+2l_1{l}_{c2}cos{q}_2\right)+I_1+I_2,\hfill \\ \hfill M_{12}& =m_2\left(l_{c2}^2+l_1{l}_{c2}cos{q}_2\right)+I_2,\hfill \\ \hfill M_{21}& =M_{12},\hfill \\ \hfill M_{22}& =m_2{l}_{c2}^2+I_2\hfill \end{array}$$

(2)

With each element of the matrix $\mathbf{M}\left(\mathbf{q}\right)$ is in (kg · ${\mathrm{m}}^2$); $l_1$ and $l_2$, $l_{c1}$ and $l_{c2}$, $m_1$ and $m_2$, $I_1$ and $I_2$ are the lengths (m), centers of mass (m), mass (kg), and moments of inertia (kg $·$ ${\mathrm{m}}^2$) of Links 1 and 2, respectively. The Coriolis and centrifugal contributions are expressed in the form $\mathbf{C}(\mathbf{q},\dot{\mathbf{q}})=\left[\begin{array}{cc}{C}_{11}& C_{12}\\ C_{21}& C_{22}\end{array}\right]$ where each element is defined as

$$\begin{array}{cc}\hfill C_{11}& =-m_2{l}_1{l}_{c2}sin\left(q_2\right){\dot{q}}_2,\hfill \\ \hfill C_{12}& =-m_2{l}_1{l}_{c2}sin\left(q_2\right)\left({\dot{q}}_1+{\dot{q}}_2\right),\hfill \\ \hfill C_{21}& =\phantom{-}{m}_2{l}_1{l}_{c2}sin\left(q_2\right){\dot{q}}_1,\hfill \\ \hfill C_{22}& =0.\hfill \end{array}$$

(3)

Note that in this representation, each element $C_{ij}$ already incorporates the velocity terms and therefore directly represents a torque contribution expressed in (N $·$ m). The gravity vector is $\mathbf{G}\left(\mathbf{q}\right)=\left[\begin{array}{c}{G}_{11}\\ G_{21}\end{array}\right]=\left[\begin{array}{c}(m_1{l}_{c1}+m_2{l}_1)gsin{q}_1+m_2{l}_{c2}gsin(q_1+q_2)\\ m_2{l}_{c2}gsin(q_1+q_2)\end{array}\right]$ in (N $·$ m). The viscous friction is represented by ${\mathbf{F}}_v\left(\dot{\mathbf{q}}\right)=\left[\begin{array}{c}{f}_{v1}{\dot{q}}_1\\ f_{v2}{\dot{q}}_2\end{array}\right]$ in (N $·$ m $·$ s) and the Coulomb friction by ${\mathbf{F}}_c\left(\dot{\mathbf{q}}\right)=\left[\begin{array}{c}{f}_{c1}tanh\left(100{\dot{q}}_1\right)\\ f_{c2}tanh\left(100{\dot{q}}_2\right)\end{array}\right]$ in (N $·$ m).

To illustrate the present proposal, Dynamical Model (1) is discretized using the Euler approximation [11], which facilitates the implementation of the recurrent high-order NN and the discrete-time sliding mode controller. This discretized model results in

$$\begin{array}{cc}\hfill q_1(k+1)& =q_1\left(k\right)+T·q_3\left(k\right)\hfill \\ \hfill q_2(k+1)& =q_2\left(k\right)+T·q_4\left(k\right)\hfill \\ \hfill q_3(k+1)& =q_3\left(k\right)+T·[M_{11}^{\prime }·\left({\tau }_1\left(k\right)-C_{11}{q}_3\left(k\right)-C_{12}{q}_4\left(k\right)-G_{11}-f_1\right)\hfill \\ \hfill & +M_{12}^{\prime }·\left({\tau }_2\left(k\right)-C_{21}{q}_3\left(k\right)-C_{22}{q}_4\left(k\right)-G_{21}-f_2\right)]\hfill \\ \hfill q_4(k+1)& =q_4\left(k\right)+T·[M_{21}^{\prime }·\left({\tau }_1\left(k\right)-C_{11}{q}_3\left(k\right)-C_{12}{q}_4\left(k\right)-G_{11}-f_1\right)\hfill \\ \hfill & +M_{22}^{\prime }·\left({\tau }_2\left(k\right)-C_{21}{q}_3\left(k\right)-C_{22}{q}_4\left(k\right)-G_{21}-f_2\right)]\hfill \end{array}$$

(4)

where $M_{11}^{\prime }={\displaystyle \frac{M_{22}}{\left|M\right|}}$; $M_{12}^{\prime }={\displaystyle \frac{-M_{12}}{\left|M\right|}}$; $M_{21}^{\prime }={\displaystyle \frac{-M_{21}}{\left|M\right|}}$; $M_{22}^{\prime }={\displaystyle \frac{M_{11}}{\left|M\right|}}$; $f_1=f_{v1}{q}_3\left(k\right)+f_{c1}tanh\left(100q_3\left(k\right)\right)$, $f_2=f_{v2}{q}_4\left(k\right)+f_{c2}tanh\left(100q_4\left(k\right)\right)$, and T is the sampling step.

This discrete-time Model (4) is used for both simulating the robot’s response and training the recurrent neural network identifier. The parameters used in Expressions (2) through (3), which are essential for simulating the discrete-time model (4), are derived from the study presented in reference [10].

2.2. State Estimation with Recurrent High-Order NN

In this work, the methodology presented in a previous work [12] is employed, where a discrete-time recurrent high-order NN is employed to identify the dynamical behavior of (4). The goal for proposing this neural network is that this NN has the capability to absorb non-modeled dynamics, modeled error, and possible parameter variations that are common in the real system. Additionally, this NN can aid the controller in gaining variations and nonlinear effects in the closed-loop system produced by the reference inputs for tracking proposed in this work. Also, to make indirect control in series-parallel consuration such that the discrete-time sliding mode algorithm acts directly on the neural network structure and so that the NN reproduces the model (4), the outputs of this model track the reference signals. Then, the recurrent high-order NN proposed for this work has the following general structure:

$$x_i(k+1)={\mathbf{W}}_i{\left(k\right)}^{\top }{\mathbf{H}}_i\left(k\right)+b_i\left(k\right),$$

(5)

where x denotes the NN state, with $i=1,2,..,n$ as the number of states, ${\mathbf{W}}_i\left(k\right)\in {\mathbb{R}}^3$ are the adaptive synaptic weights, ${\mathbf{H}}_i\left(k\right)$ are nonlinear regressors specific to each joint, $b_i\left(k\right)$ are linear dynamic contributions linked to the velocity or torque signals. Specifically, to reproduce the dynamics of the 2-DOF robot model in discrete time (4), the following recurrent high-order NN structure is proposed:

$$\begin{array}{cc}\hfill x_1(k+1)& ={\mathbf{W}}_1{\left(k\right)}^{\top }\left[\begin{array}{c}tanh\left(a{q}_1\left(k\right)\right)\\ tanh\left(a{q}_3\left(k\right)\right)\\ 1\end{array}\right]+w_{11}{q}_3\left(k\right)+{\sigma }_{q1}\mathcal{N}(0,1)\hfill \\ \hfill x_2(k+1)& ={\mathbf{W}}_2{\left(k\right)}^{\top }\left[\begin{array}{c}tanh\left(a{q}_2\left(k\right)\right)\\ tanh\left(a{q}_4\left(k\right)\right)\\ 1\end{array}\right]+w_{12}{q}_4\left(k\right)+{\sigma }_{q2}\mathcal{N}(0,1)\hfill \\ \hfill x_3(k+1)& ={\mathbf{W}}_3{\left(k\right)}^{\top }\left[\begin{array}{c}tanh\left(a{q}_1\left(k\right)\right)\\ tanh\left(a{q}_2\left(k\right)\right)\\ tanh\left(a{q}_3\left(k\right)\right)\end{array}\right]+w_{13}{\tau }_1\left(k\right)+{\sigma }_{q3}\mathcal{N}(0,1)\hfill \\ \hfill x_4(k+1)& ={\mathbf{W}}_4{\left(k\right)}^{\top }\left[\begin{array}{c}tanh\left(a{q}_1\left(k\right)\right)\\ tanh\left(a{q}_2\left(k\right)\right)\\ tanh\left(a{q}_4\left(k\right)\right)\end{array}\right]+w_{14}{\tau }_2\left(k\right)+{\sigma }_{q4}\mathcal{N}(0,1)\hfill \end{array}$$

(6)

where x are the NN state variables, each one estimating the behavior of their corresponding robot states of System (4); the synaptic weight vectors ${\mathbf{W}}_i\left(k\right)$ are adaptive online using the EKF, as explained in [12], where the state noise covariance matrix ${\mathbf{Q}}_i\left(k\right)$ and the associated measurement noise covariance matrix ${\mathbf{R}}_i\left(k\right)$ are computed using a time-varying formulation. Synaptic weights $w_{1i}$ are constant parameters to guarantee the controllability of the system; $\mathcal{N}(0,1)$ denotes a standard Gaussian random variable of measurement noise, and ${\sigma }_{qi}=0.001$ are the standard deviations; and hyperbolic tangent (tanh) is the activation function. The goal for using the EKF as training algorithm with the time-varying formulation is to reduce or to eliminate the estimation error $e_i\left(k\right)=q_i\left(k\right)-x_i\left(k\right)$.

The present formulation of this NN for estimating the plant states combines nonlinear activation function, dynamic contributions of the applied inputs, adaptive estimation using EKF, and Gaussian noise applied to the measurable variables. This is to show a robust and optimal control algorithm based on the NN structure.

2.3. Discrete-Time Sliding Mode Controller

The control algorithm employed in this work is based on the methodology presented in a previous study [12]. However, unlike their approach—which targets a five-degree-of-freedom robotic system—this proposal focuses on a planar robot with only two degrees of freedom. Naturally, this difference entails significant adjustments in aspects such as the neural network architecture, the number of inputs and outputs, and other related parameters.

We use the methodology presented in [12] to control the Model System (4) indirectly through the proposed recurrent high-order NN (6), such that the following NN tracking error vector converges to zero:

$${\mathbf{Z}}_1\left(k\right)=\left[\begin{array}{c}{x}_1\left(k\right)-re{f}_1\left(k\right)\\ x_2\left(k\right)-re{f}_2\left(k\right)\end{array}\right]$$

(7)

where $re{f}_1\left(k\right)$ and $re{f}_2\left(k\right)$ are the reference signals to be tracked by the NN states $x_1\left(k\right)$ and $x_2\left(k\right)$ of System (6), respectively, and therefore by the robot states $q_1\left(k\right)$ and $q_2\left(k\right)$ of System (4), we follow the methodology presented in [12]. Therefore, the discrete-time sliding mode control law is as follows:

$${\tau }_i\left(k\right)=\left\{\begin{array}{cc}{U}_{\mathrm{eq},i}\left(k\right),\hfill & \mathrm{if}|U_{\mathrm{eq},i}\left(k\right)|\le {\mathrm{sat}}_i,\hfill \\ {\mathrm{sat}}_i·{\displaystyle \frac{U_{\mathrm{eq},i}\left(k\right)}{|U_{\mathrm{eq},i}\left(k\right)|}},\hfill & \mathrm{otherwise},\hfill \end{array}\right.i=1,2.$$

(8)

with the discrete control torque vector given by:

$${\mathbf{U}}_{\mathrm{eq}}\left(k\right)=-{\mathbf{B}}_1^{-1}\left({\mathbf{F}}_1\left(k\right)+{\mathbf{X}}_{1,\mathrm{des}}(k+1)+{\mathbf{K}}_1{\mathbf{Z}}_2\left(k\right)\right),$$

(9)

In (8), $U_{\mathrm{eq},i}\left(k\right)$ denotes the ith component of the equivalent control vector ${\mathbf{U}}_{\mathrm{eq}}\left(k\right)\in {\mathbb{R}}^2$, computed in (9). The scalar ${\mathrm{sat}}_i>0$ is the actuator torque bound (N · m) for joint i; in these simulations, ${\mathrm{sat}}_1=80$ N · m and ${\mathrm{sat}}_2=20$ N · m. The term ${\displaystyle \frac{U_{\mathrm{eq},i}\left(k\right)}{|U_{\mathrm{eq},i}\left(k\right)|}}$ is the sign of $U_{\mathrm{eq},i}\left(k\right)$ (and is defined as 0 when $U_{\mathrm{eq},i}\left(k\right)=0$), ensuring pointwise saturation of the torque ${\tau }_i\left(k\right)$ to the interval $[-{\mathrm{sat}}_i,{\mathrm{sat}}_i]$.

Also,

$${\mathbf{B}}_1=\mathrm{diag}(b_{1,a},b_{1,b}),{\mathbf{K}}_1=\mathrm{diag}(k_1,k_1),$$

(10)

$${\mathbf{F}}_1\left(k\right)=\left[\begin{array}{c}{f}_{1,a}\left(k\right)\\ f_{1,b}\left(k\right)\end{array}\right],{\mathbf{Z}}_2\left(k\right)={\mathbf{x}}_2\left(k\right)-{\mathbf{X}}_{1,\mathrm{des}}\left(k\right)$$

(11)

$${\mathbf{X}}_{1,\mathrm{des}}(k+1)=-{\mathbf{B}}_0^{-1}\left({\mathbf{F}}_0(k+1)+{\mathbf{K}}_0{\mathbf{Z}}_1(k+1)-\mathbf{ref}(k+2)\right),$$

(12)

with the equivalent control component computed as

$${\mathbf{F}}_0(k+1)=\left[\begin{array}{c}{f}_{0,a}(k+1)\\ f_{0,b}(k+1)\end{array}\right],{\mathbf{Z}}_1(k+1)={\mathbf{x}}_1(k+1)-\mathbf{ref}(k+1),$$

and the reference signals $\mathbf{ref}(k+1)=\left[\begin{array}{c}re{f}_1(k+1)\\ re{f}_2(k+1)\end{array}\right],\mathbf{ref}(k+2)=\left[\begin{array}{c}re{f}_1(k+2)\\ re{f}_2(k+2)\end{array}\right].$

The desired discrete velocity signal is computed as

$${\mathbf{X}}_{1,\mathrm{des}}\left(k\right)=-{\mathbf{B}}_0^{-1}\left({\mathbf{F}}_0\left(k\right)+{\mathbf{K}}_0{\mathbf{Z}}_1\left(k\right)-\mathbf{ref}(k+1)\right),$$

(13)

where

$${\mathbf{B}}_0=\mathrm{diag}(b_{0,a},b_{0,b}),{\mathbf{K}}_0=\mathrm{diag}(k_0,k_0).$$

(14)

and ${\mathbf{F}}_0\left(k\right)$ denotes the estimated dynamic term provided by the recurrent NN identification:

$${\mathbf{F}}_0\left(k\right)=\left[\begin{array}{c}{f}_{0,a}\left(k\right)\\ f_{0,b}\left(k\right)\end{array}\right].$$

The reference trajectories are defined as

$$\mathbf{ref}\left(k\right)=\left[\begin{array}{c}re{f}_1\left(k\right)\\ re{f}_2\left(k\right)\end{array}\right]=\left[\begin{array}{c}1.5·sin\left(2\pi ·0.5·kT+{\displaystyle \frac{\pi }{4}}\right)\\ 1.0·sin\left(2\pi ·0.3·kT+{\displaystyle \frac{\pi }{2}}\right)\end{array}\right]$$

(15)

for the step $(k+1)$:

$$\mathbf{ref}(k+1)=\left[\begin{array}{c}re{f}_1(k+1)\\ re{f}_2(k+1)\end{array}\right]=\left[\begin{array}{c}1.5·2\pi ·0.5·cos\left(2\pi ·0.5·kT+{\displaystyle \frac{\pi }{4}}\right)\\ 1.0·2\pi ·0.3·cos\left(2\pi ·0.3·kT+{\displaystyle \frac{\pi }{2}}\right)\end{array}\right]$$

(16)

and for the step $(k+2)$:

$$\mathbf{ref}(k+2)=\left[\begin{array}{c}re{f}_1(k+2)\\ re{f}_2(k+2)\end{array}\right]=\left[\begin{array}{c}-1.5·{(2\pi ·0.5)}^2·sin\left(2\pi ·0.5·kT+{\displaystyle \frac{\pi }{4}}\right)\\ -1.0·{(2\pi ·0.3)}^2·sin\left(2\pi ·0.3·kT+{\displaystyle \frac{\pi }{2}}\right)\end{array}\right]$$

(17)

where T is the sampling period. It is worth noting that the reference signals assigned to each joint differ in both amplitude and phase. This design choice is intentional and serves to evaluate the stability margin of the proposed control system under non-identical and time-varying tracking conditions. By introducing distinct dynamics for each joint, the control system is subjected to more demanding scenarios, thereby allowing for a more comprehensive assessment of its performance and adaptability. For a more detailed explanation of the control synthesis, please refer to [12].

It is important to remark that the control gains $k_0$ in (14) and $k_1$ in (10) are responsible for driving the NN-based tracking error vector (7) toward zero. Typically, these control gains are tuned heuristically, where the practitioner manually adjusts the parameters based on qualitative or quantitative assessments of the tracking performance. The objective is to achieve minimal tracking error. Three systematic procedures for optimizing these control gains are presented in the following subsections.

2.4. Data Generation and CSV Export for AI-Based Optimization

A script file in Matlab^® is prepared to indirectly control Robot Model (4) based on the recurrent high-order NN (6) and trained with the EKF, as explained in Section 2.2 and Section 2.3.

The primary objective of this script is to explore a grid of controller gain values systematically, $k_0$ and $k_1$, and record the resulting tracking performance to facilitate the application of Artificial Intelligence (AI) optimization methods.

Then, the procedure for obtaining the dataset is summarized as follows:

• Gain Sweep and Data Storage: A grid search is performed over a discrete range of controller gain values:

  $$k_0\in \{100,102,\dots ,258\},k_1\in \{100,102,\dots ,258\},$$

  (18)

  resulting in $80\times 80=6400$ total simulations. For each simulation, the values of $k_0$ and $k_1$ are embedded in diagonal gain matrices ${\mathbf{K}}_0$ (14) and ${\mathbf{K}}_1$ (10).
  The control algorithm is executed for each pair $(k_0,k_1)$, and the resulting states, control inputs, reference signals, and estimation errors are recorded. Of particular interest is the tracking error vector ${\mathbf{Z}}_1\left(k\right)$, defined in (7).
• NN tracking error storage. The NN tracking errors are also stored with the following features:

  $$Z_{11}\left(k\right),Z_{21}\left(k\right)\in \{6400\times 5000\}$$

  (19)
  They correspond to the total combinations of the control gains $k_0$ and $k_1$× the total steps of simulations.
• Simulation Setup. The simulations are performed using a discrete-time step of $T=0.001\mathrm{s}$. Each trial corresponds to a unique pair of controller gains $(k_0,k_1)$ within the range mentioned in (18), forming an exhaustive grid for gain evaluation. The simulation environment includes measurement noise and process disturbances, both modeled as additive zero-mean Gaussian noise.
• Simulation Length. Each simulation run spans a total of 5000 time steps, corresponding to a real-time duration of 5 s. This duration is sufficient to capture the transient and steady-state behavior of the robotic manipulator under sinusoidal reference tracking.
• Control Saturation. Actuator saturation is considered to reflect physical constraints. The saturation limits are set as follows: Joint 1: ${\tau }_{1,\max }=80$ N$·$m; Joint 2: ${\tau }_{2,\max }=20$ N$·$m. Any control input exceeding these thresholds is clipped accordingly.
• Initial Conditions. The robot’s original state variables are initialized as follows: Joint positions: $q_1\left(0\right)=1$ rad, $q_2\left(0\right)=2$ rad; Joint velocities: $q_3\left(0\right)=0$ rad/s, $q_4\left(0\right)=0$ rad/s. The estimated states from the neural observer are initialized as follows: Estimated positions and velocities: $x_i\left(0\right)=0$ for $i=1,2,3,4$. The distinct initial values of the original and estimated states are chosen to evaluate the fast convergence capability of the NN.
• Export to CSV Format. After simulating all gain combinations, the script exports the data into separate .csv files to facilitate further analysis and AI-based optimization. These files include:

  –

  k0.csv and k1.csv: Contain the scalar gain values used in each simulation, with one value per row.

  –

  Z1.csv and Z2.csv: Store the first and second components of the NN tracking error vector ${\mathbf{Z}}_1\left(k\right)$ (7) for all simulations. Each row corresponds to a simulation instance, and each column corresponds to a discrete-time step k.

  These exported files serve as the dataset for AI optimization. The input features are the gain values $k_0$ (14) and $k_1$ (10), and the objective is to minimize the norm of the tracking error:

  $$J(k_0,k_1)=\sum _{k=1}^N{\parallel {\mathbf{Z}}_1\left(k\right)\parallel }^2,$$

  (20)

  where N is the number of time steps in the simulation. This objective function is used to train regression models or directly guide optimization algorithms.

The dataset generated from the script file in Matlab^® thus becomes the cornerstone for offline training and evaluation of AI-based methods to identify the optimal controller gains that minimize tracking error across all trajectories. This strategy bypasses the need for analytical tuning and enables data-driven calibration with high accuracy and generalization capability. The total dataset captures enough information that can be used to optimize the control gains $k_0$ (14) and $k_1$ (10) for minimizing the NN tracking errors (7) and therefore the original tracking error vector

$$\mathbf{e}\left(k\right)=\left[\begin{array}{c}{e}_1\left(k\right)\\ e_2\left(k\right)\end{array}\right]=\mathbf{q}\left(k\right)-\mathbf{ref}\left(k\right)=\left[\begin{array}{c}{q}_1\left(k\right)-re{f}_1\left(k\right)\\ q_2\left(k\right)-re{f}_2\left(k\right)\end{array}\right]$$

(21)

with $\mathbf{q}\left(k\right)=\left[\begin{array}{c}{q}_1\left(k\right)\\ q_2\left(k\right)\end{array}\right]$ of System (4).

In the following subsections, we present three optimization procedures consisting of BO, PSO, and GA which optimize the control gains $k_0$ (14) and $k_1$ (10) to minimize the NN tracking error vector ${\mathbf{Z}}_1\left(k\right)$ (7) and of course the original tracking error vector $\mathbf{e}\left(k\right)$ (21). Figure 1 presents the complete optimization workflow, structured into three distinct branches corresponding to the BO, PSO, and GA approaches. The process begins with two common preprocessing blocks: Load CSV Data and Normalize Data. Each branch subsequently applies its respective algorithmic strategy to search the parameter space for optimal control gains. All three branches converge at their respective endpoints, yielding the optimal pair of gains $(k_0^{*},k_1^{*})$ that minimize the NN tracking error vector ${\mathbf{Z}}_1\left(k\right)$ (7) and of course the original tracking error vector $\mathbf{e}\left(k\right)$ (21) of the discrete-time sliding mode controller for the 2-DOF robot (4).

2.5. Load CSV Data

The data loading stage was implemented in Python version 3.8.1 using the pandas and numpy libraries [13,14]. The script to load data in .py file performs the following operations:

• CSV Import. As mentioned before, four CSV files are loaded: k0.csv and k1.csv that contain the controller gain vectors $k_0$ (14) and $k_1$ (10) explored in the parameter sweep, each of dimension $6400\times 1$; and Z1.csv and Z2.csv that contain the time-series NN tracking errors ${\mathbf{Z}}_1\left(k\right)$ (7) per simulation, each of dimension $6400\times 5000$. These files are imported as NumPy arrays using pd.read_csv(filename, header=None).values.
• Dimensionality Checks. This is performed to ensure consistency and to guarantee that each gain combination has a corresponding tracking error trajectory. Then, the script validates $\mathrm{assert}\mathrm{len}\left(k_0\right)=\mathrm{len}\left(k_1\right)=6400,\mathrm{Z}1.\mathrm{shape}=\mathrm{Z}2.\mathrm{shape}=(6400,5000).$
• Computation of Steady-State Errors. To condense the time series into a scalar measure of control performance per axis, for each simulation, the final NN tracking error is summarized as the mean absolute error over the last 100 samples as $es{s}_i\left(j\right)={\displaystyle \frac{1}{100}}{\sum }_{k=4901}^{5000}\left|Z_i(j,k)\right|,i=1,2.$
• Cost Function Computation. The cost per simulation is defined as the sum of both steady-state errors:

  $$J\left(j\right)=es{s}_1\left(j\right)+es{s}_2\left(j\right).$$

  (22)
  This represents the global tracking deviation for the given gains $(k_0,k_1)$ (18).
• Feature Matrix Assembly. A matrix $X\in {\mathbb{R}}^{6400\times 2}$ is constructed by stacking the gain vectors (18):

  $$X=\left[\begin{array}{cc}{k}_0& k_1\end{array}\right].$$

  (23)
  This matrix serves as the input space for subsequent optimization algorithms.

This modular approach separates the dataset preprocessing logic from the optimization routines and ensures reproducibility of the feature-target mapping. By returning the tuple $(X,J,k_0,k_1,\mathrm{Z}1,\mathrm{Z}2)$, the pipeline retains access to both the summarized metrics and the full error trajectories for visualization or additional analysis.

2.6. Normalize Data

To prevent variables with larger numerical ranges from dominating the search process, a normalization procedure is applied. This is performed after loading the CSV data to rescale all input variables into a common range, typically [0, 1]. Also, this procedure improves the performance and convergence speed of optimization algorithms such as BO, PSO, and GA [15,16,17].

The data normalization procedure was implemented in Python using scikit-learn and joblib [18]. The script to normalize data in .py processes the gains and cost function to improve convergence stability across the optimization methods. The workflow includes the following steps:

• Gain Normalization. To ensure that each gain dimension contributes equally to the surrogate model, the matrix $X\in {\mathbb{R}}^{6400\times 2}$ (23) that has the controller gains $k_0$ and $k_1$ is rescaled to the unit hypercube ${[0,1]}^2$. This operation is performed by using the following transformation: $\tilde{X}={\displaystyle \frac{X-X_{min}}{X_{max}-X_{min}}},$ where $X_{min}$ and $X_{max}$ are vectors containing the minimum and maximum of each column, respectively.
• Cost Function Normalization. To prevent numerical scaling issues when fitting surrogate models or computing particle and genetic algorithm fitness scores, the scalar cost values $J\in {\mathbb{R}}^{6400}$ (22), which represent the aggregate steady-state tracking error per simulation, are normalized using the same approach as the following:

  $$\tilde{J}={\displaystyle \frac{J-min\left(J\right)}{max\left(J\right)-min\left(J\right)}}.$$

  (24)
• Persistence of Scaling Parameters. The fitted scalers (scaler_k.pkl and scaler_J.pkl) are saved to disk using joblib.dump. This allows the optimization .py files to apply the same transformation to new candidate gains during optimization and to inverse-transform normalized results back to the original gain space as follows: $X=scaler\_X.inverse\_transform\left(\tilde{X}\right),$$J=scaler\_J.inverse\_transform\left(\tilde{J}\right).$
• Verification. To confirm numerical consistency, after normalization and descaling, the .py file asserts the following: $\parallel X-X_{\mathrm{recovered}}{\parallel }_{\infty }<{10}^{-8},|J-J_{\mathrm{recovered}}|<{10}^{-8}.$

This normalization procedure ensures that BO, PSO, and GA algorithms operate in a uniform and reproducible numerical domain, thus improving convergence reliability. The normalized controller gains are represented as the vector

$$\tilde{\mathbf{k}}=[{\tilde{k}}_0,{\tilde{k}}_1]\in {[0,1]}^2,$$

(25)

where each component is obtained by applying the normalization transformation to the original gains $k_0$ and $k_1$ defined in (18).

Also, the normalized tracking errors are defined as

$${\tilde{Z}}_i(j,k)={\displaystyle \frac{Z_i(j,k)-min\left(Z_i\right)}{max\left(Z_i\right)-min\left(Z_i\right)}},i=1,2,$$

(26)

where $Z_i\in {\mathbb{R}}^{6400\times 5000}$ represents the original tracking errors for joint i, $min\left(Z_i\right)$ and $max\left(Z_i\right)$ are the global minimum and maximum over all elements of $Z_i$, with j indexing the simulation number (corresponding to a specific $(k_0,k_1)$ pair), and k indexing the discrete-time steps within the simulation. This normalization rescales the full time series data to the interval $[0,1]$, ensuring stability and comparability across evaluations.

The mapping of the gain vector (25) and the normalized matrices ${\tilde{Z}}_1$ and ${\tilde{Z}}_2$ (26) allows the optimization process to explore the search space consistently while maintaining the ability to recover the original gains and tracking errors using the inverse transformation. Consequently, the normalized parameters $\tilde{\mathbf{k}}$ and matrices ${\tilde{Z}}_1$ and ${\tilde{Z}}_2$ serve as the inputs for all subsequent optimization algorithms BO, PSO, and GA, and their optimal values can later be projected back to the control parameter space of the 2-DOF robotic manipulator represented in dicrete time (4).

2.7. Bayesian Optimization Algorithm

The BO branch constitutes a sequential search procedure for minimizing the combined tracking error of the neural discrete-time sliding mode controller applied to the 2-DOF robot manipulator. This procedure relies on a surrogate probabilistic model and iteratively refines the estimation of the optimal control gains $\{k_0,k_1\}$. The implementation leverages the scikit-optimize library in Python [19]. Each step of the workflow in the left part of Figure 1 is detailed as follows:

• Initialize Samples. The normalized input space $\mathcal{X}\subset {[0,1]}^2$ is defined as $\tilde{\mathbf{k}}=[{\tilde{k}}_0,{\tilde{k}}_1]$ (25), where scaling is performed to the complete dataset $\{(k_0,k_1)\in {[100,258]}^2\}$ (18) with a step of two. To cover the search space efficiently, initial samples are selected via Latin Hypercube Sampling [20].
• Fit Gaussian Process (GP) Surrogate Model. In this work, two independent Gaussian Process Regressors (GaussianProcessRegressor) are trained to model the normalized tracking errors $J_1$ and $J_2$, which are defined as follows:

  $$J_1=\mathrm{mean}\left({\mathrm{Z}}_1[t>4.9s]\right),J_2=\mathrm{mean}\left({\mathrm{Z}}_2[t>4.9s]\right),$$

  (27)

  where ${\mathrm{Z}}_i$ are vectors of length 5000 time steps per simulation. The kernel hyperparameters are optimized by maximizing the marginal likelihood, and the resulting models provide predictive means and variances.
  These outputs correspond to the normalized cost values ${\tilde{J}}_1$ and ${\tilde{J}}_2$ derived from the steady-state tracking errors described in (24) in Section 2.6.
• Maximize Acquisition Function. To select the next candidate, the expected improvement criterion $\alpha \left(\overline{x}\right)$ is optimized over the input space $\mathcal{X}$. The objective function for BO combines both tracking errors as follows:

  $$f\left(x\right)=0.5{\widehat{J}}_1\left(x\right)+0.5{\widehat{J}}_2\left(x\right),$$

  (28)

  where ${\widehat{J}}_i\left(x\right)$ denotes the GP prediction where the default optimizer in scikit-optimize is employed in the expected improvement maximization.
• Evaluate Objective. Now, using the surrogate models, the selected normalized gains are denormalized to the original scale of $\{k_0,k_1\}$ and evaluated by predicting $J_1$ and $J_2$ of (27). This denormalization process uses the inverse transformation $\mathbf{k}=scaler\_X.inverse\_transform\left(\tilde{\mathbf{k}}\right)$, where $\tilde{\mathbf{k}}={\left[{\tilde{k}}_0{\tilde{k}}_1\right]}^{\top }\in {[0,1]}^2$ are the normalized gain values for the original gains $k_0$ (14) and $k_1$ (10) obatained in Section 2.6.
• Update Dataset. After selecting a new gain configuration ${\tilde{\mathbf{k}}}^{\left(new\right)}$, the associated cost $J^{\left(new\right)}$ is computed either through the surrogate model or via a direct simulation. Then, following the evaluation of the new gain configuration, the resulting data point $\left({\tilde{\mathbf{k}}}^{\left(new\right)},J^{\left(new\right)}\right)$ is integrated into the training set. This updated dataset is used to retrain the Gaussian Process model, thereby enhancing its predictive performance across the cost landscape associated with the discrete-time sliding mode controller (8) that governs the motion of the 2-DOF planar robot in discrete time (4) via the recurrent high-order NN (6).
• Optimal Gains. At this point, until the improvement in the cost function falls below a threshold, the optimization loop is repeated for $N=50$ iterations. At the end of this process, the best performing normalized parameters ${\tilde{\mathbf{k}}}^{*}=[{\tilde{k}}_0^{*},{\tilde{k}}_1^{*}]$ are transformed back into the original gain space using the inverse normalization function. These Optimal Gains $\{k_0^{*},k_1^{*}\}$ correspond to the optimal tuning of the discrete-time sliding mode controller, minimizing the aggregate tracking error J (22) computed from the steady-state values of $Z_1\left(k\right)$ and $Z_2\left(k\right)$ of (7) (or in case $e_1\left(k\right)$ and $e_2\left(k\right)$ of (21)), the time-domain tracking errors for each joint.

2.8. Particle Swarm Optimization Algorithm

The PSO branch draws inspiration from the emergent collective behavior of biological swarms such as bird flocks or fish schools [21]. Within the goal of this project, PSO is applied as a population-based metaheuristic algorithm designed to minimize the aggregate tracking error J (22) of the neural discrete-time sliding mode controller (8) implemented on the 2-DOF robotic manipulator in discrete time (4).

The optimization presented in this work is carried out over the normalized gain space $\mathcal{X}\subset {[0,1]}^2$, where each particle in the swarm represents the normalized gains $\tilde{\mathbf{k}}=[{\tilde{k}}_0,{\tilde{k}}_1]$ (25). These gains, as candidate solutions, are mapped to the original controller parameters $\{k_0,k_1\}\in {[100,258]}^2$ (18) with a step of two by inverse normalization for performance evaluation using the NN tracking error metrics derived from $Z_1\left(k\right)$ and $Z_2\left(k\right)$, as defined in (7) (or the original tracking errors $e_1\left(k\right)$ and $e_2\left(k\right)$ of (21)). This is due to the recurrent high-order NN (5) reproducing the behavior of the 2-DOF robotic manipulator in discrete time (4).

The PSO optimization process follows the central workflow depicted in Figure 1 and is implemented using the scikit-optimize and pyswarm libraries. The algorithm simulates a swarm of particles moving in the gain space, each adjusting its velocity based on both its personal best performance and the best performance of the swarm as a whole. This collaborative mechanism allows the swarm to efficiently explore the cost landscape and converge to the global minimum.

The main steps of the PSO procedure are detailed below.

• Initialize Particle Swarm. To begin the optimization process, a swarm of $N_p=30$ particles is initialized within the normalized gain space $\mathcal{X}={[0,1]}^2$, as defined in Section 2.6. Each particle i is assigned an initial position vector $x_i^{\left(0\right)}\in \mathcal{X}$, representing a candidate normalized gain vector $\tilde{\mathbf{k}}=[{\tilde{k}}_0,{\tilde{k}}_1]$ (25) and an initial velocity vector $v_i^{\left(0\right)}\in {\mathbb{R}}^2$. The velocity components are randomly sampled from a uniform distribution in the interval $[-0.1,0.1]$, which allows for exploratory movement within the search space at the start of the algorithm.
• Evaluate Fitness. For each particle position $x_i\in \mathcal{X}={[0,1]}^2$, representing a candidate normalized gain vector ${\tilde{\mathbf{k}}}_i=[{\tilde{k}}_0^{\left(i\right)},{\tilde{k}}_1^{\left(i\right)}]$ as defined in (25), the fitness function is computed using the surrogate models. Specifically, the predicted tracking cost is calculated as

  $$f_{\mathrm{PSO}}\left(x_i\right)=0.5{\widehat{J}}_1\left(x_i\right)+0.5{\widehat{J}}_2\left(x_i\right),$$

  where ${\widehat{J}}_1\left(x_i\right)$ and ${\widehat{J}}_2\left(x_i\right)$ are the outputs of the Gaussian Process regressors trained on the normalized dataset, representing approximations of the normalized cost function (24) derived from normalized tracking error matrices ${\tilde{Z}}_1$ and ${\tilde{Z}}_2$ as defined in (26).
• Update Personal and Global Best. Each particle maintains its personal best position $p_i$, and the swarm identifies the global best position g based on the fitness function $f_{\mathrm{PSO}}\left(x_i\right)$ as follows:

  $$p_i^{(t+1)}=argmin\{f_{\mathrm{PSO}}\left(x_i^{\left(t\right)}\right),f_{\mathrm{PSO}}\left(p_i^{\left(t\right)}\right)\},g^{(t+1)}=arg\underset{i}{min}{f}_{\mathrm{PSO}}\left(p_i^{(t+1)}\right)$$

  (29)
  The fitness function is evaluated using the surrogate-based approximation defined in (28). Note: Although Equation (28) was originally introduced in the context BO, it remains valid for the PSO procedure, since the same Gaussian Process surrogate models are used to estimate the normalized tracking errors ${\widehat{J}}_1\left(x\right)$ and ${\widehat{J}}_2\left(x\right)$ based on the steady-state values derived from ${\tilde{Z}}_1$ and ${\tilde{Z}}_2$ (26) as described in Section 2.6.
• Update Positions. Each particle updates its velocity and moves to a new location in the normalized gain space $\mathcal{X}\subset {[0,1]}^2$. First, the velocity is updated according to the standard PSO update rule: $v_i^{(t+1)}=\omega v_i^{\left(t\right)}+c_1{r}_1(p_i^{\left(t\right)}-x_i^{\left(t\right)})+c_2{r}_2(g^{\left(t\right)}-x_i^{\left(t\right)}),$ where $\omega =0.5$ is the inertia weight that controls the influence of the previous velocity; $c_1=c_2=1.5$ are the cognitive and social acceleration coefficients; $r_1,r_2\sim U[0,1]$ are vectors of uniformly distributed random numbers that introduce stochasticity in exploration. Then, the particle’s position is updated as $x_i^{(t+1)}=x_i^{\left(t\right)}+v_i^{(t+1)}$ and clipped to remain within the bounds of the normalized domain: $x_i^{(t+1)}=min\left(max(x_i^{(t+1)},0),1\right).$
  This ensures that each particle remains within the feasible search region for the normalized gains $\tilde{\mathbf{k}}=[{\tilde{k}}_0,{\tilde{k}}_1]$ (25).
• Termination Criterion. The PSO algorithm proceeds iteratively until one of the following stopping conditions is met:

  –

  the number of iterations reaches a predefined maximum of $T^{\prime }=50$, or

  –

  the absolute improvement in the global best fitness value $f_{\mathrm{PSO}}\left(g^{\left(t\right)}\right)$ over consecutive iterations is smaller than a convergence threshold $ϵ={10}^{-6}$.

  This condition is checked at each iteration. If satisfied (Yes), the loop terminates and proceeds to the final block (Optimal Gains). Otherwise (No), the algorithm returns to the Evaluate Fitness step to continue refining the swarm’s exploration of the normalized gain space $\mathcal{X}={[0,1]}^2$.
  This convergence behavior ensures that the PSO process balances global exploration and local refinement while searching for the optimal normalized gains ${\tilde{\mathbf{k}}}^{*}=[{\tilde{k}}_0^{*},{\tilde{k}}_1^{*}]$, which can then be inverse-transformed to obtain the corresponding gains $\{k_0^{*},k_1^{*}\}$ for the controller.
• Optimal Gains $\{k_0^{*},k_1^{*}\}$. Once the termination criterion is satisfied, the global best particle position $g^{*}\in {[0,1]}^2$ is selected as the optimal solution in the normalized space. To recover the corresponding control gains for the discrete-time sliding mode controller, the inverse normalization transformation is applied using the scaler saved in Section 2.6: $[k_0^{*},k_1^{*}]=scaler\_X.inverse\_transform\left(g^{*}\right).$
  These gains represent the optimal tuning configuration that minimizes the aggregate tracking error defined by the surrogate-based fitness function $f_{\mathrm{PSO}}\left(x\right)$, which itself is derived from the normalized steady-state tracking errors ${\tilde{Z}}_1$ and ${\tilde{Z}}_2$ described in (26).
  The resulting Optimal gains $\{k_0^{*},k_1^{*}\}$ are the values alongside their corresponding cost J computed from the original tracking error matrices. This optimal pair can now be implemented in the neural discrete-time sliding mode controller (8) to achieve improved performance in joint trajectory tracking for the 2-DOF planar robot in discrete time (4).

2.9. Genetic Algorithm Optimization

The GA branch employs a population-based evolutionary method to minimize the overall steady-state tracking error of the neural discrete-time sliding mode controller for the 2-DOF planar robot. This is illustrated in the rightmost branch of the workflow in Figure 1 and is implemented using the DEAP [22] and scikit-optimize [23] libraries. The optimization operates within the normalized gain space $\mathcal{X}={[0,1]}^2$, where each candidate solution represents a gain vector $\tilde{\mathbf{k}}=[{\tilde{k}}_0,{\tilde{k}}_1]$, as defined in (25). These are obtained by scaling the original gain set $\{k_0,k_1\}\in {[100,258]}^2$ (see (18)), as discussed in Section 2.6.

The GA procedure comprises the following stages:

• Initialize Population. A starting population of $N_{\mathrm{pop}}=50$ individuals is generated by random sampling from the normalized domain $\mathcal{X}$. Each individual $x_j^{\left(0\right)}=[{\tilde{k}}_0^{\left(j\right)},{\tilde{k}}_1^{\left(j\right)}]\in {[0,1]}^2$ represents a potential controller gain vector. Uniform initialization is applied to guarantee broad exploration of the search space and maintain genetic diversity for the evolutionary algorithm.
• Evaluate Fitness. Each individual’s fitness is assessed through the Gaussian Process (GP) surrogate model. The fitness function combines predicted normalized tracking costs as

  $$f_{\mathrm{GA}}\left(x_j\right)=0.5{\widehat{J}}_1\left(x_j\right)+0.5{\widehat{J}}_2\left(x_j\right),$$

  (30)

  where ${\widehat{J}}_1\left(x_j\right)$ and ${\widehat{J}}_2\left(x_j\right)$ are predictions from GP models trained on the normalized error matrices ${\tilde{Z}}_1$ and ${\tilde{Z}}_2$ (see (26)). This cost function aligns with (28) from the Bayesian Optimization framework and remains applicable here, as identical surrogate models are employed.
• Select Parents. A tournament selection mechanism is used with a tournament size of $k_{tourn}=3$. In this process, random groups of individuals are created from the population, and the highest-fitness candidate from each group is chosen for reproduction. This approach maintains an effective equilibrium between selecting high-performing solutions and sustaining population diversity.
• Crossover and Mutation. The next generation is produced through the following:

  –

  Crossover. Simulated Binary Crossover (SBX) [24,25] is performed with crossover probability $p_c=0.9$. For parent solutions, offspring are generated via

  $$x_{\mathrm{child}}=\mathrm{SBX}(x_{\mathrm{parent}1},x_{\mathrm{parent}2},{\eta }_c),$$

  where the distribution index ${\eta }_c=15$ determines offspring diversity.

  –

  Mutation. Polynomial mutation operates with probability $p_m=0.1$, adding controlled random variations:

  $$x_j^{\prime }=x_j+\delta ,\delta \sim \mathrm{Polynomial}({\eta }_m=20),$$

  (31)

  with solutions constrained to the normalized space ${[0,1]}^2$.

• Termination Criterion. The optimization runs for up to $G=50$ generations or stops earlier if the relative improvement in the best fitness value drops below $ϵ={10}^{-6}$. Each iteration checks the stopping condition: if it is not satisfied (No), the process returns to the fitness evaluation; if satisfied (Yes), the algorithm ends and proceeds to the Optimal Gains block.
• Optimal Gains $\{k_0^{*},k_1^{*}\}$. Upon convergence, the optimal normalized solution $x^{*}=[{\tilde{k}}_0^{*},{\tilde{k}}_1^{*}]$ is identified. The actual controller gains are obtained by reversing the normalization:

  $$[k_0^{*},k_1^{*}]=scaler\_X.inverse\_transform\left(x^{*}\right),$$

  producing the final control parameters. These optimized gains minimize the surrogate-based cost function $f_{\mathrm{GA}}\left(x\right)$ that represents the robot joints’ steady-state tracking errors.

3. Results

To enhance the transparency of the optimization process, progression plots are provided for each algorithm: BO (Figure 2), PSO (Figure 3), and GA (Figure 4). Each figure is arranged as a 2 × 3 grid: the top row shows Joint 1 and the bottom row Joint 2; the columns correspond to early, mid, and final stages of the search. In every panel, the black curve is the reference, the blue curve is the estimated position $x_j\left(k\right)$, and the red curve (right axis) is the estimation error $e_j\left(k\right)$. These signals are reconstructed directly from the dataset using $x_j\left(k\right)={\mathrm{ref}}_j+z_j\left(k\right)$ and $e_j\left(k\right)=z_j\left(k\right)$. When available, the three milestones are taken from the optimization logs at iterations 1, 25, and 50; otherwise, a representative early/mid/final triplet is selected by sorting the per-simulation cost $J=\mathrm{mean}\left(\right|z_1\left(k\right)\left|\right)+\mathrm{mean}\left(\right|z_2\left(k\right)\left|\right)$ and picking worst/median/best. This presentation complements the convergence summary (Figure 5) by showing how tracking quality improves over time in each method.

3.1. Dataset Neural Sliding Mode Control Simulation

As a result of the script and for the dataset obtained in Section 2.4, Figure 6 and Figure 7 show simulation comparisons for all tracking performance of the proposed control scheme for the 2-DOF planar robotic manipulator for Joints 1 and 2. Each figure displays the reference signal (in black), the real joint position (in red), and the estimated position provided by recurrent high-order NN (in blue) for all simulations with the 6400 different controller gain values $k_0$ and $k_1$ (18).

In Figure 6, the measured position $q_1\left(k\right)$ and the estimated state $x_1\left(k\right)$ closely follow reference ${\mathrm{ref}}_1\left(k\right)$ over the full 5 s simulation. The red and blue semi-transparent traces correspond to $6400$ simulations with different controller gains, allowing visual assessment of variability; the narrow dispersion indicates consistent tracking. The inset zoom emphasizes the initial transient. These results also show that the recurrent high-order NN accurately estimates the robot state, as $x_1\left(k\right)$ matches $q_1\left(k\right)$ with high fidelity.

Figure 7 shows analogous results for Joint 2. After a short transient, both $q_2\left(k\right)$ and $x_2\left(k\right)$ align with ${\mathrm{ref}}_2\left(k\right)$, demonstrating robust tracking over the full sweep of gains. The agreement between $x_2\left(k\right)$ and $q_2\left(k\right)$ further validates the effectiveness of the neural estimator. To explicitly illustrate optimization progress (beyond aggregate tracking), it includes per-algorithm progression plots (early/mid/final milestones taken from iterations 1, 25, and 50 or a worst/median/best fallback), see Figure 2, Figure 3 and Figure 4, and the convergence of the objective value over iterations/generations in Figure 5. These plots complement Figure 6 and Figure 7 by showing how performance improves as each method converges.

Table 1. Mean values of the state estimation errors (MAE as the primary clarity metric).

Estimation Error	MAE	Mean Error	RMSE
$e_1\left(k\right)=q_1\left(k\right)-x_1\left(k\right)$ rad	0.00263	$2.56\times {10}^{-4}$	0.0030561
$e_2\left(k\right)=q_2\left(k\right)-x_2\left(k\right)$ rad	0.004083	$3.45\times {10}^{-5}$	0.004558
$e_3\left(k\right)=q_3\left(k\right)-x_3\left(k\right)$ rad/s	0.067850	$7.39\times {10}^{-4}$	0.081822
$e_4\left(k\right)=q_4\left(k\right)-x_4\left(k\right)$ rad/s	0.445721	$2.91\times {10}^{-3}$	0.5002100

reports the mean values of the state estimation errors for clarity. MAE (mean absolute error) is used as the primary metric and also the mean error (bias) and RMSE (root mean squared error) are reported. For the joint positions, $\mathrm{MAE}=2.63\times {10}^{-3}$ rad and $4.083\times {10}^{-3}$ rad for $e_1\left(k\right)$ and $e_2\left(k\right)$, respectively, are obtained with very small mean errors ($2.56\times {10}^{-4}$ rad and $3.45\times {10}^{-5}$ rad), indicating negligible bias. The corresponding RMSE values ($3.056\times {10}^{-3}$ rad and $4.558\times {10}^{-3}$ rad) are close to the MAE, suggesting the absence of large outliers in the position estimates. For the joint velocities, the MAE is $6.785\times {10}^{-2}$ rad/s for $e_3\left(k\right)$ and $4.457\times {10}^{-1}$ rad/s for $e_4\left(k\right)$, with mean errors $7.39\times {10}^{-4}$ rad/s and $2.91\times {10}^{-3}$ rad/s, respectively. The larger gap between RMSE and MAE for $e_4\left(k\right)$ ($0.500$ vs. $0.446$ rad/s) points to sporadic higher deviations in the velocity estimate of Joint 2. Table 1 complements Figure 6 and Figure 7 and clearly demonstrates the accuracy of the state estimation algorithm.

3.2. Optimal Control Gains for BO, PSO, and GA

Table 2. Optimal gains and average steady-state tracking errors.

Algorithm	${\mathit{k}}_0^{*}$	${\mathit{k}}_1^{*}$	${\overline{\mathit{e}}}_1$ (Joint 1) rad	${\overline{\mathit{e}}}_2$ (Joint 2) rad
BO	106.863	194.327	$7.814\times {10}^{-5}$	$8.392\times {10}^{-3}$
PSO	106.8747	194.542.0	$7.363\times {10}^{-5}$	$8.96\times {10}^{-3}$
GA	106.4461	195.01	$1.225\times {10}^{-4}$	$8.175\times {10}^{-3}$

,

Table 3. Computational time per process.

Process	Time (s)
Load Data	22.3841
Normalization	0.0526
Training DOF1	7.4854
Training DOF2	7.2542
Bayesian Optimization	23.6546
PSO Optimization	23.443
GA Optimization	61.9840
GA Refinement	7.702

,

Table 4. Number of evaluations per algorithm.

Algorithm	Evaluations
Bayesian Optimization	50
Particle Swarm Optimization	1500
Genetic Algorithms	7500

and

Table 5. Model precision (R²).

Model	R2
DOF1	0.0336
DOF2	0.0084

summarize the performance of the optimization algorithms applied to the tuning of the neural discrete-time sliding mode controller gains for the robot manipulator.

Table 2 and Table 3 jointly summarize accuracy and efficiency under an identical pipeline (shared data loading/normalization and a single Python implementation). The optimal gains concentrate in a narrow region ($k_0^{*}\approx 106$, $k_1^{*}\in [194,195]$), and the average steady-state errors ${\overline{e}}_1,{\overline{e}}_2$ are computed over the final 0.1 s ($t>4.9$ s). Quantitatively, PSO attains the lowest error in Joint 1 ($7.36\times {10}^{-5}$ rad), GA the lowest in Joint 2 ($8.18\times {10}^{-3}$ rad), and BO remains competitive in both ($7.81\times {10}^{-5}$ rad; $8.39\times {10}^{-3}$ rad) while using only 50 evaluations. In terms of time, PSO is the fastest (23.44 s), BO is similar (23.65 s), and GA is costlier (61.98 + 7.70 s refinement $\approx 69.7$ s), consistent with its larger evaluation budget.

Table 4 shows that the GA requires the highest number of function evaluations (7500), significantly more than PSO with 1500 and BO with only 50. This extensive sampling by GA likely contributes to its ability to find a more refined solution, as reported in Table 2, but comes at the cost of considerably increased computational time.

Table 5 presents the predictive accuracy of the Gaussian Process surrogate models used in the optimization, reported through the coefficient of determination $R^2$. The low $R^2$ values for both joints (0.0336 for DOF1 and 0.0084 for DOF2) indicate that the surrogate models provide only coarse approximations of the true cost landscape. As such, while they offer a useful heuristic for guiding the search process, direct simulation evaluations remain essential to ensure accurate assessment of candidate solutions.

Figure 5 illustrates the convergence behavior of the three optimization algorithms over 50 iterations or generations. The BO trajectory shows significant oscillations, reflecting its probabilistic sampling strategy and active exploration of the gain space. In contrast, both PSO and GA exhibit rapid convergence within the first few iterations, stabilizing early in low-error regions. For PSO and GA, the plot displays the best normalized cost value found at each generation, highlighting their exploitation-driven search dynamics. The dashed horizontal line representing PSO marks the lowest final cost among the three methods, consistent with the results reported in Table 2. These convergence profiles illustrate the distinct exploration–exploitation balances intrinsic to each optimization strategy. For clarity, Figure 5 plots the normalized objective $\tilde{J}$ (built from the steady-state tracking-error cost defined in Section 2.6; lower is better). Each curve reports the best-so-far value ${min}_{t^{\prime }\le t}\tilde{J}\left({\mathbf{k}}^{\left(t^{\prime }\right)}\right)$ as a function of iteration/generation t, and all methods are run with an equal budget of 50 iterations/generations. The y-axis is unitless due to normalization to $[0,1]$, and the x-axis counts iterations (BO) or generations (PSO/GA).

The early stagnation of the PSO curve suggests that the swarm quickly located a promising region in the search space and collectively converged without further significant improvement, possibly due to limited diversity or suboptimal balance in its exploration parameters. On the other hand, the persistent oscillations in the BO curve indicate that the acquisition function continues to propose exploratory samples far from previously evaluated regions. This reflects the BO strategy’s emphasis on global search, even after identifying near-optimal regions, which may delay convergence but can help avoid premature local optima. Such behavior highlights that while BO may take longer to settle, it remains valuable in problems where the cost landscape is highly multimodal or where evaluations are costly and limited in number.

Overall, the results demonstrate that all three optimization strategies effectively identify high-performance gain configurations. BO offers a favorable trade-off between tracking performance and computational efficiency, whereas the GA achieves the lowest tracking cost at the expense of significantly higher computational effort and number of evaluations.

Figure 8 shows the torques produced over a 5 s simulation with $T=1$ ms. Dashed horizontal lines indicate actuator limits: $\pm 80$ N$·$m for Joint 1 and $\pm 20$ N$·$m for Joint 2. Both ${\tau }_1\left(k\right)$ and ${\tau }_2\left(k\right)$ remain within their bounds, exhibiting the expected behavior of SMC while satisfying the torque requirements stated in Section 2.3. The apparent saturation in the control signals is an intended consequence of the control law in (8). Whenever $|U_{\mathrm{eq},i}\left(k\right)|>{\mathrm{sat}}_i$, the second branch is activated and the commanded torque is clipped to $\pm {\mathrm{sat}}_i$ with the sign of $U_{\mathrm{eq},i}\left(k\right)$. This explains the plateaus at $\pm 80$ N$·$m (Joint 1) and $\pm 20$ N$·$m (Joint 2), ensures compliance with actuator limits, and produces the characteristic behavior typical of SMC.

4. Discussion

The results presented in Section 3 confirm the effectiveness of the proposed AI-based optimization framework for tuning the gains of a neural discrete-time sliding mode controller applied to a 2-DOF robotic manipulator. However, several additional aspects merit discussion to contextualize the contributions and limitations of this work.

First, while this study focused on three popular metaheuristic algorithms—Bayesian Optimization (BO), Particle Swarm Optimization (PSO), and Genetic Algorithms (GAs)—it is important to note that other AI-driven and classical optimization techniques are available. Alternatives such as Differential Evolution, Ant Colony Optimization, Reinforcement Learning-based controllers, or even gradient-based deterministic methods (e.g., Sequential Quadratic Programming) could also be explored. Each approach brings trade-offs in terms of convergence rate, robustness, and computational demand, which may prove beneficial in different application scenarios.

Second, the optimization objective in this study targeted the minimization of the steady-state tracking error, as defined by the cost function in (22). While this metric is fundamental for ensuring accurate long-term tracking, it does not explicitly account for transient dynamics such as overshoot, settling time, or control energy expenditure.

Third, the simulation data used for training the surrogate models and evaluating the controller was generated through a systematic sweep of normalized gain values. Despite the limited size of the dataset (on the order of hundreds of samples), the convergence of BO, PSO, and GA to similar optimal regions indicates that the data were sufficiently informative to guide the optimization processes. This also highlights the advantage of working in a normalized gain space, which allowed the models to generalize well across the explored domain.

It is also worth noting that the surrogate models used in BO and PSO approximated the cost landscape with relatively low precision (as reflected by the $R^2$ scores in Table 5). Nevertheless, the optimization routines remained effective due to the reinforcement provided by direct simulation evaluations. This suggests that even modest-quality models can support efficient gain tuning when combined with simulation-based corrections.

Finally, although the neural plant model employed an EKF for online adaptation of covariance matrices, future research could investigate other adaptive training mechanisms such as recursive least squares, ensemble learning, or deep learning-based dynamics estimators. Incorporating uncertainty quantification into the plant model could further improve the robustness of the control strategy in real-world settings.

In summary, the methodology proposed in this study establishes a solid foundation for AI-based controller optimization. It remains extensible to other objective functions, optimization techniques, and controller architectures, thereby offering a flexible framework for advancing autonomous control of robotic systems.

Recent studies have explored data-driven or metaheuristic tuning of robust controllers in robotic applications. For instance, work [26] combines SMC with online BO for a bio-inspired underwater robot, showing marked improvements in depth and pitch regulation after roughly fifty online updates while maintaining Lyapunov-stable operation. In terrestrial settings, local BO with crash constraints has been proposed to tune controller parameters under hardware limits safely [27]. Within metaheuristics, work [28] integrates PSO with a modified power–rate SMC to mitigate chattering and simplify tuning on a multi-DOF manipulator with experimental validation; the authors in [29] compare several metaheuristics (DE, PSO, hybrids) for manipulator trajectory tracking using a multi-term objective (position/orientation/joint errors) and uniform iteration budgets; and in Keshti [30] employ GA to tune SMC gains for human-arm trajectory tracking, focusing on minimizing summary tracking error.

Compared with the above, we explicitly adopt a discrete-time SMC and a recurrent high-order neural network NN that reproduces the dynamics of the 2-DOF manipulator (serving as the predictive plant for indirect control). Within this discrete-time setting, we evaluate the same controller and dataset across BO, PSO, and GA, enabling a direct trade-off reading between accuracy and computation (Table 2 and Table 3). Table 2 shows that PSO attains the lowest steady-state error for Joint 1, while GA attains the lowest for Joint 2 (by a narrow margin), and BO is competitive in both joints. From Table 3, PSO achieves the shortest optimization time among the three, BO is similar, and GA is noticeably more expensive—consistent with prior reports that PSO offers fast convergence for nonlinear objectives [28] and that BO is attractive for sample-efficient tuning [26,27]. Together with the progression plots and convergence curves, these results contextualize our contribution: a reproducible, apples-to-apples benchmark of discrete-time SMC gain tuning with a recurrent high order NN-based plant model for a 2-DOF robot, revealing that PSO is an excellent first choice when compute is tight, BO is attractive when safe, sample-efficient exploration is needed, and GA can yield competitive accuracy at higher computational cost.

Table 6. Comparison with related works on data-driven/metaheuristic controller tuning.

Application/Plant	Method (Tuning/Goal)	Reported Outcome/Notes
Bio-inspired marine robot [26]	SMC with online Bayesian Optimization (update sliding surface)	Significant improvement in depth/pitch regulation after ∼56 online updates with Lyapunov-stable tuning; safe real-time exploration.
Real systems (controller tuning with safety) [27]	Local Bayesian Optimization with crash constraints	Formulation and demos emphasizing safe, sample-efficient parameter search under hardware limits.
Robotic manipulator (4-DOF) [28]	PSO-tuned modified power-rate SMC (chattering mitigation)	Experimental validation; PSO adopted to simplify tuning of nonlinear objective and improve tracking robustness.
Manipulator path tracking [29]	Comparative metaheuristics (DE, PSO, hybrids) minimizing weighted position/orientation/joint errors	Uniform settings (e.g., population and iterations); methodology generalizable across DOFs and objectives.
Human-arm (3-link) model [30]	GA-tuned SMC (minimize sum of tracking errors)	Simulation study; GA set gains to track prescribed human-arm trajectories.
2-DOF manipulator (discrete-time SMC with NN model). This study	Unified normalized benchmark of BO/PSO/GA for gain tuning	Table 2: PSO best ${\overline{e}}_1$, GA best ${\overline{e}}_2$ (close margins); Table 3: PSO fastest, BO similar, GA slower. Convergence/progression figures corroborate trends.

shows the mentioned comparison.

Following industry practice, steady state is declared once the trajectory enters and remains within a tolerance band for a dwell time. In accordance with ISO 9283 [31] “position stabilization time,” the band can be tied to robot repeatability or set as a percentage band (e.g., $\pm 2\%$), and the dwell time ensures persistence inside the band. In our experiments (sampling at 1 kHz), we adopt a 0.1 s dwell (100 samples) once the band is entered, and compute steady-state errors over that dwell segment. This aligns with the classical settling-time definition based on tolerance bands used in control theory [32].

5. Conclusions

This work presented a comprehensive AI-based optimization framework for tuning the gains of a neural discrete-time sliding mode controller applied to a two-degree-of-freedom robotic manipulator. The controller was indirectly implemented through a neural network trained with an EKF, allowing the estimation of the plant dynamics and facilitating robust control under model uncertainties.

Three optimization strategies—Bayesian Optimization (BO), Particle Swarm Optimization (PSO), and Genetic Algorithms (GAs)—were evaluated using a normalized parameter space and surrogate modeling based on Gaussian Processes. The optimization process was driven by the minimization of normalized steady-state tracking errors for both joints of the robot. The normalization framework enabled a unified treatment of the gain space and tracking error costs, improving convergence efficiency and reproducibility.

The results demonstrated that all three metaheuristics successfully identified high-performance gain configurations. GAs achieved the lowest tracking cost but at the expense of a significantly higher number of evaluations and computation time. BO and PSO yielded nearly identical results with much lower computational effort. These findings highlight that the proposed methodology provides a flexible and efficient solution for automatic controller tuning, especially in scenarios where analytical models are unavailable or costly to evaluate.

Future work will explore real-time adaptation of controller gains using online learning techniques and extend the optimization framework to multi-objective formulations involving control effort, energy consumption, and robustness metrics.