NASA Technical Reports Server (NTRS) 20040089860: Neural Networks for Rapid Design and Analysis

9 Pages·0.19 MB·English

by  NASA Technical Reports Server (NTRS)

AIAA-98-1779
NEURAL NETWORKS FOR RAPID DESIGN AND ANALYSIS
* (cid:160)
Dean W. Sparks, Jr. and Peiman G. Maghami
NASA Langley Research Center, Hampton, VA 23681-0001
A bstract aerospace systems experience excitations resulting from
internal and external disturbances, for example,
Artificial neural networks have been employed for aerodynamic turbulence encountered by aircraft or
rapid and efficient dynamics and control analysis of instrument scanning in space systems. Excessive
flexible systems. Specifically, feedforward neural vibrations due to turbulent aerodynamics could diminish
networks are designed to approximate nonlinear dynamic the ride quality or safety of an aircraft. In space
components over prescribed input ranges, and are used systems, excessive vibrations could be detrimental to its
in simulations as a means to speed up the overall time science instruments which usually require consistently
response analysis process. To capture the recursive steady pointing in a specified direction for a prescribed
nature of dynamic components with artificial neural time duration. Typically, in the course of the design of
networks, recurrent networks, which use state feedback an aerospace system, as the definitions and the designs
with the appropriate number of time delays, as inputs to of the system and its components mature, several
the networks, are employed. Once properly trained, detailed dynamics and controls analyses are performed in
neural networks can give very good approximations to order to insure that all mission requirements are being
nonlinear dynamic components, and by their judicious met. These analyses, although necessary, have
use in simulations, allow the analyst the potential to historically been very time consuming and costly due to
speed up the analysis process considerably. To the large number of disturbance scenarios involved, and
illustrate this potential speed up, an existing simulation the extent of time domain simulations that need to be
model of a spacecraft reaction wheel system is executed, carried out. For example, a typical pointing
first conventionally, and then with an artificial neural performance analysis for a space system might require
network in place. several months or more, which can amount to a
considerable drain on the time and resources of a space
Introduction mission.
It is anticipated that artificial neural networks
(ANNs) can be used to significantly speed up the design
The overall design process for aerospace systems
and analysis process of aerospace systems. This paper
typically consists of the following steps: design,
will focus on the application of ANNs in
analysis and evaluation. If the evaluation is not
approximating nonlinear dynamic components in
satisfactory, the process is repeated until a satisfactory
simulations, in order to reduce overall time domain
design is obtained. Dynamics and control analyses,
analysis time and compute effort. Initial work has
which define the critical performance of many aerospace
shown that ANNs, once properly trained, can be used in
systems, are particularly important. Generally, all
place of nonlinear dynamical systems in simulations.
_____________________________
* These ANNs can give very good approximations of the
Aerospace Technologist, Guidance and Control
systems(cid:213) outputs, and they can drastically reduce
Branch.
computational burden in running the overall simulation.
(cid:160)
Senior Research Engineer, Guidance and Control A numerical example of a dynamical system simulation
Branch, Senior Member, AIAA. with an ANN is presented, and comparisons between
Copyright (cid:211) 1998 by the American Institute of conventional (i.e., without the ANN) simulation times,
Aeronautics and Astronautics, Inc. No copyright is in terms of computer processing unit (CPU) seconds,
asserted in the United States under Title 17, U.S. Code. versus simulation times with the ANN in place is
The U.S. Government has a royalty-free license to made.
exercise all rights under the copyright claimed herein for The paper is organized as follows. After this
Governmental purposes. All other rights are reserved introduction section, a brief description on conventional
by the copyright owner. dynamics analysis is given. Next, discussions on
1
American Institute of Aeronautics andAstronautics
neural networks, their use in approximating functional performance of the overall system to some degree. In
relationships, together with a typical design outline, is many instances, these changes are expected to affect the
presented. Then, numerical results of an example performance of the system to such a degree as to warrant
application of an ANN in a simulation is reported. a partial or full analysis of its performance. In the area
Finally, a conclusions section closes the paper. of spacecraft dynamics and controls, these types of
changes include: changes in the inertia or flexibility of
C onventional Dynamics Analysis the structural components which would affect the
dynamic characteristics of the spacecraft; changes in the
Conventional dynamics analysis can be divided characteristics of the external and internal disturbances
into two categories: time domain analysis and that may act on the spacecraft while it is in orbit; or
frequency domain analysis. Both are used to determine changes in the control system design, hardware, and
specific characteristics of a system performance, but as software. For example, for a reaction wheel system,
implied by their respective names, the characteristics are changes could include: wheel size, nonlinear friction
either defined in terms of time or as a function of characteristics, or wheel speed internal controller design.
frequency. In this paper, the emphasis will be on time Now, depending on the nature and extent of these
domain analysis. Time domain analysis tries to changes, there may be a need to reevaluate the controlled
compute the transient and steady state time responses of dynamical responses of the system. The computational
a system given specific inputs. Examples of typical time and cost associated with each of these performance
system response characteristics, which are studied in analyses (i.e., executing conventional time simulations)
time domain analysis, include transient system response may be substantial. The cost can be exorbitant
maximum overshoot, rise and settling times. Another especially if the analysis has to be repeated several
is the system(cid:213)s steady state performance, which is times during the design phase. One approach to this
usually defined by some metric on the steady state error problem is to use artificial neural networks (ANNs) to
between the system response and a reference signal. If help speed up the analysis.
the system is simple enough, i.e., linear, of very low
order and has relatively few inputs and outputs, like a R apid Analysis with ANNs
single-input, single-output (SISO) system, its
responses can be obtained by direct solution of the The motivation behind the use of ANNs is to
system equations which describe the model. However, speed up the analysis process substantially. The main
most realistic system models are of high order and/or use of ANNs lies with their ability to approximate
nonlinear, which precludes a direct solution. The usual functional relationships, specifically nonlinear
procedure in this case is to construct a simulation of the relationships. This can be either a static relationship,
system to obtain the time responses, via integration one that does not involve time explicitly, or a dynamic
(e.g., Runge-Kutta methods) of the system(cid:213)s equations relationship, which explicitly does involve time.
of motion. There are available several simulation-based Dynamic approximations via ANNs can be achieved by
packages, such as MATRIXx/System Build and using the appropriate time delays and feedback of the
MATLAB/Simulink, which can perform whatever time output back to the input, which is defined as recurrence.
domain analysis is required. However, even with these Such networks are referred to as recurrent networks1,2.
tools, computing time response solutions can be In any case, to an ANN, there is no distinction between
expensive both in terms of time and effort, depending a static or dynamic map, there is just input/output data.
upon a number of factors, such as the order of the For example, an ANN could be designed to approximate
system, the number of inputs and outputs, the level of the dynamic behavior of a nonlinear component, e.g.,
nonlinearities, the type and level of disturbance inputs the mapping between the nonlinear torque output of a
and/or reference signals, and the kind of integration spacecraft reaction wheel and its angular wheel speed and
selected. input torque command. Once such a network is trained,
Whatever type of analyses need to be done, it the torque output of the wheel, for given wheel speed
would be highly beneficial to the analyst to be able to and torque command inputs, can be easily obtained by
rapidly assess the effects on system time response simulating the ANN. One application of ANNs is to
performance due to the almost inevitable design changes use them to speed up the simulation process and
that a system will undergo during its lifetime. During therefore, the overall analysis time. For example,
the design phase of an aerospace system, almost all ANNs can be designed to approximate the outputs of a
components go through some level of change, with continuous-time, nonlinear system, with outputs
each change having the potential to affect the computed for a specified discrete step. This way, the
2
American Institute of Aeronautics andAstronautics
traditional continuous-time integration (e.g. Runge- A rtificial Neural Networks (ANNs)
Kutta) of the nonlinear dynamics can be replaced by Artificial neural networks (ANNs) have grown
discrete-time nonlinear algebraic updates, with into a large field since their inception, and a complete
reasonable accuracy. Although the initial training time discussion on them is beyond the scope of this paper.
for an ANN may be long, it can be performed during off Instead, this section will present a very brief description
hours, in a semi-automated manner, without much on ANNs. ANNs were developed as an attempt to
direct involvement by the designer. Also, once an ANN mimic the process of the human brain. They consist of
has been designed to represent a dynamic component, it groups of elements (called neurons) which perform
can be stored in a component library and recalled for use specific computations on incoming data, with
in future analyses. interconnections which permit data flow from one group
The successful design of an ANN depends on the of neurons to the next, similar to the way groups of
proper training of the network. The training of a biological neurons receive and transmit information
network involves the judicious selection of points in through dendrites and axons, respectively, in a brain.
the input variable space, which along with the Like their biological counterparts, ANNs can be trained
corresponding output points, constitute the training set. to perform a variety of tasks, such as modeling
In the reaction wheel example, in order to properly train functional relationships. The parameters of the ANN,
an ANN approximation, it is important that the input when presented with the appropriate input and output
points, i.e., the wheel speed and commanded torque data related to a specific functional relationship, can be
values, completely cover the range of possible values adjusted such that the ANN can give a good
for both. In addition, it is important that enough points representation of that relationship. This feature is
are selected such that they cover areas where fine particularly useful when the relationship is nonlinear
resolution in the design space is required, i.e., areas and/or not well defined, and thus difficult to model by
where small variations in input data cause large conventional means. Also ANNs, by their very nature,
variations in the corresponding output data. Of course, are a perfect fit for efficient parallel computations on
there will be the inevitable trade-off between selecting digital computers. Though there are several types of
enough points for good training and keeping the number ANNs, in this paper, only the feedforward ANN will be
of training points down to practical levels for discussed.
computation. A typical feedforward ANN is depicted in Figure 1,
Before proceeding, it is important to restate here with m inputs and n outputs, and each
p
that the true advantage of using ANNs lies with
modeling nonlinear relationships. Although one can Input Hidden Hidden Output
Layer Layer 1 Layer 2 Layer
certainly use ANNs to represent linear systems, there
will be no gain, in terms of reductions in compute time input 1 output 1
and effort, in their use over conventional representations
of the same linear systems. One can always take any
input 2 output 2
pure linear, dynamical system and rewrite it as a series . . . .
. . . .
of output difference equations, which are functions of . . . .
appropriate time-delayed output feedbacks and input
signals. It turns out that the coefficients of these input m output np
system output equations are equivalent to the Figure 1. Typical feedforward ANN.

(cid:210)weighting coefficients(cid:211) (which are defined in the
following subsection) of pure linear ANNs, with the circle, or node, representing a single neuron. The name
(cid:210)bias(cid:211) parameters (see following subsection) set to feedforward implies that the data flow is one way
zeros. Thus, there would be no point in training ANNs (forward) and there are no feedback paths between
to represent linear dynamical systems. Therefore, the neurons. The output of each neuron from one column
work reported in this paper will only cover representing is an input to each neuron of the next column. Using
nonlinear systems with ANNs. the typical naming convention, each column of neurons
In the following subsections, a brief overview of is called a layer, the initial column where the inputs
ANNs and the training of a specific type of ANN that come into the ANN is called the input layer, and the
was used in this work, are presented. last layer, i.e., where the outputs come out of the ANN,
is denoted as the output layer. All other layers in
between are called hidden layers. These ANNs can have
as many layers as desired, and each hidden layer can have
3
American Institute of Aeronautics andAstronautics
as many neurons as desired. Each neuron can be nodes, corresponding to the elements of the input
modeled as shown in Figure 2, with n being the number vector, while the output layer has n nodes, which
p
of inputs to the neuron. correspond to the elements in the output vector. The
number of nodes in the hidden layer is arbitrary,
w however, it has to be large enough to guarantee
1
convergence of the network to the functional
relationship that it is to approximate. Once the number
inputs output
to w S Activation from of nodes in the hidden layer has been chosen, the
2 Function
neuron neuron network design is reduced to adjusting, or training, the
.
. weighting coefficients and biases. The parameters of
.
feedforward networks are usually trained using either a
w b gradient method named the back propagation method1,2,
n
or a pseudo-Newtonian approach, such as the
Figure 2. Representation of a neuron in the feedforward
Levenberg-Marquardt3 technique. Typically, in these
ANN.
methods, the weights and biases are trained to minimize
some cost function of the error of the network. The
Associated with each of the n inputs is some adjustable
network error is defined as the difference between the
scalar weight, w , i = 1, 2, ..., n, which multiplies that
i output of the true system and that of its ANN
input. In addition, an adjustable bias value, b, can be
approximation, for a given set of inputs. The cost
added to the summed scaled inputs. These combined
function is usually taken as the sum squared error of the
inputs are then fed into an activation function, which
network over all of the input points. If q sets of points
produces the output of the neuron. The activation
(e.g., points taken for q time samples) are used for
function can take on many forms to shape the output;
training the network, then the input U to the network
three of the more common functions are linear, tan
would be an n x q matrix, with each column
sigmoid, and log sigmoid, as shown in Figure 3. The c
corresponding to a set of input points for a given time
sample, and the output Y would be a n x q matrix,
linear tan sigmoid log sigmoid p c
with each column of Y corresponding to that of U.
p
1 1 1 Now the cost function, in terms of the sum squared
error of the network, can be written as
0 0 0
1
(cid:229)qnp (cid:229)q (cid:229)np
-1 E = e(k)2 = (Y (j,r)-Y (j,r))2 (1)
d p
Figure 3. Three common activation functions. k=1 r=1 j=1
linear activation function simply outputs the input; the where Yd is a np x q matrix of the target outputs. The
tan sigmoid function is the hyperbolic tangent function, typical procedure is to keep updating the weights and
with output values between [-1,1] for inputs (-¥,+¥); biases until the error E goes below some specified
while the log sigmoid is also a nonlinear function, tolerance level. At this point, the feedforward network
which can be written asy =1/(1+e-x), with the is considered trained.
It has been shown in the literature that a
outputs values, y, in the range [0,1], given inputs, x, in
feedforward network with only one hidden layer can
the range (-¥,+¥). During training, the set of weights
approximate a continuous function to any degree of
and bias terms associated with the neurons are adjusted
accuracy4-6. It is obvious that this capability carries
until the output of the ANN matches, to within some
over to networks with more than one hidden layer. The
specified level of tolerance, the true outputs for the
use of feedforward ANNs has some advantages over the
same inputs.
conventional approximation techniques, such as
polynomials and splines. For example, polynomials
T raining o f a F eedforward N etwork
are hard to implement in hardware due to signal
The objective is to design a feedforward network to saturation, and if they are of higher order, there may be
map the functional relationship between a set of input stability problems in determining the coefficients.
points and a corresponding set of output points, or ANNs, on the other hand, are very amenable to hardware
target points. To accomplish this task, a feedforward implementation. As a matter of fact, to date, several
network, like the one shown in Figure 1, but with only VLSI chips based on multilayer neural network
one hidden layer, is considered. The input layer has nc architecture are available7,8.
4
American Institute of Aeronautics andAstronautics
R eaction Wheel Model Example Runge-Kutta (2,3) variable step size integration for
accurate, but time consuming, integration. The error
In order to illustrate the feasibility of using ANNs tolerance for the integration was set at 10-6, the
to approximate dynamic components, a model of a minimum step size set at 10-8 seconds, and the
reaction wheel assembly, consisting of three reaction maximum step size at one time sample of 1.024
wheels, one each for the roll, pitch, and yaw axes of a seconds. Note that the tight error tolerance was required
spacecraft, was selected as a test application. Figure 4 for solution accuracy. One way to speed up the
shows the block simulation was to convert the continuous-time model
into a discrete-time model, and then use discrete updates
Tcom Wheel Tact 1 Mw 30 Wsp aeqt ueavteioryn s.1 . 0H2o4w seevceorn, dass two ilpl rboep adgiastceu stsheed slaytsetre min stthaties
Friction p
Function S Jw section, the direct discrete simulation of this model
results in unacceptable inaccuracies because of the
nonlinear torque friction component.
Figure 4. Example Reaction Wheel Model.
To try to keep the speed advantage of discrete
update simulations, and still maintain reasonable
representation of a reaction wheel model in this
accuracy in the wheel model outputs, an ANN was
assembly; this model was used for all three wheels.
trained to map the functional relationship from the
This model is fairly simple in nature, and consists of
torque input command at the kth discrete time step,
the following: the input, T , is the torque command
com T (k), and wheel speed at the kth time step, W (k), to
(in units of N-m) to the reaction wheel, which is com sp
the wheel speed for the next time step, W (k+1). In
updated every 1.024 seconds; T , in N-m, is the actual sp
act other words, the wheel speed from one time step to the
torque output of the wheel, which includes nonlinear
next was approximated. Figure 5 depicts the discrete-
viscous friction torque; the wheel momentum, M ; and
w time model of the reaction wheel, with a single-hidden
the angular wheel speed, W , which is converted into
sp layer ANN (hidden layer with a tan sigmoid activation
units of revolutions per minute (RPM). The parameter
function, the output layer with a pure linear function)
J is the wheel inertia. The actual torque output of the
w computing W (k+1). A unit delay is in place to obtain
wheel, T , is the combination of the torque command sp
act the current (kth step) wheel speed.
and viscous friction torque, T , (which takes the
fric
opposite sign of that of the wheel speed W ):
sp Tcom(k) W (k+1) W (k)
T = T -T *sign(W ). (2) mux . sp z-1 sp
act com fric sp .
.

Two different nonlinear functions were used to
model the wheel friction torque: a quadratic function in Tcom(k) Wheel Tact(k)
Friction
terms of wheel speed; and an exponential function in Function
terms of wheel speed. In each case, an ANN was
designed to approximate the dynamics of the wheel.
Figure 5. Discrete reaction wheel model with an ANN.
The results are presented in the following subsections.

The friction torque computation was done the same way
Q uadratic F riction F unction
as in Figure 4. It was felt that there would be no real
In the first case, the wheel viscous friction torque
advantage gained in substituting a separate ANN to
was modeled with a quadratic function in terms of W ,
sp replace the simple quadratic friction function (Eq. 2),
which is given below:
which was a static map. Since the same model was
used for each of the three wheels in the assembly, the

same ANN could be used for each wheel.
Before the ANN for the wheel speed could be
T = 3.367176x10-5*aw
trained, the appropriate input/output training data had to
fric aw = W . (3)
+2.41045x10-6*aw2, sp be generated. To accomplish this, proper data points for
both the torque command T and wheel speed W ,
com sp
the two inputs to the ANN, had to be selected first.
The above wheel model is continuous and With this specific wheel model, the expected operating
nonlinear, and in the past, has been simulated using a range for T was assumed to be +/- 0.1 N-m, and +/-
com
5
American Institute of Aeronautics andAstronautics
300 RPM for W . To get adequate coverage of data yaw axis wheels, respectively, shown in Figure 6, were
sp
points over these ranges, the T points were taken in a series of 1.024-second-wide pulses. In addition, a
com
equally-spaced increments of 0.005 N-m, while the W small random signal was added to the pitch axis wheel
sp
points were taken in increments of 3.0 RPM. With torque command. These could be typical torque
these ranges and increments, the total number of command profiles required to counter the motions of
training input pairs (T , W ) was 8,241. The
com sp
corresponding training output, or target, points were
then computed by taking each training input pair, and
running a MATLAB (v5.0)/Simulink (v2.0) simulation
of the continuous reaction wheel model (Figure 4) over
a specified time interval [0, T ]; the wheel speed value
step
at time T was recorded as the desired target point for
step
that specific training pair. As mentioned earlier, for
this reaction wheel model, T was set to 1.024
step
seconds. Each Simulink simulation used the second-
order, three-function-evaluation-per-step Bogaki-
Shampine variable-step integration routine, the
minimum and maximum step sizes allowed were set at
10-8 and 1.024 seconds, respectively; the relative and
absolute error tolerance parameters were set to 10-6.
Each T input value was held constant over the
com
integration range [0, 1.024], while the corresponding Figure 6. Roll, pitch and yaw torque input command
W input value was entered as the initial wheel speed profiles.
sp
value (i.e., at time 0) in the pure integrator block.
After the training data was generated, the ANN scanning instruments on a spacecraft, for example. The
could now be trained. Prior to the actual ANN training, original continuous-time reaction wheel assembly
both the input and output training data were normalized model, as shown in Figure 4, was also simulated using
with respect to their absolute maximum values; by the Simulink second-order, three-function-evaluation-
keeping the training data in the [-1, 1] range, more per-step Bogaki-Shampine variable-step integration
efficient use of the ANN training routines was obtained. routine, with the minimum and maximum step sizes
The training led to a feedforward ANN with one 10- allowed were set at 10-8 and 1.024 seconds, respectively.
neuron, hidden layer (using a tan sigmoid activation The relative and absolute error tolerance parameters were
function) and a pure linear output layer. The training set to 10-6. The results of this simulation were
was performed using the standard (cid:212)trainlm(cid:213) function considered the (cid:212)true(cid:213) results, against which the other
from the MATLAB Neural Network Toolbox, which is simulations were tested. The average execution time for
based on the Levenberg-Marquardt training algorithm this (cid:212)true model(cid:213) simulation was 15.01 CPU seconds on
[Ref. 3]. Running on a Sun Ultra-2 Workstation, the the Sun Ultra-2.
training of this ANN completed in less than 2.0 Using the ANN-based model of the reaction wheel
(elapsed time) hours. The training reduced the sum assembly, two different discrete-time simulations, both
squared error (see Eq. (1)) of the ANN down to a level of running at a discrete update period of 1.024 seconds,
2.98 x 10-5, which was deemed acceptable. Once the were performed to see if meaningful reductions in
training was completed, the final ANN weights and bias simulation execution times can be achieved without
numbers were scaled back to their true values. In sacrificing accuracy down to unacceptable levels. Table
checking the accuracy of the approximation achieved by 1 contains the execution times (in CPU seconds), the
this ANN, given the training input points, the mean rms and maximum absolute errors (as compared to the
percent error between the true target points and the ANN (cid:212)true model(cid:213) results from above) for three discrete-time
outputs points was 0.063% , and only 1.07% of the simulations . First, a MATLAB function file version of
points had errors greater than 1%. the ANN-based discrete-time model was written; this
Once the ANN-based model of the reaction wheel function was executed in MATLAB v5.0. The average
assembly was developed, its performance, in terms of execution time for was 6.49 CPU seconds. In
accuracy and execution CPU time, was evaluated in comparing the wheel speed outputs from this discrete
several discrete-time simulations under a specific set of function file simulation with those from the (cid:212)true
torque command input, T , profiles. These 6000- model(cid:213), very good agreement was observed; the
com
second torque command profiles for the roll, pitch and
6
American Institute of Aeronautics andAstronautics
Table 1. Discrete-time simulation results for quadratic
friction case.
rms Max.
CPU error error
Simulation sec (RPM) (RPM)
ANN MATLAB 6.49
function
roll axis wheel 0.0011 0.0092
pitch axis wheel 0.0049 0.0790
yaw axis wheel 0.0263 0.0417
ANN MEX file 0.35
roll axis wheel 0.0011 0.0092
pitch axis wheel 0.0049 0.0790
yaw axis wheel 0.0263 0.0417
discrete MATLAB 1.71
Figure 7. Roll axis wheel speed simulation results.
function
roll axis wheel 1.8437 41.5683
Clearly, the ANN-based MEX file simulation results
pitch axis wheel 1.3968 80.6037
matched the (cid:212)true model(cid:213) results much better than did
yaw axis wheel 4.2915 63.6718
the pure discrete-time simulation results. The
combination of the nonlinearity and the rapid dynamics
root-mean-square (rms) of the errors between (cid:212)true(cid:213) and
caused by the pulse command profile made it difficult
ANN-based discrete-time simulation outputs, over the
for the pure discrete model to accurately match the (cid:212)true
length of the simulation, were 0.0011 RPM for the roll
model(cid:213) simulation, at the update period of 1.024
axis wheel, 0.0049 RPM for the pitch axis wheel, and
seconds. On the other hand, the ANN-based wheel
0.0263 RPM for the yaw axis wheel. These results
model simulations, while executing slower than the
indicated that, although acceptable simulation accuracies
pure discrete model simulation, gave much more
were achieved with the ANN-based model, the execution
accurate results. The ANN-based wheel model MEX
time speed up was only a factor of 2.3.
file simulation gave wheel output results which were
This was somewhat expected, because the friction
very comparable to the (cid:212)true model(cid:213) results, while
nonlinearity was fairly benign, i.e., the Runge-Kutta
executing about 40 times faster, which was a fairly
integration did not have to take many steps to converge
significant speed up.
to the solution. More reduction in execution time can
be achieved if another compute language is used, one
E xponential F riction F unction
with faster loop execution capability. To do this, the
In the second case, the wheel viscous friction
ANN-based wheel model simulation was written in
torque was modeled with an exponential function in
FORTRAN-77, for execution as a MEX file called by
terms of W , which is given below:
MATLAB. MEX files are dynamically linked sp
subroutines which MATLAB can load and execute like
regular MATLAB functions. T = 0.01*aw*e-0.01aw, aw = W . (4)
The third simulation was just a pure discrete-time fric sp
simulation (zero-order-hold integration, with no ANN)
of the wheel assembly, sampled at 1.024 seconds. This As in the quadratic friction function case, an ANN-
simulation was also written as a MATLAB function, based model of the reaction wheel assembly was
and executed in MATLAB v5.0. designed. Another 10-node, feedforward ANN, was
The results in Table 1 show that although the pure trained in the exact manner as reported in the previous
discrete wheel model simulation executes at a faster rate, case. Running on the Sun Ultra-2 Workstation, the
its accuracy leaves much to be desired. Figure 7. shows training of this ANN completed in less than 2.0
the roll axis wheel speed output time histories for this (elapsed time) hours. The training reduced the sum
case, from the (cid:212)true model(cid:213) Simulink simulation (top), squared error of this ANN down to 3.009 x 10-4, which
from the ANN-based model MEX file simulation was deemed acceptable. In checking the accuracy of this
(middle), and the pure discrete-time model simulation ANN, given the training input points, the percent error
(bottom). In these simulations, the initial angular between the true target points and the ANN outputs
speed of all three wheels was 250 RPM. points were 0.419% on average, and only 1.32% of the
7
American Institute of Aeronautics andAstronautics
points had errors greater than 1%. It should be noted Table 2. Discrete-time simulation results for
that the percentage numbers above did not include those exponential friction case.
target wheel speed points that were very close to zero rms Max.
magnitude, since they made the percent error CPU error error
calculations biasly inaccurate. In checking the absolute Simulation sec (RPM) (RPM)
errors, between (cid:212)true(cid:213) targets and ANN outputs for all
ANN MATLAB 6.50
8,241 points, the mean error was 0.017 RPM, and the
function 0.0007 0.0139
maximum absolute error was 0.479 RPM.
roll axis wheel 0.0014 0.0102
Again, the original continuous-time model of the
pitch axis wheel 0.0018 0.0068
reaction wheel assembly was simulated using the
yaw axis wheel
Simulink second-order, three-function-evaluation-per-
ANN MEX file 0.35
step Bogaki-Shampine variable-step integration routine,
roll axis wheel 0.0007 0.0139
with the minimum and maximum step sizes allowed set
pitch axis wheel 0.0014 0.0102
at 10-8 and 1.024 seconds, respectively. The relative and
yaw axis wheel 0.0018 0.0068
absolute error tolerance parameters were set to 10-6. The
discrete MATLAB 1.75
results of this simulation were considered the (cid:212)true(cid:213)
func. 8.6x104 2.9x105
results, against which the other simulations were tested.
roll axis wheel 233.480 394.034
The average execution time for this (cid:212)true model(cid:213)
pitch axis wheel 233.883 434.861
simulation was 65.54 CPU seconds; the higher
yaw axis wheel
magnitude and nonlinear nature of the exponential
friction model caused the Simulink integration routine
to take smaller time steps than with the quadratic Also, a pure discrete-time simulation of the wheel
friction model, thus the longer execution time. assembly (i.e., no ANN) , sampled at 1.024 seconds,
Using the ANN-based model of the reaction wheel was written for comparison with the ANN-based model
assembly, two different discrete-time simulations, both simulations. This simulation was also written as a
running at a discrete update period of 1.024 seconds, MATLAB function, and executed in MATLAB v5.0.
were performed for comparison with the (cid:212)true model(cid:213) The results in Table 2 show that although the pure
Simulink simulation. Table 2 contains the execution discrete wheel model simulation still executed at a faster
times (in CPU seconds) for three discrete-time rate (although it should be noted that its execution time
simulations, and the rms and maximum absolute errors did increase slightly, where as the ANN-based model
(as compared to the (cid:212)true(cid:213) results from above) for three simulation execution times were about the same as in
discrete-time simulations. First, the same MATLAB the previous case), its outputs were physically
v5.0 function file version of the discrete-time ANN- meaningless. Figure 8. shows the roll axis wheel speed
based model, used in the previous case, was executed output time histories for this friction case, from the
using the same torque input profiles. The average (cid:212)true model(cid:213) Simulink simulation (top), from the ANN-
execution time was 6.5 CPU seconds. In comparing based model MEX file simulation (middle), and the pure
the wheel speed outputs from this discrete function file discrete-time model simulation (bottom). Clearly, the
simulation with those from the (cid:212)true model(cid:213) Simulink ANN-based simulation results matched the (cid:212)true model(cid:213)
simulation, very good agreement was observed; the results much better, while the pure discrete-time model
root-mean-square (rms) of the errors between (cid:212)true(cid:213) and simulation results were physically meaningless for the
ANN-based discrete-time simulation outputs, over the given sampling period of 1.024 seconds. The ANN-
length of the simulation , were 0.0007 RPM for the based wheel model simulation gave wheel output results
roll axis wheel, 0.0014 RPM for the pitch axis wheel, which were very comparable to the (cid:212)true model(cid:213) results,
and 0.0018 RPM for the yaw axis wheel. The advantage while executing about 180 times faster, which was a
of an ANN-based, discrete-time wheel model was really very sizable speed up.
brought out in this case with the higher nonlinear It should be noted that in those cases where the
friction model. The ANN-based model MATLAB nonlinearity and/or rapid dynamics (relative to the
function simulation executed 10 times faster than its discrete step size) in the system are not significant, then
corresponding (cid:212)true model(cid:213) Simulink simulation, with pure discrete-time model simulation performance was
excellent results. found to be comparable to the ANN-based model
Again, to see if even more execution speed-up simulations. For example, in other tests using the
could be achieved, the ANN-based model simulation
was written as a FORTRAN-77/MEX file.
8
American Institute of Aeronautics andAstronautics
presence of significant model nonlinearity or command
input profiles which cause fast varying responses, the
ANN-based model gave accurate answers, with
computational speed-ups up to a factor of 180.

R eferences
1S. Hayden, Neural Networks: A Comprehensive
Foundation, Macmillan College Publishing Co., New
York, 1994.
2D.E. Rumelhart and J.L. McClelland, Parallel
Distributed Processing, Vol.1, MIT Press, Cambridge,
MA, 1986.
3M.T. Hagan and M.B. Menhaj, (cid:210)Training Feedfoward
Networks with the Marquardt Algorithm(cid:211), IEEE
Transactions on Neural Networks, Vol. 5, No. 6,
Figure 8. Roll axis wheel speed simulation results.
November 1994, pp. 989-993.
4K.S. Narenda, (cid:210)Adaptive Control of Dynamical
same reaction wheel model, with the wheel friction
Systems Using Neural Networks(cid:211), Handbook of
being more linear (i.e., the coefficient associated with
Intelligent Control: Neural, Fuzzy and Adaptive
the quadratic term in the viscous friction equation Eq.
Approaches, ed. by D.A. White and D.A. Sofge, Van
(2) reduced in magnitude by a factor of 1000), the
Nostrand Reinhold, New York, 1992, pp. 141-183.
differences in the ANN-based model simulation results
5K. Funahashi, (cid:210)On the Approximate Realization of
and the pure discrete-time model simulations results
Continuous Mappings by Neural Networks(cid:211), Neural
were practically negligible. The same held true for
Networks, Vol. 2, 1989, pp. 183-192.
simulations with torque command input profiles, such
6A.R. Gallant and H. White, (cid:210)There Exists a Neural
as low frequency pure sine waves, which caused only
Network That Does Not Make Avoidable Mistakes(cid:211),
slow varying time response outputs from the wheel
Proceedings of the IEEE 2nd International Conference
model. Therefore, the real advantage of ANNs is truly
on Neural Networks, 1988, pp. 657-664.
seen when the dynamic model that is to be
7M.I. Elmasry (ed.), VLSI Artificial Neural Networks
approximated is commandingly nonlinear.
Engineering, Kluwer Academic Publishers, Norwell,
MA, 1994.
C onclusions
8K. Wawryn and B. Streszewski, (cid:210)Low Power VLSI
Neuron Cells for Artificial Neural Networks(cid:211),
This paper presented a specific application of Proceedings of the 1996 IEEE International Symposium
ANNs for rapid and efficient dynamics and control on Circuits and Systems, 1996, pp. 372-375.
analysis of flexible systems. Specifically, feedforward
neural networks were designed to approximate the
dynamics of components (over prescribed input ranges),
for use in simulations as a means to speed up the
overall time response analysis process. To capture the
recursive nature of dynamic components with artificial
neural networks, recurrent networks, which used state
feedback with the appropriate number of time delays, as
inputs to the networks, were employed. Once properly
trained, neural networks gave very good approximations
to nonlinear dynamic components at a fraction of the
cost of full nonlinear dynamic integration, and by their
judicious use, have paved a way for a potential speed up
in the overall analysis process. To illustrate this
potential speed up, an existing simulation model of a
spacecraft reaction wheel system was used, first
conventionally and then with an ANN-based model in
place. Simulation results indicated that, at least in the
9
American Institute of Aeronautics andAstronautics