Artificial Neuron-Based Model for a Hybrid Real-Time System: Induction Motor Case Study

Abstract

Automatic Machine Learning (AML) methods are currently considered of great interest for use in the development of cyber-physical systems. However, in practice, they present serious application problems with respect to fitness computation, overfitting, lack of scalability, and the need for an enormous amount of time for the computation of neural network hyperparameters. In this work, we have experimentally investigated the impact of continuous updating and validation of the hyperparameters, on the performance of a cyber-physical model, with four estimators based on feedforward and narx ANNs, all with the gradient descent-based optimization technique. The main objective is to demonstrate that the optimized values of the hyperparameters can be validated by simulation with MATLAB/Simulink following a mixed approach based on interleaving the updates of their values with a classical training of the ANNs without affecting their efficiency and automaticity of the proposed method. For the two relevant variables of an Induction Motor (IM), two sets of estimators have been trained from the input current and voltage data. In contrast, the training data for the speed and output electromagnetic torque of the IM have been established with the help of a new Simulink model developed entirely. The results have demonstrated the effectiveness of ANN estimators obtained with the Deep Learning Toolbox (DLT) that we used to transform the trained ANNs into blocks that can be directly used in cyber-physical models designed with Simulink.

1. Introduction

IoT is highlighting the huge current interest in the development of autonomous driving to organize traffic in future smart cities. In this context, automated machine learning (AML) methods [1,2] are useful to apply machine learning end-to-end to find a consistent implementation of electric vehicles (EVs) [3] and other cyber-physical systems (CPS) [4,5,6,7]. However, they present serious application problems regarding fitness calculation, overfitting, lack of scalability, and need a huge amount of time to compute hyperparameters on which CPS are dependable. The problem is worsened if we choose an artificial neural network (ANN), and to calculate the hyperparameters [8], we follow an optimization method such as gradient descent [9,10].

Therefore, we propose in this paper to complement the computationally expensive training phase of ANNs with hyperparameter updates carried out manually, as in [11], with the help of efficient cyber-physical models’ simulation tools.

The optimization algorithm normally used to train ANNs for industrial control is called gradient descent [12]. The optimization computation based on gradient descent acts as a measurement device to gauge the accuracy of the cost function calculation, which each step or iteration of the ANN parameters updates. Following this approach, evaluations of the target function results in a hyper-gradient vector, i.e., one which learns various optimized parameters to combine different levels of adaptations [13], instead of single values that are usually obtained by other methods such as the called Bayesian hyperparameter optimization (HPO) [14].

Using HPO, when the number of derivatives is large, e.g., for a deep-learning ANN with n layers, the gradient will increase exponentially by backpropagation until it finally explodes. We can overcome the complexity of gradient descent and backpropagation applied to CPS hyperparameters optimization by model transformation, such as the distributed optimal coordination (DOC) approach for heterogeneous linear multi-agent systems proposed in [15].

Nowadays, we can obtain the model selection gradient in a reasonable time thanks to modern parallel computers and GPU graphics cards, which are crucial to tuning hyperparameters of cyber-physical models [8]. Thanks to parallel computing recent advances, we can now handle many hyperparameters of a model by deploying gradient descent-based methods efficiently [9]; more specifically, our method for ANN applied to high-dimensional HPO problems can perform the following tasks:

• Separately optimize the learning rate of an ANN for each iteration and layer;
• Calculate optimal weights for the synaptic connections between neurons of different layers in the ANN;
• Reduce the likelihood of overfitting by L2 regularization, a strategy that establishes the decay of peaky weights for each individual parameter.

Therefore, it is possible to perform the complete training procedure of an optimized cyber-physical model with an ANN, either by adaptive and offline updating of the hyperparameters: through measurements on a model of the studied CPS or after performing, interspersed with the training of the network, a manual validation from a software simulation of the cyber-physical model. This second alternative is the one we have finally adopted here.

This method is very model-specific but, in return, allows tuning of many hyperparameters of the cyber-physical model, which lays the ground for obtaining a great improvement with respect to the HPO performed so far in other papers [8,14,16], e.g., by Bayesian optimization.

Overfitting is an open problem when we try to apply ANN with a finite validation set, and the calculation of the model’s hyperparameters suffers from this drawback. One possibility would be to use a different shuffling for each function we need to evaluate thus reducing the amount of overfitting. This approach has been shown to improve the generalization accuracy and recall by deploying a cross-validation strategy of the cyber-physical models. We can also use the strategy of finding stable optima instead only optima in the objective function, as noted in [16].

There are currently many machine learning problems that cannot be solved directly due to the magnitude of their scale. We will understand the term scale, in this context, as the size of the configuration space and the high computational cost of carrying out the individual evaluations of the models involved. There are currently some successes in training the neural network with small datasets and setting hyperparameter values by hand during model training [10,17]. Our approach with respect to coping with the scalability problem is to take advantage of massive parallel computing and try to fully exploit large-scale computer clusters or the thousands of SMs of GPU/CUDA multiprocessors.

In hybrid systems, the continuous behavior described by a system of differential equations associated must change as a result of the occurrence of discrete events too. Our approach gives very compact and flexible specifications for complex hybrid systems. However, there are very few tools that support this class of tools now. In our case, we hypothesize that there is no major problem in building a trained ANN, which can substitute the PID [18,19] controller of a closed loop control system, capable of reacting and producing a correct response even in the case of discrete events, i.e., messages or signals that may modify the values of the cyber-physical model’s hyperparameters.

For implementation, CPS usually resorts to excellent tools such as MATLAB/Simulink © that are widely used in industry today to successfully complement machine learning methods mentioned above in IoT or Big Data applications. Currently, the use of tools that speed up the determination of the hyperparameters of ANNs is being considered a firm basis for the development of AML methods in an industrial environment and could certainly be considered a sound and less complex alternative to the development of new algorithms by only using metaheuristics that present a high complexity both in their design and in the execution time they need.

In this work, through a case study design, two research questions are answered: (1) whether an ANN model could be used to replace a PID controller for open and closed loop control systems, and (2) whether this model could be generated in a short time. To obtain the objectives, two ANN models (ff and narx) are used to generate four estimators of 2 physical variables (speed and torque) of an AC motor. Hyperparameter optimization is used with the approximate gradient method from the literature [8], which makes the gradient descent process much faster.

1.1. Real-Time Speed Regulation of an Induction Motor

As a case study, an induction motor (IM) has been modeled and controlled using simulation data and neural networks as an application of the proposed method for derivation of control applications with hybrid systems with real-time characteristics.

We can control the IM rotation speed by an open loop control system with real-time requirements, Figure 1a. The IM rotor speed is controlled by cutting the sine wave of the input voltage using a TriaC device, Figure 1b, whose operation is like a very fast switch. The control line of the TriaC is commanded by a synchronization signal (synch). This signal is high when the input wave passes through a zero value, resulting in the TriaC immediately stopping conducting electricity. If, after stopping conducting, the TriaC is fed with a current for several milliseconds, it will go to the saturation state by the texct signal. It will drive current until the input voltage passes through a zero value again. The maximum time (timeval) to re-excitation of the TriaC device must be calculated in real-time and at each cycle of the voltage with which it is fed. If after passing a full cycle of the input voltage, the signal synch is lost, i.e., the texct signal fails, then the synchf failure signal goes high to prevent the motor may rotate too fast. The combination of both devices, an IM and the TriaC, can serve as the basis of an industrial prototype to control or keep constant the speed of a vehicle in an automatic driving system or to maintain a constant airflow through a filter in HVAC systems, etc.

To solve such a problem that often occurs in the manufacturing industry, we can produce a closed loop feedback system with real-time requirements by implementing a PID, necessary to maintain constant the rotor speed of an induction motor driven by a TriaC device, Figure 2a. A Simulink block can be used to implement a hybrid system that also contains discrete components, such as the TriaC driver component shown in Figure 2b.

The proposal of this paper applies, according to the approach we will detail, to the implementation of an ANN-based controller instead of a PID-based one. The case study shows how the proposed method can be applied to derive ANN estimators of rotor speed and torque of an IM that provide improved control performance of this system. We have performed a double validation of the response of the developed ANN-based estimators for speed and electromagnetic torque, considering a time interval of 50 s. of the training time. Deep Learning Toolbox (DLT) is used to transform the trained ANNs into blocks that can be directly used in cyber-physical models designed with Simulink. We can observe that the measured and estimated speed and electromagnetic motor torque have a very close trajectory in the graphs shown (performance, error histogram), as well as we can also verify that the regression study yields a good accuracy for the mentioned both engine variables estimated in the study.

1.2. Article Structure

The following sections are structured as described below. First, we present the mathematical modeling of the induction motor. In Section 3, we describe our proposed modeling approach for the design of a class of CPS, i.e., hybrid real-time systems with continuous and discrete components. We algorithmically define a new method to deploy the model, such as closed-loop control of the IM case study based on neural networks, in which we define training, testing, and validation. A reference Simulink model of the IM is used, which provides insight into the functional and dynamic aspects and the necessary training data for the ANN-based controller models proposed in this paper. In Section 4, two motor speed and torque estimators are obtained, each with two classes of ANNs (ff and narx), which are applied to solve a problem consisting of reliably maintaining a constant speed and electromagnetic torque of the IM of the case study. Conclusions and current lines of work are presented in the last section.

2. Induction Motor Modeling

The simulation of the induction motor (IM) in Simulink, which has been used as a case study here, can be downloaded at the address https://lsi2.ugr.es/~mcapel/miscelanea/motor/ (accessed on 20 May 2022) (see Supplementary Materials). The prototype code has been structured in three separate blocks, corresponding to the transformation between the reference system of magnetic fluxes, currents, and voltages in the motor, resolution of the simulation, and return to the standard three-phase reference system, as shown in Figure 3a.

2.1. Physical Modeling of an Induction Motor

The most difficult component to model an induction motor (IM) is the IM drive itself, as specialized Simulink blocks that include differentiation operators are needed or need to be developed manually, as shown in Section 2.3. The other devices in the IM model can be modeled by means of simple switches or a combination of them.

An IM works according to the physical principle of mutual induction between electrical circuits traversed by a varying magnetic flux. Applying Faraday’s law, which is given by the following equation, where N is the number of turns of wire and Φ_B is the magnetic flux through a single loop, we can obtain the relation between electromagnetic force ($\epsilon$) and the change of magnetic flux Φ_B through the winding of a motor as follows,

$$\epsilon =-\frac{d}{dt}\left(N·{\mathsf{\Phi }}_B\right),$$

(1)

$i_{reel}$ conducted by the stator circuit, i.e., it turns out to be independent, for example, on the number of poles of the motor. Therefore, we will assign a self-induction constant L to any circuit affected by magnetic induction, according to the following equation,

$$N·{\Phi }_B=L·i_{reel}$$

(2)

To obtain a rotating magnetic field $\overrightarrow{B}$ (or B) in the stator of an IM, as shown in Figure 3a, three windings are necessary for the stator nucleus, each of which conducts current with a voltage phase difference of 2π/3 rad. from the next. An important parameter of induction motors and thus necessary for our target model to learn is what we call the synchronous speed ω_e of the motor, which is the rotational speed of the magnetic field B produced by the triple winding of the stator.

A three phases model of a dynamic IM can be found by assuming balanced voltages (in the phase of 2π/3 rad) and constant inductances. Under these conditions, the magnetic field vector B in the stator describes a circle in the plane with speed ω_e. A mathematical model with a rotating vector B identical to the above can be obtained with single current i instead of using three sinusoidal currents in phase. This model would only define one coil rotating at the same speed as vector B (Figure 3b) and conducting a direct current (DC). The problem is that with this model, the inductances’ mutual couplings between the three stator windings would not be considered. Therefore, a minimum of 2 coils are needed to obtain a dynamic model of the IM, as Figure 4 shows.

Complex vector space can be represented using a reference frame of only two orthogonal axes, according to the two-axis theory [20], so that in our study the motor model could be considered equivalent to a two-phase machine, which is a model that reduces the number of equations and greatly simplifies the control design of an IM.

2.1.1. Stationary Reference System (Alpha and Beta Coordinates)

In this case the motor is modeled by placing two coils forming an angle of π/2 rad (Figure 4a) and each one of them drives a sinusoidal current with a phase difference of π/2 rad. The first coil (or coil-α) will conduct the first phase of the current (φ = 0) and it is fixed to the ordinate axis. The second coil (or coil-β) will conduct the second phase of the current (φ = π/2) and is considered fixed to the x-axis. The named αβ-reference system reduces the IM modeling problem to a simpler electromagnetic model with only two phases.

2.1.2. Rotative Reference System

Combining the single rotating coil system and the stationary reference system yields a new system consisting of two rotating coils, Figure 4b, which allows to obtain a rotating vector B and allows the modeling of the couplings between the inductances of the coils. In addition, the currents conducted by the coils could be direct (DC).

In this model, the axis of reference, which is solidary with the coil driving the phase α is called the d-axis (from the direct axis), and the axis corresponding to the coil β is called the q-axis (from the quadrature axis). Where θ_e is the angle between the α-axis of the stationary reference attached to the stator and the d-axis of the rotative reference frame, we will always consider the rotor angle θ_e as just another state of the IM model and, therefore, a value that can be calculated.

2.1.3. Motor Shaft Rotation

To form the magnetic pole pairs that will produce the movement of the motor shaft, the rotor winding must also conduct a current to generate magnetic flux. If we short-circuit the rotor winding (for example, using a squirrel cage winding [21]), then a current is induced in it, which produces an electromagnetic force. The motor will start to rotate at the speed ω_r due to the electromagnetic force generated by the change of direction of the magnetic field B, which rotates at the synchronous angular speed ω_e resulting from the stator winding.

On the other hand, according to Faraday’s law (1), only if the magnetic flux Φ varies with time will an electromagnetic force be generated, which translates into a momentum capable of moving a load. Such a change may be due to a change in the amplitude of the magnetic flux Φ or the electric circuit representing the rotor winding that cuts the magnetic flux and changes its angle of incidence. According to this observation, it will be the case that if the rotor were to rotate at the same speed as the rotating magnetic field of the stator, i.e., ω_r = ω_e, then no electromagnetic force would be induced, nor would any momentum be created. If, on the other hand, there were a small difference between the rotor angular velocity ω_r and the B speed ω_e induced by the stator, then an electromagnetic force would be generated and, consequently, create a momentum that can be converted into mechanical torque. The difference between both rotational speeds (ω_e and ω_r) is another important parameter of induction motors, which is called slip,

Table 1. Synchronous and rotor speeds.

Slip Feature of 2-Pole IM
ωe: stator synchronous speed (input variable)	314.2 rad/s
ωr: rotor angular speed (output variable)	311.2 rad/s
s: slip (IM parameter)	0.01 rad/s

shows the values assumed by these variables during a random run of the model.

2.1.4. Transformation of the 3-Phase Reference Model to the Rotating Reference System

In three-phase symmetrical machines, the direct and quadrature axis currents (as well as the other variables) that are defined in the rotating reference frame represent two fictitious components of the stator and rotor currents components. The components of the three-phase reference frame currents can be transformed into the direct and quadrature axis components by means of a linear transformation and vice versa.

It is necessary to find the transformations that allow passing the currents $\overrightarrow{i}$ (i_a, i_b, i_c), voltages $\overrightarrow{v}$ (v_a, v_b, v_c), and magnetic fluxes $\overrightarrow{\Phi }$ (Φ_a, Φ_b, Φ_c) to the stationary 2-phase reference frame: $\overrightarrow{i}$_αβ, $\overrightarrow{v}$_αβ, and $\overrightarrow{\Phi }$_αβ, then, to the rotating reference system: $\overrightarrow{i}$_dq, $\overrightarrow{v}$_dq, $\overrightarrow{\Phi }$_dq. Trivially, from a mathematical point of view, an expression given as a function of the coordinates dq can be directly transformed into an expression in coordinates αβ if the θ_e angle always maintains a constant value θ_e = 0. Otherwise, we will therefore have to apply the transformation of reference systems (abc → dq), expressed by the following T matrix transformation:

$$\overrightarrow{f_{dq}}=T_{dq}\left(\theta \right)·\overrightarrow{f_{abc}}$$

(3)

where $\overrightarrow{f_{dq}}$ is a vector representing the voltage, current or magnetic flux of the stator or rotor (we will use different variables for each of these motor elements) of the IM model. This is a transformation from a three-phase system (abc) into a two-phase system (dq). However, the d and q axes may be insufficient to describe the above physical variables if the currents are not balanced or if induced magnetic fluxes occur, causing the neutral wire of the stator to drive current, i.e., that v₀ ≠ 0. Because of this, the zero component is added to the physical magnitude $\overrightarrow{f}$, and we will therefore denote the reference system as dq0 from now on. The transformation matrix of the three-phase reference system (abc) into the stationary reference frame (αβ0) is given in [3].

$$T_{\alpha \beta 0}=\left(\begin{array}{ccc}1& 0& 0\\ 0& \raisebox{1ex}{$-1$}\!\left/ \!\raisebox{-1ex}{$\sqrt{3}$}\right.& \raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{$\sqrt{3}$}\right.\\ 1& 1& 1\end{array}\right)$$

The inverse transformation matrix (from system αβ0 → abc) would be:

$$T_{{}_{\alpha \beta 0}}^{-1}=\left(\begin{array}{ccc}1& 0& 0\\ -\raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{$2$}\right.& \raisebox{1ex}{$-\sqrt{3}$}\!\left/ \!\raisebox{-1ex}{$2$}\right.& \raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{$2$}\right.\\ -\raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{$2$}\right.& \raisebox{1ex}{$\sqrt{3}$}\!\left/ \!\raisebox{-1ex}{$2$}\right.& \raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{$2$}\right.\end{array}\right)$$

To transform any of the above magnitudes, for example, voltage, to the rotating reference system, the following equations can be used:

$$\left\{\begin{array}{c}{V}_{qs}{=V}_{\alpha }{cos\theta }_e{-V}_{\beta }{sen\theta }_e\\ V_{ds}{=V}_{\alpha }{sen\theta }_e{+V}_{\beta }{cos\theta }_e\end{array}\right.$$

The inverse transformation would be given by the equations:

$$\left\{\begin{array}{c}{V}_{\alpha }{=V}_{\mathit{qs}}{\mathit{cos}\theta }_{+}+V_{\mathit{ds}}{\mathit{sen}\theta }_e\\ V_{\beta }{=-V}_{\mathit{qs}}{\mathit{sen}\theta }_e{+V}_{\mathit{ds}}{\mathit{cos}\theta }_e\end{array}\right.$$

2.2. Physical Model of the IM in the Rotative Reference System

The IM model can be derived from the equivalent electrical circuit (Figure 5 and Figure 6). The differential equations describing this model expressed as a function of the magnetic linkage Fij (see definition in

Table 2. Physical constants and variables of the induction motor model.

Relevant Observables and Magnitudes of the Physical System under Study
d: direct axis of the rotating reference system	χ*lm = 1/(1/χls +1/χlr + 1/χm): total reactance with the loses for magnetizing (χm)
q: quadrature axis of the rotating reference system	iqs, ids: currents of the q and d stator axis
s: subindex for the stator variable	iqr, idr: currents of the q and d rotor axis
r: subindex for the rotor variable	p: number of poles of the motor
Fij = Φij, ωb: magnetic linkage, where i = q or d and j = s or r	J: inertia momentum
vqs, vds: stator voltages	Me: motor’s electromagnetic torque (output variable)
vqr, vdr: rotor voltages	Ml: load torque (input variable)
Rr, Rs: rotor and stator resistors	ωe: stator synchronous speed (input variable) of B
χls: stator reactance (ωe·Lls)	ωb=2·π·fb: angular speed corresponding to the electric frequency of feeding voltage
χlr: rotor reactance (ωe·Llr)	ωr: rotor angular speed (output variable)

) are as follows:

$$\frac{d{F}_{qs}}{dt}={\omega }_b\left[v_{qs}-\frac{{\omega }_e}{{\omega }_b}{F}_{ds}+\frac{R_s}{{\chi }_{ls}}\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{lr}}{F}_{qr}+\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{ls}}-1\right)F_{qs}\right)\right]$$

(4)

$$\frac{d{F}_{ds}}{dt}={\omega }_b\left[v_{ds}+\frac{{\omega }_e}{{\omega }_b}{F}_{qs}+\frac{R_s}{{\chi }_{ls}}\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{lr}}{F}_{dr}+\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{ls}}-1\right)F_{ds}\right)\right]$$

(5)

$$\frac{d{F}_{qr}}{dt}={\omega }_b\left[-\frac{({\omega }_e-{\omega }_r)}{{\omega }_b}{F}_{dr}+\frac{R_r}{{\chi }_{lr}}\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{ls}}{F}_{qs}+\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{lr}}-1\right)F_{qr}\right)\right]$$

(6)

$$\frac{d{F}_{dr}}{dt}={\omega }_b\left[\frac{({\omega }_e-{\omega }_r)}{{\omega }_b}{F}_{qr}+\frac{R_r}{{\chi }_{lr}}\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{ls}}{F}_{ds}+\left(\frac{{\chi }_{ml}^{*}}{{\chi }_{lr}}-1\right)F_{dr}\right)\right]$$

(7)

As can be seen in Equations (6) and (7), in the IM model, voltages v_qr and v_dr are identically equal to zero in the rotor since we assume a short-circuited (squirrel cage) rotor winding; and therefore, the right-hand side of the equivalent electrical circuits would have zero voltage. The constants and variables of the above system of linear differential equations are defined in Table 2.

Simulink Model of the Induction Motor Model

A new block has been implemented using Simulink from the physical model, given by the differential Equations (4)–(7) of the induction motor. In the first column of the Simulink model (Figure 7), the blocks corresponding to the differential equations of the four magnetic linkages F_ij appear since they are needed to calculate the other output variables. Each of these equations could have been implemented using the Simulink block intended for modeling systems of equations in state-space block notation, but for reasons of design flexibility, discrete user blocks have been used instead.

Figure 8 shows the interior design of one of the blocks of the first column—the one that calculates the magnetic linkage F_ds.

2.3. Calculation of the Electromagnetic Torque and Mechanical Power Generated by the Motor

The most important function of the MI is to produce mechanical torque on the motor shaft. The electrical power input to the motor P_input in the three-phase reference system can be obtained by evaluating the following expression, which is a sum of terms of products of the voltage and current values of each of the phases of the motor input current:

$$P_{input}{=v}_{as}·i_{as}{+v}_{bs}·i_{bs}{+v}_{cs}·i_{cs}{+v}_{ar}·i_{ar}{+v}_{br}·i_{br}{+v}_{cr}·i_{cr}$$

(8)

The expression of Equation (8) above can be easily obtained by simply applying the well-known electric power formula: $P_e={\sum }_{i,j}{v}_{ij}·i_{ij}$; where j = s (stator) or r (rotor) and i = a, b, c, to the equivalent electric circuit of the induction motor (Figure 9), which we can consider as an accurate model for calculating the input power of the motor. The input power is expended on four things: electromagnetic energy, mechanical energy, dissipation by losses in resistors and inductances, and the movement of the load, although most of the electrical power generated by the motor is converted into mechanical torque.

In order to comfortably use the input power equation, we have obtained above, we have to transform it according to our rotating reference frame dq0, using for this purpose the inverse transformation given by T⁻¹_αβ0, and after conveniently manipulating Equation (8), we obtain the following expression for the input power expressed in the reference frame dq0,

$$P_{input}=\frac{2}{3}\left(v_{ds}·i_{ds}+v_{qs}·i_{qs}+2v_{0s}·i_{0s}+v_{dr}·i_{dr}+v_{qr}·i_{qr}+2v_{0r}·i_{0r}\right)$$

(9)

The currents produced in the zero phase of the stator, and consequently the magnetic fluxes induced in this phase, do not contribute to the mechanical power of the motor. Moreover, as previously commented, if we consider that the rotor winding is short-circuited, then the voltages v_qr, v_dr, are zero, so that from Equation (9), we will only consider the first two terms of the sum. On the other hand, if we substitute the voltages by their equation as a function of the magnetic induction and the stator current intensities, Equation (9) would be re-written as follows:

$$P_{input}=\frac{3}{2}\left(r_{ds}·i_{ds}^2{+\omega }_b{\varphi }_{qs}·i_{ds}+\frac{d}{dt}{\varphi }_{ds}·i_{ds}{+r}_{qs}·i_{qs}^2-{\omega }_b{\varphi }_{ds}·i_{qs}+\frac{d}{dt}{\varphi }_{qs}·i_{qs}\right)$$

(10)

In the above equation there are three different types of generated power. The first type has the form ri² and corresponds to the power dissipated in the motor windings. The second type has the form $\mathsf{\omega }·{\varphi }_i$ and represents the electrical energy converted into mechanical energy. The third type is of the form $\frac{\mathrm{d}}{\mathrm{dt}}\varphi ·i$ and takes into account the energy exchange between the magnetizable parts of the machine and the windings. Therefore, the total mechanical power will be given by the following equation for an IM with p poles,

$$P_{mech}=\frac{3}{2}\left(\frac{p}{2}\right) \left({\omega }_b·{\varphi }_{qs}·i_{ds}-{\omega }_b·{\varphi }_{ds}·i_{qs}\right)$$

(11)

and the magnetic flux ${\varphi }_{qs,ds}$ only depends on the angular speed and the magnetic linkage F_ij = ω_b⋅Φ_ij. The mechanical torque transmitted by the motor shaft would be equivalent to the electrical torque generated by the motor, $P_{mech}={\omega }_b·M_e$, then we can obtain,

$$M_e=\frac{3}{2}\left(\frac{p}{2}\right)\frac{1}{{\omega }_b}\left(F_{qs}{i}_{ds}-F_{ds}{i}_{qs}\right)$$

(12)

from the magnetic linkages F_ds, F_qs, and currents, which are obtained by solving a system of differential linear equations, graphically represented by (Figure 7), with concrete values of p (the number of poles) and ${\omega }_b$ (stator speed) as the input data to the induction motor model.

The angular speed ω_r of the rotor can also be calculated since the mechanical load torque M_l, and inertia J are also parameters of the IM model. As the above Equation (12) shows, the electrical torque $M_e$ (and the angular rotor speed ${\omega }_b$) depend on the number of poles of the rotor winding, contrary to what happens with the magnetic fluxes.

3. Modeling Method

In the proposed method, we will use different ANN classes [22,23] to design a hybrid real-time system with continuous and discrete components. We use a typical design of a neural network, in which we define training, testing, and validation (Figure 10). The output generated or “measured” from the IM Simulink model, which represents the functional and dynamic aspects of the model, are the training data.

During the execution of the IM drive implemented with Simulink, the main variables of the CPS acquire values that are used to train the ANN. The MATLAB Deep Learning Toolbox (DLT) allows us to generate Simulink blocks that implement different types of neural networks (feed-forward, narx, …).

A Simulink block implementing a trained ANN can replace any PID controller in a closed-loop control system, such as those typically used in industrial systems to keep the output signal constant and produce a predictable system response, even in the case of disturbances in the input signals or noise. We can see the advantages of the mentioned substitution in [18].

3.1. Registry

The training data were obtained by simulation using the Simulink model of the IM drive. The problem of data logging, although facilitated by the assistance offered by the Simulink software, requires the application of algorithms such as the classical ICP or some of its adaptations [24].

The proposed method starts from N sets of point clouds: ${\left\{\left(v_a,v_b,v_c,i_a,i_b,i_c,M_l,{\omega }_e\right)\right\}}_{i=1}^N$, whose points have information of a 3D static property, i.e., the voltages: v_a, v_b, v_c and currents: i_a, i_b, i_c of the stator, and of two dynamic properties, which have been chosen to be the load torque M_l and the ω_e synchronous angular speed of B in the stator (see Table 2).

The point clouds for ANN training can be obtained in several ways: by direct measurement of the physical device (IM) using a rotating torque-meter or obtained directly (off-line) from an experimental database for three-phase induction motor rotor fault detection and diagnosis [25], or they can be obtained by simulating the IM drive with Simulink, which is the option chosen in this study. The acquisition of the training data must be repeated several times, and outliers must be eliminated. In the end, the objective of the first stage of the proposed method is to obtain a realistic point cloud in which the evolution of the rotor’s angular speed ω_r and the rotor’s electromagnetic torque M_e in the real physical system can be visualized. On the other hand, the objective model sought by the method, to accurately predict the values of the above variables, must be able to react and self-stabilize against variations of input voltages, or changes of the load torque M_l and synchronous speed ω_e, to achieve this the IM drive Simulink model proves to be of great help.

The training data have been collected assuming initially a synchronous reference speed ω_e = 2π × f_b, where f_b is the frequency of the feeding voltage (=100 s⁻¹.) in the stator winding. M_l is the load torque, whose values are in the range [0.0…330.0] Nm during the simulation. The collected data from the Simulink model are the voltages and currents in the three phases of the named abc reference system. Figure 11 shows the reference rotor speed ω_r, which is assumed to change over the simulation time. The simulation time was 50 s. The simulation was done with a sample time of 0.0005 s and the size of data points is 250,000. The rotor speed ω_r has been stored in the MATLAB workspace as a time series represented by a table with the same time step as the simulation sampling time.

3.2. Design of the ANN and Selected Hyperparameters

The type of ANN is very important to get an accurate estimation of the electromagnetic torque and speed of the IM. The DLT toolbox of MATLAB has been used to implement the ANN deployed in the study. The ANN hyperparameters related to the structure (number of neurons and hidden layers…) have been chosen by trial and error; those related to how the network is trained (backpropagation step, activation function, epochs…) are given by the selected training function and, usually, can be adjusted manually. A shallow multilayer neural network with two hidden layers has been initially defined, Figure 12a. The training function of both ANN has been chosen as the Levenberg-Marquardt (‘trainlm’) one, but any other could have been chosen instead.

The objective function selected was the mean squared error (MSE). Of course, the number of hidden layers and the number of neurons in each layer can be tuned to obtain, with the maximum possible performance, the estimated speed within a time window (50 s). We have selected here 20 and 10 neurons for the first and second hidden layers, respectively.

In the second part of the study, a non-linear autoregressive with exogenous input neural network has been used, Figure 12b, i.e., a two-layer feed-forward narx, with ten neurons and a sigmoid transfer function (depicted as one Simulink block with curved line), which takes an input data matrix and returns another one where each column vector contains a single value ‘1’, with all other elements equal to ‘0’. In the output layer, one linear transfer function (Simulink block with an oblique straight line) has been defined.

3.3. Training of the ANN

The main objective of ANN training is to minimize the objective function $F\left(x,{\mathsf{\Pi }}_i\right)$ iteratively by fitting a set Π_i = {α,β,γ,…} of hyperparameters with respect to K training samples, which have been initially chosen to be a subset of the point clouds yielded by the prior registry stage, i.e.,

$$x={\{v_a^i,v_b^i,v_c^i,i_a^i,i_b^i,i_c^i,M_l^i,{\omega }_e^i\}}_{i=1}^K$$

(13)

where v_x, i_x, M_l, ω_e are the input voltages and currents in the three-phase reference system, the load torque, and the synchronous speed, respectively.

This process can be expressed by the following equation, $mi{n}_{{\mathsf{\Pi }}_i}F\left(x,{\mathsf{\Pi }}_i\right),$ such that

$$F\left(x,{\mathsf{\Pi }}_i\right)=l.r.\left(\{v_a^i,v_b^i,v_c^i,i_a^i,i_b^i,i_c^i,M_l^i,{\omega }_e^i){\}}_{i=1}^K,{\mathsf{\Pi }}_i\right)+r({\mathsf{\Pi }}_i)$$

(14)

where F is the objective function, l.r. represents a linear relationship between each set of training samples and the hyperparameters Π_i, and the function r(·)represents the penalties that the application of each set of hyperparameter values may incur.

The optimization of the objective function F can be performed by several techniques: reinforcement learning, heuristics, and gradient descent, … In our method, we have chosen the latter one because the functions describing the cyber-physical model are all differentiable. F maintains the same properties, so that the calculation of $mi{n}_{{\Pi }_i}F\left(x,{\Pi }_i\right)$ does not usually diverge if gradient descent application is chosen.

The training of each of the ANNs used in the study has been performed offline, using the recorded currents and voltage data during a representative run of the IM drive model to save implementation time. The rotor speed ω_r was then predicted (‘estimated speed’) by training first the ff ANN and then the narx ANN. The same process has been carried out for the estimation of the electromagnetic torque M_e.

3.4. Validation of the ANN

In order to obtain a useful objective function adapted to our case study, we will define a cost function to be optimized and build the complete performance evaluation model, for which we have selected the MSE based on four key factors: v_x, i_x, ω_r and the M_e, (see definitions in Table 2) affecting the reliability and efficiency of the IM model.

Therefore, we can interleave the dimensions of the model ($\overrightarrow{v_x}, \overrightarrow{i_x}$, M_e, ω_r) to obtain a multidimensional evaluation of performance, such that the MSE can guide the iterations during the application of the gradient descent technique,

$$I_{k_x}=\frac{\sqrt{{\sum }_{i=1}^K{\left(\overrightarrow{i_{x_i}}-\overrightarrow{i_{x_i}^{ref}}\right)}^2}}{K}$$

(15)

$$E_{k_x}=\frac{\sqrt{{\sum }_{i=1}^K{\left(\overrightarrow{v_{x_i}}-\overrightarrow{v_{x_i}^{ref}}\right)}^2}}{K}$$

(16)

$$M_{e_k}=\frac{\sqrt{{\sum }_{i=1}^K{\left(M_{e_i}-M_{e_i}^{ref}\right)}^2}}{K}$$

(17)

$$W_{r_k}=\frac{\sqrt{{\sum }_{i=1}^K{\left({\omega }_{r_i}-{\omega }_{r_i}^{ref}\right)}^2}}{K}$$

(18)

The reference values of the four key factors for MSE calculation are the measured values of currents, voltages, torque, and synchronous speed in each one of the K training samples. We can find the optimal model by minimization of

$$F\left(\Pi \right)=\log \left(\alpha ·E_{k_x}+\beta ·I_{k_x}+\gamma ·M_{e_k}+\delta ·W_{r_k}\right)$$

(19)

We consider that the natural logarithm can substitute the square root. In the latter equation α, β, γ, and δ denote the weight hyperparameters, and E_kx, I_kx, M_ek, W_rk represent the performance factors of input voltages, currents, torque, and motor speed, respectively.

First, we create the network by executing ‘name = feedforwardnet ([ 10, 20 ])’ of DLT; i.e., we create a two-layer feed-forward network with 10 and 5 hidden neurons, respectively. In the second part of the study, we repeated the process by creating a narx network by issuing the command name = narxnet(10). By executing the command ‘view (net_name)’, for each of the two networks created we can visualize the images (a) and (b) in (Figure 12).

We have validated and tested both ANNs to prove the performance and accuracy of the feed-forward and narx networks. Tests have been performed by calculating the MSE of the estimated values of ω_r and M_e by applying regression. The estimated values should be tested with all the data available (training, validation, and test) up to that point. If the accuracy of the results is not satisfactory, the previous steps should be repeated, as shown in the diagram in Figure 10.

3.5. Exporting the Simulink Block

At this stage, after checking the efficiency and accuracy of the ANN generated in the previous phase of the method, the neural network can be exported as a Simulink block using the command ‘gensim(net_name)’ of the DLT application. The steps to obtain an accurate estimate of the ω_r and M_e can be carried out as in the listing below. This code shows that the ff ANN has been selected to obtain these predictions and that it has two hidden layers of 10 and 5 neurons, respectively,

• Implement a Simulink model of the IM;
• Simulation running of the Simulink model;
• Collect the input signals (currents, voltages, load torque, stator synchronous speed)
• Collect the output signals, i.e., values of rotor speed and electromagnetic torque for training the ANN;
• Design the ANN as a result of issuing similar commands as the next ones: ff_net = feedforwardnet ([ 20, 10 ]);
  • ff_net.trainFcn = ’trainlm’;
  • ff_net.trainFcn = ’trainlm’;
  • ff_net.divideFcn =’dividetrain’;
  • ff_net.divideMode =’sample’;
  • ff_net.trainParam.Epochs = 1000;
• Configure and train the ANN as a result of the commands:
  • ff_net = configure(ff_net, input_signals, output_signals); [ff_net,tr] = train(ff_net, input_signals, output_signals).

3.6. ANN Parallelization Assessment

A fully connected network that contains two hidden layers of size 2K has been defined, and one of them is constituted as a 50% dropout layer between them to avoid overfitting. Each of the K-sub-networks is susceptible to be run in parallel. The optimal value of K will depend on the number of CPU/GPU cores available on the machine and all K models are started in parallel to follow a process that interchanges training and model validation by coding the algorithm to operate on separate data partitions, according to the SPMD parallel data execution paradigm. The assessment, which is carried out during the execution of the application, consists of the comparison and fitting of the hyperparameters of the cyber-physical model by using for this purpose the Simulink model of the IM drive, see (Figure 7). In this way, it is possible to accelerate the convergence of the optimal values with respect to the application of the approximate gradient descent only.

4. ANN-Based Speed Estimator

The input and output signals of ω_r and M_e estimators can be obtained during the training phase by simulation of the IM drive, shown in (Figure 7 and Figure 8). ff ANN rotor speed estimator is exported as a Simulink block with the input x1 (time, currents, voltages) and the output y1 (rotor_speed) signals, as they are shown in (Figure 13).

4.1. FF Network Based Rotor Speed Estimator

The MATLAB DLT application has been used to train, validate, and test the ANN (created as ‘ff_net’). Figure 14 shows the architecture of the ff ANN, information about the algorithm selected for training and the objective function deployed in the validation phase, as well as other characteristics of ‘ff_net’ and the total execution time spent training this network.

The performance of the ANN-based rotor speed ω_r estimator of the IM has been obtained by the MSE calculated during 1000 epochs of training, and it is shown in Figure 15a. The error histogram is shown in Figure 15b.

As can be seen, the figures show a linear regression between the estimated (predicted by ‘ff_net’) and the measured (in the IM drive) rotor speed values. The regression calculation between the estimated and measured rotor speed ω_r has been displayed in Figure 15c.

4.2. NARX Network Based Rotor Speed Estimator

In addition to the above speed estimator, obtained from an ff ANN, another narx ANN has also been trained to predict a time series y(t) from the past values of the feedback signal y(t) and the values of the exogenous input series x(t). The time series y(t) contains values of ω_r, and the series x(t), the vectors of the motor input currents and voltages in the ‘abc’ phase-normal reference system, as

Table 3. Created narx ANN characteristics.

Series Role	Time Steps	Number of Features	Features
Predictors: x(t)	250,004	7	(time, ia, ib, ic, va, vb, vc)
Responses: y(t)	250,004	2 1	(time, ωr)

¹ Exogeneous signal components.

shows.

Narx neural networks can be applied in three different forms for making predictions,

• Open loop;
• Closed loop;
• Open/closed multistep prediction.

In general, with the next value of the dependent output signal y(t), a regression is performed on previous values of this output signal and the previous values of the exogenous independent input signal x(t).

A series-parallel architecture based on an ff network can be efficiently used for training a narx neural network when modeling dynamic systems since doing so is faster than training the parallel configuration directly. We are going to apply the created narx for an open/closed multi-step prediction, i.e., the so-called ‘narx_net’ can initially be implemented using an ff ANN to approximate the following function,

$$\left(t\right)=f\left(y\left(t-1\right), y\left(t-2\right), \dots ,y\left(t-n_y\right), x\left(t-1\right), x\left(t-2\right),\dots x\left(t-n_x\right)\right)$$

(20)

Figure 16a shows the series-parallel architecture that has been used for training the ‘narx_net.’ Subsequently, the feedback loop is closed to convert such architecture into its parallel configuration as shown in Figure 16b for performing predictions of values in the series y(t). This technique is very useful for performing multi-step forward prediction in modeling nonlinear dynamic systems such as the IM drive we are concerned with in this study.

The protocol to be followed to obtain an accurate estimate of ω_r and M_e is given in the following list of actions and commands of the DLT. The following code shows that the ‘narx_net’ has been selected to obtain the above predictions (estimates) and that it has one hidden layer of 10 neurons,

• Implement a Simulink model of the IM;
• Simulation running of the Simulink model;
• Collect the input signals (currents, voltages, load torque, stator synchronous speed)
• Collect the output signals, i.e., values of rotor velocity and electric torque for training the ANN;
• Design the NARX ANN as a result of issuing similar commands as the next ones: delay1 = [ 1:2 ]; delay2 = [ 1:2 ];
  narx_net = narxnet(delay1,delay2,10); narx_net.trainFcn = ’trainlm’;
  narx_net.trainParam.min_grad = 1 × 10⁻¹⁰; narx_net.trainParam.Epochs = 1000;
• Configure and train the NARX ANN as a result of the commands:
  [p,Pi,Ai,t]= preparets(narx_net,X,{},Y);
  narx_net=train(narx_net,p,t,Pi);
• Close narx_net for obtaining multi-step predictions of target values:
  narx_net_closed= closeloop(narx_net);

The training data must be used with a tapped delay with respect to the inputs of both signals. The above code listing has defined two identical delays ([1:2]) for both predictors and responses so that the training of the network begins with the third data point in the input(X) and output(Y) to the series-parallel network ‘narx_net.’ Using the ‘preparets’ configuration command means that a lot of data preparation is required before training the network’s tapped delay lines, which must be filled with initial conditions. Finally, the ‘narx_net_closed’ network is prepared to make predictions after the execution of the ‘closedloop’ command converts the trained network into its parallel configuration.

Since with narx neural networks, it is more frequent to get into overfitting situations, in this part of the study, it was decided to manually divide the dataset into 70% for training, 15% to validate that the ANN is generalizing correctly, and stop it before overfitting, and 15% to test the generalization performed by the ANN. Therefore, the histogram of errors and the regression between estimated data and actual data must be displayed for each of the mentioned subsets (training, validation, testing), as shown by the different graphs in Figure 17.

4.3. Results and Discussion

The DLT MATLAB application was used to validate the complete target system associated with the ANNs for motor speed and electromagnetic torque estimation.

We have carried out a double validation of the ANN-based estimator response for rotor speed ω_r in this section considering a time span of 50 s from the training speed and the load torque M_l has been maintained constant. The measured speed with the IM driver model and the estimated speed based on the ff ANN is shown in Figure 18. The actual reference speed of the IM driver and the speed estimated by the narx ANN-based estimator can be seen in Figure 19. We can see in both figures that the measured and estimated rotor speeds have the same trajectory, so we can conclude that the accuracy of the two-speed estimators based on two different types of ANN has been correctly validated.

However, in Figure 19, we can observe that perturbations in the response (ω_r) of the narx-based estimator are evident up to 8 s of run time, although the output signal tends to stabilize soon after. In general, we can observe that the rotor speed ω_r follows the changes produced in the synchronous ω_e angular speed in the stator. Since any change in the value of ω_e causes rapid oscillations around the new value in the rotor speed ω_r, such oscillations are more dramatic at the beginning in the narx-based estimator; this is probably caused by the closed loop of the feedback signal that brings the output values of the speed back to the input of the estimator. Therefore, we could state in view of the ω_r response plots that the narx-based estimator performs worse and takes longer to self-stabilize than the ff-based estimator. The plots in Figure 18b and Figure 19b, which show the error between the measured and estimated values of the rotor speed, also agree that the error shown by the ff-based open-loop estimator is smaller than the error produced by the closed-loop narx-based implementation. In addition, a perturbation of the rotor speed at 31 s is shown in Figure 18a that has no effect on the estimated output speed, which confirms the self-establishing capability of the ff-based estimator.

5. ANN-Based Electromagnetic Torque Estimator

We have carried out a double validation of the response of the ANN-based estimator for the electromagnetic torque M_e in this section, considering a time span of 50 s of the training speed ω_e, and the load torque M_l has been maintained constant.

Feed-forward and narx ANN rotor speed estimators are exported as DLT-generated blocks for their use in the target Simulink model with the input x1 (time, currents, voltages) and the output y1 (electromagnetic_torque) signals. The load torque M_l, which has been applied to obtain the training data, and the electrical torque M_e measured with the IM drive have been shown in Figure 20.

5.1. FF Network Based Electromagnetic Torque Estimator

The input data to the ff ANN estimator are based on the measured currents and voltages in the IM drive model with respect to the abc phase-standard reference system. The output data are the electromagnetic torque M_e and the speed ω_r in the rotor over time.

The DLT of MATLAB has been used to train, validate, and test the ff ANN M_e estimator. The input and output data have been collected during the training by simulation with the Simulink IM drive system. The generation of the ff ANN block in Simulink is performed with the DLT commands,

• TqTT = timeseries2timetable(Torque);
• TqT1 = [seconds(TqTT.Time), TqTT.Data];
• Tq = tonndata(TqT1,false,false);
• W = [XT1(:,1:4),ZT1(:,2:4)];%(time, currents, voltages)
• [ff_net, tr] = train(ff_net, W, Tq);
• gensim(ff_net); %Simulink- FF ANN block generated

The performance of the ff ANN-based electromagnetic torque M_e estimator has been obtained by calculating the MSE for 1000 epochs of training, as shown in Figure 21a. The error histogram in Figure 21b shows that more than 99% of all the instances exhibit almost negligible errors. (<0.020).

It can be seen that there is a linear regression between the estimated electromagnetic torque and the one measured with the IM driver, such regression has been calculated directly from the 50 s time series obtained from the Simulink model, and the results are presented in Figure 21c.

5.2. FF Network Based Electromagnetic Torque Estimator

A second narx ANN-based (

Table 4. Created narx characteristics.

Series role	Time Steps	Number of Features	Features
Predictors: x(t)	250,004	7	(time, ia, ib, ic, va, vb, vc)
Responses: y(t)	250,004	2 1	(time, Me)

¹ Exogeneous signal components.

) estimator of electromagnetic torque M_e for the rotor has been generated with the DLT commands,

• narx_net = narxnet(narx_net, delay1, delay2,10);
• [x,xi,ai,t] = preparets(narx_net, W,{}, Tq);
• narx_net = train(narx_net, x, t, xi, ai);
• narx_net_closed = closeloop(narx_net);
• %Simulink-NARX ANN block generated
• gensim(narx_net);

The time series y(t) contains now values of M_e and the series x(t) the vectors of the motor input currents and voltages in theabc phase-normal reference system.

As we did for the speed estimator, the dataset has been manually divided into 70% for training, 15% for validation, and 15% for testing. Therefore, the histogram of errors and the regression between estimated data and actual data must be displayed for each of the mentioned subsets (training, validation, testing), as shown by the different graphs in Figure 22a–c.

5.3. Obtained Results and Discussion

The DLT of MATLAB has been used to train, validate, and test the ff ANN and narx electromagnetic torque estimator considering a time span of 50 s from the training speed. The load torque has been maintained constant and equal to 145 Nm in the plots.

Figure 23a shows the zoomed capture of the measured data (used for training) and the estimated electromagnetic torque values after training the ff ANN estimator. The input data of the ff ANN are based on the measured voltages and currents in the abc-phases representation and the electromagnetic torque of the rotor. The output and input data can be obtained during the training stage by simulation of the IM drive with Simulink.

The errors, scaled to 1.0, obtained between the estimated and measured M_e for the rotor are shown in Figure 23b and the results shown validate accuracy and effectiveness of the ff ANN estimator implemented as a Simulink block by using DLT.

Figure 24a shows the actual reference torque M_e produced by the IM drive and the output of the narx ANN-based estimator. We can see that the measured and estimated electromagnetic torques have the same trajectory, so we can conclude that the accuracy of the two torque estimators based on two different types of ANN has been correctly validated.

On the other hand, if we perform a closed loop-based estimation with the electromagnetic torque M_e controlled by the narx, exported as a Simulink block, we are apparently obtaining worse results than with the ff ANN estimator, as can be seen in the error plot between the measured and estimated values in Figure 24b. However, we can observe that the error plot of the electromagnetic torque M_e produced by the induction motor with respect to a constant load torque M_l of 145 Nm will only have significant oscillations at the beginning of the simulation, i.e., while the system is trying to reach a stabilization point. The oscillations shown represent approximately 50% of the target torque value M_e (200 Nm.), but these oscillations are caused by dynamic conditions during motor operation, which subsequently attenuates and is probably an unwanted side effect of the closed loop of the feedback signal. The initial output values of the electromagnetic torque for the rotor are not accurate. However, the estimator input is also fed with these values.

6. Conclusions and Future Work

We have presented one method and application derivation scheme to obtain a correct control system with real-time features. Automated Machine Learning methods, together with a certain class of ANN, will allow us to model continuous and discrete dynamic systems, such as the induction motor (IM) drive that is the case study.

Four estimators, based on a feed-forward (ff) and a narx ANNs, have been used for estimating two output signals: the rotor speed ω_r and electromagnetic torque M_e of an IM drive. Simulink blocks have been implemented and analyzed for the ANN-based estimators in this article. The validation of the estimators has been performed using MATLAB and Simulink, as well as the Deep Learning Toolbox (DLT), which provides a specific command for transforming certain types of ANNs into blocks that can be directly used in cyber-physical models designed with Simulink. The training, validation, and testing of the ff and narx-based estimators have been detailed as a useful reference for engineers and researchers. The estimated rotor speed and electromagnetic torque follow the same track as the measured ones from the IM drive.

Therefore, we have shown that PID (proportional integrative differential) controllers can be substituted by trained ANN of different classes. The ff and narx have been used here to integrate continuous components in a hybrid real/time system design without any accuracy or timeliness losses. However, unlike other proposals that attempted to overcome the same problem, our methodological scheme also includes a set of guidelines as a method, which have proved to be of use for deriving a verifiable model of a cyber-physical complex system.

A possible objection to the work carried out in this paper has to do with the basic classes of ANN deployed (ff and narx), which is due to hyperparameter optimization only performed in the case study with an approximate gradient method that may not be used with Recurrent Neural Networks (RNN), which seem to be more appropriate for obtaining accurate and performant estimators of relevant cyber-physical variables in industrial systems as the induction motor drives. In future work, other classes of ANN, such as RNN, must be used and tested, which may produce an improvement in the effectiveness and estimation accuracy with respect to the ANN deployed in this paper. The case study carried out here can be continued with the detection and isolation of incipient faults to improve the safety and reliability of the induction motor with squirrel cage winding in the future.

Finally, the proposed method has been defined for its easy integration in industrial environments for simulation (Simulink). It can also be used with standard libraries for neural networks development, such as SkLearn [14] in order to interoperate with the Python NumPy and SciPy numerical and scientific libraries, and PySpark, which has been launched to support collaboration between Apache Spark and Python, is actually a Python API for Spark. PySpark allows us to use a GPU cluster architecture and SparkGPU data transfer. In future work, we plan to develop a tool capable of automated code generation of real-time and embedded system software for several computing platforms.