------------------- ASCII.ASC follows --------------------
[Hans Blom, 970116]
On Another (?) Test for Control
Very succinct abstract: Testing whether a system is controlled is
mathematically equivalent to modelling that system.
How do we get to know the world -- or any other system -- out there?
The answer of the science called Systems Identification is: conduct
experiments. To be more specific: act on the thing ("system") that you
want to get to know and observe how it reacts. The hope is that the
relationship between the actions on and the reactions of the system
can be characterized by a few parameters only. If so, these parameters
characterize (the knowledge that is obtained about) the system. An
example: what is an object's color? An identification procedure might
be to shine monochromatic light of various wavelengths on the object
and measure the intensity of the reflected light. The amplitudes of
the reflections at different wavelengths collectively describe the
object's color.
There is probably not a single physical system that can be fully
described by just a few parameters: we are only able to construct
models, approximations of the real thing. Yet, these approximations
can be as complete and accurate as we want them to be, by modelling
ever more details. Yet, modelling these details conflicts with our
other goal of characterizing our knowledge with _as few parameters as
possible_. We prefer simple models, because we can _use_ them more
easily.
But how simple can the model be? In general, that depends on the
application, on what the model is used _for_. Frequently, to our
surprise, a simple model will do. Newton, for instance, demonstrated
that if it is our goal to know the gravitational attraction between
two "bodies", a model only needs the masses of those two bodies and
their distance, and _not_ those bodies' size, surface temperature,
luminosities or whatever.
Systems Identification provides a general answer (within a given
context): try out a range of models, and pick the "best" one using the
dual criteria of model fit (how well does the model describe the data)
and model economy (how many parameters does the model have). This is
most easily explained if we assume that the system is linear and time-
invariant (this assumption can later be tested, and if it is incorrect
a more complex model could be chosen). A schematic diagram of a
general single input single output (SISO) system is:
···
----------
u (k) | | y (k)
----->| system |----->
> >
----------
where u (k) is the system's input at time k and y (k) is the system's
response at time k. By sampling the input and output at regular time
intervals 0, 1, ..., k, k+1, ..., a general description results in the
form of a difference equation; if we observe continuously, we get
differential equations. A discussion in terms of difference equations
is simpler.
How do we model the system? Well, the general idea is that the
system's output somehow depends on its input. It is the "somehow" that
we have to determine. There are a lot of different methods, all
mathematically (more or less) equivalent, so I'll describe the
simplest, the "finite impulse response" (FIR) method. In order of
complexity from simplest to more complex, descriptions of possible
models would be
y (k) = a (order 0)
y (k) = a + b * u (k) (order 1)
y (k) = a + b * u (k) + c * u (k-1) (order 2)
y (k) = a + b * u (k) + c * u (k-1) + d * u (k-2) (order 3)
etcetera, where a, b, c, d, ... are constants. You get the idea. The
constants are initially unknown, but they can be estimated, e.g. using
a least-squares ("curve fitting") method. All we have to do is to
collect a sufficiently large set of input and output values and let
the least squares method do its work (either in a batch mode or real-
time/on-line). It will present us with the unknowns a, b, c, d... Once
we have these, we can use those same models to generate predictions,
using the formulas
ym (k) = am (order 0)
ym (k) = am + bm * u (k) (order 1)
ym (k) = am + bm * u (k) + cm * u (k-1) (order 2)
ym (k) = am + bm * u (k) + cm * u (k-1) + dm * u (k-2) (order 3)
where the constants am, bm, ... are the results of the least-squares
estimation procedure, and ym is the model's prediction. Depending on
the order of the model, the (average squared) difference between y (k)
and ym (k) will vary. If the order is high enough and the model is
good, differences will be small.
The order 0 model is probably pretty bad, at least if the input has a
significant and consistent effect on the output -- which is not
necessarily always the case. The order 1 model might be a little bit
better, and the order 2 model even better than that. Practice shows
that, starting from a certain "high enough" model order, the model
predictions hardly improves anymore. In that case we stop, and, if the
model's predictions are sufficiently accurate compared to the response
of the real system, we accept the model as our "knowledge" of the
system. If not, we pick a different type of model (e.g. one including
nonlinearities), construct a corresponding sequence of ever more
complex models, and try again. Once we have a good enough model, we
can use it, e.g. in model-based control.
All of this is probably pretty familiar to you. Now comes the thing
that may be new. In the above model, we have used the inputs u (k) as
the independent variables and the outputs y (k) as the dependent
variables. This is called a "forward" model, and in the example above
it described what is called the system's "impulse response". But there
also exists a "backward" model, in which independent and dependent
variables change places. The models to be tried out are now:
u (k) = a (order 0)
u (k) = a + b * y (k) (order 1)
u (k) = a + b * y (k) + c * y (k-1) (order 2)
u (k) = a + b * y (k) + c * y (k-1) + d * y (k-2) (order 3)
etcetera, where a, b, c, d are again constants (but different ones!).
These relationships now describe HOW u DEPENDS ON y! If it does not,
i.e. if u is truly independent of y, no higher order model will turn
out to be significantly better than a model of order 0. This is easy
to understand: if u does not depend on y in any (possibly time-
shifted) way, it will also not depend on earlier values of y (and,
moreover, constants b, c, d... will all turn out to be zero as well).
If, however, u DOES somehow depend on y, there is what we have learned
to call _feedback_ (from y to u) and thus we have a control system!
(Footnote: One might pose additional requirements for calling the
feedback thus discovered "control", such as a high enough loop gain).
Moreover, the estimates of the parameters a, b, c, d... present us
with the "control law", i.e. the way in which u (the control system's
"action") is "computed" based on y (what PCT calls the control
system's "perception"). The procedure to establish whether control is
present is obvious: establish whether higher order models give
improved predictions (note that u, the "action", is predicted in this
case!). Clearly, if the "action" cannot be predicted from the
"perceptions" in any way, there is no feedback/control. The procedure
to discover the governing control law is clear as well: increase the
backward model order until a higher order model does not give improved
(more accurate) predictions anymore.
The procedure to establish whether a variable y is controlled is thus
as simple as can be: collect a sequence of u/y values and find out
whether u depends on y. Or is this "nothing but" a formalization of
The Test?
The above is an informal description of some aspects of a paper by
Niu, Fisher, Ljung and Shah "A Tutorial on Multiple Model Least-
Squares and Augmented UD Identification" (1995), a Postscript version
of which can be found by connecting to
http://ankeborg.isy.liu.se/cgi-bin/reports
This paper describes a method to simultaneously discover all forward
and backward models (of a variety of types) up to a maximum chosen
model order in a very efficient way. It describes both batch (off-
line) and real-time (on-line) algorithms. The latter can be used in
model-based/adaptive control.
A nice connection of papers on many aspects of Systems Identification
can be found at this address as well, including a general tutorial on
Systems Identification.
Greetings,
Hans