Korn G.A. Advanced Dynamic-system Simulation: Model-replication Techniques and Monte Carlo Simulation

Подождите немного. Документ загружается.

172 More Applications of Vector Models

also for the time. Most of the 25 simulation programs submitted for the

benchmark competition [1] solved the differential equations seven times and

then obtained logarithmic scales with a plotting program. The vectorized

DESIRE program in Figure 7-1 produces all seven solutions in a single sim-

ulation run and uses a different approach to obtain logarithmic time scaling.

We relate the computer time variable

t to the problem time

so that

= 10t – t0 (d

/dt) = ln(10)10t – t0 = tt

Multiplication of each given differential equation by tt then produces the

new differential-equation model

tt = ln10 * (10^(t – t0))

d/dt r = A * tt | d/dt m = (B – A) * tt | d/dt f = (p – Lf * f – A – 2 * B) * tt

The extra time-scaling operations must execute at each derivative call, not

only at the output points. But they serendipitously reduce the stiffness factor

(ratio of the Jacobian eigenvalues), so that our variable-step/variable-order

integration routine automatically uses larger integration steps

DT. In any

case, the exponential time factor

tt is common to all seven replicated models

and is thus computed only once per derivative call.

For logarithmic scaling of the state variable

f, the program directly plots

lgfplus1 = log e * ln(f) + 1. This assignment needs to be computed only at the

sampling points and can thus follow an

OUT statement (Section 1-6).

Vectorization is not really needed for such a small model. But compared to

the all-scalar model in Reference [2], vectorization reduced the benchmark

time by a factor of 4 with the display turned off, and by a factor of 2 with the

display on.

MODELING FUZZY-LOGIC FUNCTION GENERATORS

7-3. Rule Tables Specify Heuristic Functions

Regression, prediction, and controller-design problems all require construc-

tion of a function

y = y(x1, x2, …) that minimizes an error measure or cost.

For regression,

y = y(x1, x2, …) is a regression function designed to mini-

mize, say, a mean-square regression error (Section 6-6). In control engineer-

ing,

y = y(x1, x2, …) is a controller output that depends on inputs such as

servo error and output rate.

y = y(x1, x2, …) must minimize a dynamic-sys-

tem performance measure such as servo integral square error (Section 1-14).

Regression problems usually yield to numerical methods, but accurate

optimization of a nonlinear control system may be difficult. In either case,

–

→

scale = 2 F[1],F[2],F[3],F[4],F[5],F[6],F[7], vs. t

-- EUROSIM Benchmark PROBLEM 1

-- demonstrates model replication, log/log plot

---------------------------------------------------------------------------------------------------------------------

irule 15 | ERMAX = 0.01 | -- GEAR-type integration

ln10 = ln(10) | loge = 1/ln10 | t0 = 3 | -- shift log t

TMAX = 1 + t0 | NN = 6000 | DT = 0.0001 | scale = 2

kr = 1 | kf = 0.1 | dr = 0.1 | dm = 1 | p = 0

---------------------------------------------------------------------------------------------------------------------

-- variables and initial values for 7 replicated models

STATE r[7], m[7], f[7] | ARRAY Lf[7], F[7], A[7], B[7]

data 50,100,200,500,1000,5000,10000 | read Lf

for i = 1 to 7 | -- set equal initial values for all 7

f[i] = 9.975 | m[i] = 1.674 | r[i] = 84.99

drun

---------------------------------------------------------------------------------------------------------------------

DYNAMIC

---------------------------------------------------------------------------------------------------------------------

tt = ln10 * (10^(t-t0)) | -- log-scales time for all 7 models

Vector A = kr * m * f - dr * r | -- precompute for speed!

Vector B = kf * f^2 - dm * m

Vectr d/dt r = A * tt | -- 7 times 3 differential equations

Vectr d/dt m = (B - A) * tt

Vectr d/dt f = (p - Lf * f - A - 2 * B) * tt

------------------------------------------------------------------------------------------------------ display

OUT

Vector F = loge * ln(f) + 1 | -- logarithmic ordinates

dispt F[1], F[2], F[3], F[4], F[5], F[6], F[7]

FIGURE 7-1. Vectorized simulation program for the EUROSIM benchmark problem.

log/log plot of

f versus t for seven values of the parameter Lf (see text).

173

fuzzy-set techniques try to design y = y(x1, x2, …) heuristically by invoking

the designer’s intuition or accumulated knowledge.

First, consider a function

y = y(x) of a single input, and divide the range of

x into just a few (typically between 2 and 7) mutually exclusive class inter-

vals, which may have different sizes. The class intervals can be numbered, or

they can be given names such as

negative, positive, very negative, near

zero, or cold, warm, hot, and so on. We assign a corresponding small num-

ber of numerical function values

y(x) by specifying a rule table such as

if x is negative, then y = –1014

if x is near zero, then y = 0.2

............

Our choice of class intervals and function values, presumably based on intu-

ition or experience, defines a function

y = y(x). We can actually try this func-

tion on our regression or control problem. But

y(x) is a coarsely defined and

necessarily discontinuous step function.

One can similarly construct a function

y = y(x1, x2) of 2 inputs x1, x2. We

again divide the ranges of

x1 and x2 into class intervals (x1 and x2 can have

different class-interval numbers and/or sizes) and try to invent a two-dimen-

sional rule table such as

if x1 is negative AND x 2 is very negative then y =1200

if x1 is negative AND x 2 is near zero then y = 0

.................................

We have now defined a step function y = y(x1, x2) with two inputs. We can

add more inputs.

7-4. Fuzzy-set Logic

Fuzzy-set techniques also invoke heuristic rule tables but produce at least

piecewise-continuous functions instead of coarse step functions.

(a) Fuzzy Sets and Membership Functions

We replace our input class intervals with similarly labeled abstract fuzzy sets

x values, for example, very negative, negative, near zero, positive, and

very positive. Membership of a given input value x = X in a fuzzy set E is

defined by a nonnegative membership function

M(E | x) that measures the

degree to which the value

X “belongs” to the fuzzy set. We regard the propo-

sition that a measured value

X of x belongs to a fuzzy set E as an abstract

event with the “fuzzy truth value”

M(E | X).

174 More Applications of Vector Models

Figures 7-2 and 7-3 show examples. Note that membership functions can

overlap, which means that a value

X of x can “belong” to more than one fuzzy

set. Classical truth values associated with mutually exclusive (“crisp”) class

intervals can be regarded as special membership functions equal to 1 on a sin-

gle class interval and 0 elsewhere. Singleton fuzzy sets have membership

functions that equal 1 for a single “support value”

x = X and are 0 elsewhere.

(b) Fuzzy Intersections and Unions

We next define membership functions for (1) the abstract event that X

belongs to the fuzzy set E1 AND to the fuzzy set E2, and (2) for the abstract

event that

X belongs to the fuzzy set E1 OR to the fuzzy set E2:

M(E1 AND E2 | x)

≡

M(E1 | x) m(E2 | x) (fuzzy intersection)

M(E1 OR E2 | x)

≡

M(E1 | x) + m(E2 | x) (fuzzy union)

We call this product/sum logic.

For multiple input variables x1, x2, … we define multidimensional fuzzy sets

E by membership functions M(E | x1, x2, …). We extend product/sum logic to

relate multidimensional fuzzy sets to intersections of lower-dimensional

fuzzy sets in terms of joint membership functions such as

M(E | x1, x2)

≡

M(E1 AND E2 | x1, x2)

≡

M(E1 | x1) M(E2 | x2)

One can also define unions of fuzzy sets in the x1 and x2 domains, as in

M(E1 OR E2 | x1, x2)

≡

M(E1 | x1) + M(E2 | x2)]

(d) Normalized Fuzzy-set Partitions

N fuzzy sets E1, E2, …, EN form a fuzzy-set partition “covering” the

domain of

≡

(x1, x2, …, xn) if at least one of the fuzzy-set membership

functions

M(Ei | x) differs from 0 for every x. In the following sections, we

shall always use product/sum logic and normalized fuzzy-set partitions

whose membership functions add up to 1 for every value of

x (see also

Modeling Fuzzy-logic Function Generators 175

Union and intersections can be alternatively defined by min/max logic, as in

M(E1 AND E2 | x1, x2)

≡

min[M(E1 | x1), M(E2 | x2)]

M(E1 OR E2 | x1, x2)

≡

max[M(E1 | x1), M(E2 | x2)]

Min/max logic simplifies inexpensive fixed-point controllers but usually slows floating-point

computations.

–

–1.0 –0.5 0.0 0.5 1.0

scale = 3 x,mb1,mb2,mb3,mb4,mb5,mb6,mb7,mb8,mb9

–1.0 –0.5 0.0 0.5 1.0

scale = 3 x,mb1,mb2,mb3,mb4,mb5,mb6,mb7,mb8,mb9

FIGURE 7-2. Fuzzy-set membership functions before and after normalization, and a pro-

gram for experiments with different numbers and spacings of fuzzy sets. Note the effect of nor-

malization at the ends of the range. With increasing spacing, the un-normalized fuzzy sets

approximate singleton fuzzy sets, and the normalized fuzzy sets approximate conventional

class intervals.

-- GAUSSIAN FUZZY-SET MEMBERSHIP FUNCTIONS

-------------------------------------------------------------------------------

-- submodel for computing membership functions

ARRAY X$[1], mb$[1] | -- dummy-argument arrays

SUBMODEL fuzzmemb(N$, X$, mb$, input$)

Vector mb$ = exp(-b * (X – 2 * x)^2)

DOT sum = mb$ * 1 | ss = 1/sum | -- normalize

Vector mb$ = ss * mb$

end

--------------------------------------------------------------------------------------

scale = 3 | -- declare arrays

N = 9 | b = 10 | -- number and spread

ARRAY X[N] | -- peak ordinates

ARRAY mb[N] | -- limiter functions

-- define fuzzy-set spacing

x0 = - scale

for i = 1 to N | X[i] = (I^2 - N)/N + x0 | next

--------------------------------------------------------------------------------------

NN = 10000 | TMAX = 1 | DT = 0.0001

x = - scale | drun

--------------------------------------------------------------------------------------

DYNAMIC

--------------------------------------------------------------------------------------

d/dt x = 2 * scale | -- display sweep

invoke fuzzmemb[N,X,mb,x)

Vector mb = 6 * mb - scale | -- scaled, offset display

Modeling Fuzzy-logic Function Generators 177

–

–1.0

scale = 1 x,mb4,minusmb5,member[4]

–0.5 0.0 0.5 1.0

FIGURE 7-3

. Generating a triangle function as a difference of two limiter functions

(S. Geva and J. Sitte, IEEE Trans. Neural Networks, 3, 1994, pp. 622–624).

–

–1.0 0.0 0.5 1.0

scale = 1.33333 x,mb1,mb2,mb3,mb4,mb5,mb6,mb7,mb8

–0.5

FIGURE 7-3

. N overlapping triangle functions form a very useful normalized fuzzy-set

partition.

Section 7-7). This implies that all our membership functions range between

0 and 1.

Membership functions of normalized partitions for individual variables

x1, x2, … and for combinations of such variables can be simply multiplied to

define normalized partitions of higher-dimensional domains.

7-5. Fuzzy-set Rule Tables and Function Generators

Rule tables can relate output fuzzy-set memberships rather than numerical

values to input fuzzy-set memberships, for example, if

x is very positive then

y is hot. One can then define fuzzy-set membership functions M1(Ei1 | x1),

M2(Ei2 | x2), … for each function-generator input x1, x2, …, membership

functions

M(Ei | y) for the function-generator output y, and joint input–output

membership functions

M(Ei1, Ei2, ...; Ei | x1, x2, ...; y) = M1(Ei1 | x1) M2(Ei2 | x2) ... M(Ei | y)

with i1 = 1, 2, …, N1; i2 = 1, 2, …, N2, …; i = 1, 2, …, N. The fuzzy-set parti-

tion sizes

N1, N2, …, N are usually small (between 2 and 7).

We now define a different type of rule table, namely, an (

N1 N2 … N)-

dimensional vector whose components, similar to those of

M(Ei1, Ei2, ...; Ei

| x1, x2, ...; y) can be ordered by their index combinations i1, i2, …, i. We

heuristically set the rule-table entries to 1 or 0 when we consider the corre-

sponding input–output combination as possible or impossible. These rules

normally associate a single fuzzy set in the output domain with each combi-

nation of input sets, but each output set can be selected by more than one

input combination.

The resulting fuzzy output set is the fuzzy union of all joint fuzzy

input–output sets that are not eliminated by the rule table. With

product/sum logic, tts membership function

P(y) is the sum of the corre-

sponding joint membership functions

M(Ei1, Ei2, ...; Ei | x1, x2, ...; y). This

is all fuzzy logic can tell us about

y. Obtaining a usable “crisp” function-

generator output

y(x1, x2, …) requires a heuristic defuzzification assump-

tion such as

y = (centroid defuzzification)

∫

YP(Y )

ᎏᎏ

∫

P(Y )dY

178

More Applications of Vector Models

In this context, we can define the logical complement E

⬘

of E by its membership function

M(E

⬘

| x) = 1 – M(E | x).

Note that this requires product/sum logic.

or alternatively

y = ymax where P(ymax) is a maximum of P(y)

(maximum defuzzification)

Here, integrals and maximum are taken over the range of y. Such tech-

niques are further discussed in Reference [3].

7-6. Simplified Function Generation with Fuzzy Basis Functions

The general fuzzy-set technique outlined in Section 7-5 is complicated and

involves rather arbitrary defuzzification assumptions. Although DESIRE

allows programming this general method [4], many practical regression and

controller-design problems yield to a much simpler procedure.

Assume that we have a normalized fuzzy-set partition of the input-variable

domain and a rule table that assigns a “crisp” function output value

y[i] (not

an output fuzzy set) to each fuzzy set

Ei of the input-variable partition. We

then employ the weighted sum

y(x) = y[1] M(E1 | x) + y[2] M(E1 | x) + … + y[N] M(EN | x) (7-1)

as a regression or controller function designed to “fit” our rule table.

x can be

a multidimensional set of variables

x ≡ x1, x2, …, xn [14].

The

N normalized fuzzy-set membership functions mb[i] = M(Ei | x) are often

called fuzzy basis functions. Section A-2 in the Appendix describes their appli-

cation to neural networks, where they are used much like radial basis functions

(Section 7-13). The function-generator output

y(x) is determined by the heuris-

tic rule-table entries

y[i] and by the number and shape of the fuzzy basis func-

tions, which are normally continuous or piecewise continuous functions of

7-7. Vector Models of Fuzzy-set Partitions

(a) Gaussian Bumps—Effects of Normalization

We begin with functions of a one-dimensional argument x. To generate N

bump-shaped fuzzy basis functions mb[1], mb[2], …, mb[N] centered on N

given values X = X[1], X[2], … of x, a DESIRE program can declare vectors

X and mb with

ARRAY X[N], mb[N]

Modeling Fuzzy-logic Function Generators 179

With random input x, one can consider the N fuzzy-set memberships as abstract random

events with conditional probabilities

M(Ei | x). The expression (7-1) is then the expected value

y[i]. This, in fact, models a well-known hardware technique, namely, function-generator

interpolation using dither-noise injection and averaging.

and assign X[i] values in the experiment-protocol script. The DYNAMIC-

segment lines

Vector mb = a * exp(- b*(X – x)^2)

DOT sum = mb * 1 | ss = 1/sum | Vector mb = ss * mb

then produce N Gaussian bumps and divide them by their sum to normalize

them (Fig. 7-2). The effect of normalization on the first and last fuzzy-set

membership function is realistic and intuitively plausible. The normalized

Gaussian bumps in Figure 7-2b have different amplitudes since they have the

same “spread” parameter

b but are not uniformly spaced. In the following

sections, we exhibit membership functions whose spread changes with their

spacing [13, 14].

(b) Triangle Functions

Suitably overlapping triangle-shaped functions mb[i] with unity peaks at x =

x[1], X[2], …, X[N] (Fig. 7-3b) produce particularly useful normalized fuzzy-

set partitions. They can implement exact linear interpolation between adja-

cent rule-table function values.

To generate the desired triangle functions of the input

x, we first use index

shifting (Section 3-6) to create

N limiter functions (Section 2-8a)

Vector mb = SAT((X – x)/(X – X{1}))

Vector components with index values shifted below 1 and above N are auto-

matically replaced by zero, and we save the two end values

Mbb = mb[1] | mcc = mb[N – 1]

for use later in the program. Pairwise subtraction of index-shifted limiter

functions with

Vector mb = mb{–1} – mb

(Fig. 7-3a) then produces the desired N overlapping triangle functions mb[i]

if we overwrite mb[1] and mb[N] with

mb[1] = 1 – mbb | mb$[N] = mcc

This algorithm is twice as fast as the original algorithm in References [4]

and [5] and also uses only half the memory required by the earlier program.

180 More Applications of Vector Models

The procedure can be stored as a library submodel (Section 3-17):

ARRAY X$[1], mb$[1] | -- dummy-argument arrays

SUBMODEL fuzzmemb(N$, X$, mb$, input$)

Vector mb$ = SAT((X$ - input$)/(X$ - X${1}))

mbb = mb$[1] | mcc = mb$[N$ - 1]

Vector mb$ = mb${-1} - mb$

mb$[1] = 1 – mbb | mb$[N$] = mcc

end

for function generation, regression, and control-system simulation

(Section 7-9).

It is easy to replace the piecewise-continuous triangles in Section 7-7b with

differentiable functions. The soft-limiting DESIRE library function

sigmoid(q)

≡

1/(1 + exp(– q))

should be used instead of the hard-limiting SAT(q) function in Section 7-7b

(Fig. 7-3a). In regression applications, such nonlinear curve fitting may allow

using fewer basis functions. The membership-function shape had almost no

effect on the controller in Section 7-9.

7-8. Vector Models for Multidimensional Fuzzy-set Partitions

Given normalized fuzzy-set partitions for each of two independent input vari-

ables

x1, x2, with arrays (vectors) of membership functions

Modeling Fuzzy-logic Function Generators 181

–

–1.0 0.0 0.5 1.0

scale = 1.33333 x,mb1,mb2,mb3,mb4,mb5,mb6,mb7,mb8

–0.5

FIGURE 7-4. A normalized fuzzy-set partition obtained with differences of soft limiter

functions.