Preference-Directed Design1 Joseph G. D’Ambrosio & William P. Birmingham2 Dept. of Electrical Engineering and Computer Science The University of Michigan Ann Arbor, MI 48109 USA
Abstract Current design practices mandate that engineering designs be evaluated based on multiple attributes, e.g., cost, power, and area. For multi-attribute design problems, generation and evaluation of the Pareto optimal set guarantees the optimal design will be found, but is not practical for a large class of problems. Iterative techniques can be applied to most problems, but sacrifice optimality. In this paper, we introduce a new technique that extends the set of design problems that can be solved optimally. By first constructing an imprecise value function, the number of non-dominated alternatives that must be generated is reduced. We describe an implementation based on combinatorial optimization and constraint satisfaction which achieves additional performance gains by decomposing the value function to identify dominated design-variable assignments. Test results indicate that our approach extends the set of problems that can be solved optimally.
1 Accepted for publication
by AI EDAM, Journal for Artificial Inelligence in Engineering
and Manufacturing, 12/94. 2 Contact Author Information
email:
[email protected] Phone: 313-936-1590 fax: 313-763-1260
1
Design, Analysis
1.0 Introduction Over recent years, engineering organizations have extended the process of design to include a number of new practices. Quality-function-deployment (King & Akao, 1989) translates customer preferences for product features into terms appropriate for the design process. Pugh's selection method (Pugh, 1990) provides a high-level means to generate and evaluate design alternatives. Concurrent engineering (Peihua & Andrew, 1993) integrates overall knowledge, resources, and experience of a company into the design cycle as early as possible. We believe the overall thrust of these techniques is to identify a set of attributes that characterize how valuable the end design will be to the design organization, and to maximize the value of the design based on these attributes. For example, consider Pugh's selection method. All known design alternatives are identified and then evaluated based on number of different attributes (product features). The attributes used for evaluation are complete in the sense that they reflect the impact of an alternative on product design, manufacturing, sales, etc. Alternatives that score well are evaluated in detail, and an attempt is made to merge these alternatives to create a new, more desirable alternative. Thus, the value of the end product is maximized by enumerating all feasible alternatives and choosing the one that best satisfies overall organizational concerns. In this paper, we describe preference-directed design, a decision-theoretic approach for multiattribute design. Preference-directed design generates an imprecise value function based on a set of preferences statements that reflect the relative importance of each attribute. Preference-directed search identifies the optimal design by decomposing the value function to facilitate dominance checks between design-variable assignments, and by performing constraint propagation to bound the search process. Section 2 describes previous work in the area of multi-attribute design. Section 3 defines preference-directed design, and Section 4 describes several application examples. Finally, Section 5 presents a summary and a discussion.
2.0 Traditional Approaches to Multi-Attribute Design To solve a multi-attribute design problem, it is often formulated as a mathematical program or as a constraint-satisfaction problem. Once the formulation is completed, the entire Pareto-optimal set of designs may be generated, or an iterative technique can be applied to attempt to identify a good solution. In this section, we review both problem formulation and solution techniques. Table 2.1 gives the notation developed in this paper.
2
X,
∆xk
Tuple of n design variables, X = (x1,x2,...xk,xk+1,...xn), where variables 1 to k measure the k attributes to be optimized; the difference in attribute k between two alternatives. D Tuple of domains for design variables, such that xn ∈dn . R, rk(X), rnk(xn) Set of constraints; constraint for attribute k, such that xk = rk(X); constraint for xn that calculates the contribution of xn to attribute k. z(X) Objective function or search heuristic S Set of solutions. PX, PS A partition of X; set of partition solutions. w k , W’ Weight associated with attribute k; subspace of weight values. v k (x k ), V, ∆vk Value of attribute k; set of attribute values, V = {v1(x1), v2(x2),...vk(xk)}; difference in the value of attribute k between two alternatives. v(V), v(ai), ∆v Value of an alternative; value of alternative i; difference in the value between two alternatives. vn(xn), ∆vn , Contribution of xn to v(V); difference in contribution of xn to v(V) between two alternatives. vnk(xn), ∆vnk Contribution of xn to vk(xk); the difference in the value of attribute k for two alternatives due to xn. m k , mk (x k ), b k, m k (x k ) Slope of a linear value function; slope at a given point; y intercept; y intercept projected using slope mk(xk) from point corresponding to x k . xi n , X Assigned level of variable xn for alternative i; tuple of assigned design variables,
X = ( x1 , x2 ,..., xn ) .
Table 2.1: List of symbols. 2.1 Problem Formulation A mathematical-programming (Nemhauser, Kan, & Todd, 1989) formulation of a design problem includes: • a tuple of n design variables, X = (x 1 , x 2 , ...x k , x k+1 , ...x n ), where variables 1 to k measure the k attributes to be optimized • a tuple of n domains, D = (d1, d2, ..., dn), such that xi ∈ di • a set of constraints among design variables, R = {r1, r2, ..., rm}, that restrict the domains of the variables • an objective function, z(X), to evaluate the desirability of a design alternative Integer-valued design variables select the topology of the design, and real-valued design variables select design parameters. For topology decisions, a variable value of one indicates that a component should be used, while a zero value indicates it should be omitted. By setting up appropriate constraints between integer design variables, different topologies can be considered. A
3
wide range of constraints can be supported, including if-then constraints between integer design variables (Grossmann, 1990) . The majority of single-attribute design problems can be formulated and solved as mixed-integer non-linear programs (Grossmann, 1990) as follows: Minimize z(X) = x1 Subject to: R x 1 ...x i ∈ ℜ x i+1 ...x n ∈ {0,1} where the non-linearities are present in the real variables, and x1 measures the level3 of a single attribute, such as cost. Mathematical programming for design has been applied to the fields of electronic engineering (Gebotys & Elmasry, 1993; Hafer & Parker, 1983; Lee, Hsu, & Lin, 1989) , chemical engineering (Grossmann, 1990; Pekny, 1992) , and mechanical engineering (Vanderplaats & Sugimoto, 1985) . Techniques for formulating multi-attribute (multi-objective) mathematical programs include weighted evaluation function, goal programming, and compromise (Murty, 1983; Yu, 1989) . A weighted evaluation function combines the level of attributes into a single objective function by using a weighted sum of attribute levels: z(X) = ∑ wk xk
(2.1)
k
The relative importance of one attribute versus another is determined by relative levels of the weights. In goal programming, constraints are assign goals for attribute levels, and slack and surplus variables measure deviation from these goals. The objective function, which is minimized, is a weighted summation of slack and surplus variables, with the relative levels of the weights specifying the relative importance of the goals. The compromise approach attempts to minimize the distance from an ideal state. The compromise approach often fails, since there is no guarantee that the design alternative closest to the ideal will be optimal (Yu, 1989) . The main limitation of a weighted evaluation function and goal programming is the difficulty in correlating weight levels to the solutions produced: the
3 When discussing the value of an attribute, we use “level” to refer to the raw value of the attribute, a n d use “value” only to refer to the output of the attribute’s value function.
4
process for assigning levels to weights does not guarantee the optimal design alternative will be identified. Another common approach is to formulate the design task as a constraint-satisfaction problem (Mackworth, 1987; Mittal & Falkenhainer, 1990) The formulation of a constraint-satisfaction problem is as follows: • a tuple of n design variables, X = (x 1 , x 2 , ...x k , x k+1 , ...x n ), where variables 1 to k measure the k attributes to be optimized • a tuple of n domains, D = (d1, d2, ..., dn), such that xi ∈ di • a set of constraints among variables, R = {r1, r2, ..., rm}, that restrict the domains of the variables • a heuristic to guide the search process Design variables represent design parameters and functions. Different topologies can be described through the use of dynamic constraints and variables, such that as design variable assignments are made, constraints and variables are activated and deactivated to reflect the topology under consideration. Examples of the constraint-satisfaction approach include COSSACK (Mittal & Frayman, 1987) , MBESDSD (Wu & al., 1990) , and MICON (Birmingham, Gupta, & Siewiorek, 1992) . MICON and MBESDSD use a weighted evaluation function as a search heuristic, therefore reducing the multi-attribute optimization problem to a single-objective-function problem. As stated previously, there is no guarantee that the optimal design will be found when a weighted evaluation function is used. Thus, a major difficulty with multi-attribute design problems is the formulation of the objective function or search heuristics. Improving the level of one attribute is usually only achieved at the expense of other attribute levels. Trade-offs must be made among the attributes, but the exact information required to make such trade-offs is rarely available. One way to address such a problem is to generate the Pareto-optimal set of designs and select the alternative that best meets organizational goals. 2.2 Generation of the Pareto-Optimal Set An alternative ai is Pareto preferred to alternative aj if all attribute levels of ai are better than or equal to those of aj, with at least one being strictly better. An alternative dominates another if it is preferred. The set of non-dominated alternatives based on Pareto preference is the Pareto-optimal set. Identification of the Pareto-optimal set is also known as vector minimization (Murty, 1983) . The optimal design is guaranteed to be in the Pareto-optimal set. The Pareto-optimal set is usually found by enumeration or by repeated optimization based on a single attribute while changing the
5
bounds on others. GOPS (Haworth & Birmingham, 1993) produces the Pareto-optimal set of designs for electronic system problems using a combinatorial-optimization technique. Bradley and Agogino (1993) use Pareto plots to choose components from a catalog. Once the set of Pareto-optimal alternatives is found, the alternatives are evaluated, and the best one chosen. Thurston (1991) demonstrates the application of multi-attribute decision making for selecting the best design alternative. The utility of each design alternative is evaluated, and the one that maximize utility is chosen. Evaluation based on utility analysis requires detailed quantitative analysis, which may be difficult if a design problem has a high degree of imprecision, such as during the early stages of the design process. Wood et al. (1990) note the difficulties involved in using utility analysis when most design information is incomplete. An alternative approach is fuzzy analysis (Wood & Antonsson, 1989) , which allows evaluation based on qualitative information. Fuzzy calculations are simpler than those based on probability, which is required by utility analysis. In theory, a mathematical programming or constraint-satisfaction tool that identifies Pareto optimality could be used for optimal design. Once the set is identified, utility or fuzzy analysis could be used to select the optimal alternative. Unfortunately, the Pareto-optimal set is often extremely large (Murty, 1983) , making generation of the entire set impractical. Artificial constraints can be added to reduce this set to a manageable size, but adding these constraints may eliminate the optimal solution from the feasible set. 2.3 Iterative Techniques Mathematical programming and constraint satisfaction can be incorporated into an iterative design process, such as the one given in Figure 2.1. Iterative techniques can be applied to most problems, but they do not guarantee optimality. Domain knowledge describing the problem to be solved and the available technology is captured and used to generate a design-space description for the problem solver. The description includes design variables (X), constraints (R), and an objective function (z). The problem solver explores the set of possible design solutions, and identifies a solution (s) that is optimal in some sense. If the solution is acceptable, the design process terminates, otherwise it is repeated with additional domain knowledge. A key aspect of iterative design is how iterations are performed. Relating inputs to outputs is critical for determining how to modify the objective function for the next iteration. Fuzzy analysis (Wood & Antonsson, 1989) allows the level of preference for an input variable to be directly related to an output variable. Thurston and Carnahan (1992) show that utility analysis can also be used, and they argue that utility analysis is superior in all but the earliest design stages.
6
Iterative_Design(in: X, R, z; out: s) { repeat { ExecuteProblemSolver(in: X, R, z; out: s); if (Acceptable(in: s)) exit; else Modify(in/out: R, z); until (TimeLimitReached()); }
Figure 2.1: An iterative algorithm for engineering design.
3.0 Preference-Directed Design In this section, we describe our optimal design approach: preference-directed design. Compared to the design techniques previously discussed, preference-directed design facilitates multi-attribute decision making while minimizing the enumeration and evaluation of design alternatives. An imprecise value function is created by ranking a random sample of design alternatives. Preferencedirected search, which decomposes the value function for decision making, uses combinatorial optimization and constraint propagation to explore the design space and identify the optimal solution. PD_Design(in: X, R, D; out: S) { GenerateRandSample(in: X, R, D; out: S); RankSample(in: S; out: V); BuildConstraintNetwork(in: X, R, D); StaticPartitioning(in: X, R; out: PX); for each pxi ∈ PX { PD_Search(in: px i, v; in/out: ps i, D); CombinePartitions(in: PS, out: S); }
Figure 3.1: Preference-directed design algorithm Figure 3.1 describes the preference-directed-design algorithm. Domain knowledge defines design variables (X), variable domains (D), and constraints (R). By making random variations in an objective function, GenerateRandSample creates a random sample of feasible designs, S, where each design is characterized by a set of non-commensurate attributes. RankSample is an interactive procedure for specifying attribute value functions and ranking the elements in the sample. The sample is either totally or partially ordered from pair-wise comparisons between elements in the set. The attribute value functions and preferences among sample elements imply an imprecise value function, v, which measures design value during problem solving (see Section 3.1). BuildConstraintNetwork generates a constraint network for constraint propagation during search (design) (Mackworth, 1987) . StaticPartitioning examines the constraint connections among design variables, and divides X into sets, P1, P 2 ,...,P i , forming independent sub problems, if possible
7
(see Section 3.2). Preference-directed search, PD_Search, finds solutions for each partition (see Section 3.3). CombinePartitions integrates partition solutions into the final set of solutions. The lack of iteration in Figure 3.1, as compared to the design process in Figure 2.1, emphasizes that preference-directed design provides a rational process for defining the problem-solver’s objective function. In the following, we first provide the definition of an imprecise value function. Next we describe how constraint-graph analysis identifies partitions and unconstrained variables. Finally, we introduce preference-directed search, and discuss how the value function is decomposed into a set of design variable value functions. 3.1 Imprecise Value Function Decision theory defines the conditions when a single-valued utility function can be used for decision making (Fishburn, 1970) . The preference relationship between alternatives must be asymmetric and negatively transitive. The utility function creates a weak order over all possible alternatives. In this paper, we restrict our discussion to decisions made under certainty. Following common practice, we refer to the utility function as a value function for this case. For multi-attribute decision making, it is possible to use a weighted sum of attribute value functions as a multi-attribute value function. Thus, the value of an alternative with k attributes is given by: v(V ) = ∑ wk vk ( xk )
(3.1)
k
where w k is the tradeoff weight for attribute k, and v k (x k ) is the value produced by the value function of attribute k. Keeney and Raiffa (1976) describe the process for determining the attribute value functions and tradeoff weights. This form of the multi-attribute value function requires that the attributes be mutually, preferentially independent. An attribute k is preferentially independent if the weak order specified by v k (x k ) is independent of the level of other attributes. A set of attributes is mutually, preferentially independent if every subset of these attributes is preferentially independent of its complementary set. A physical relationship may exist between preferentially independent attributes (i.e., a constraint r ∈ R ); it is only required that the preference order for attribute levels be independent of the others. The amount of quantitative analysis required to identify the optimal alternative can be reduced by using an imprecise value function. Imprecisely Specified Multi-Attribute Utility Theory (ISMAUT) 8
(White & al., 1984) creates a partial order based on preference relationships among a subset of alternatives. ISMAUT uses a weighted sum of attribute values. Thus, the value of alternative ai is given by Eqn. 3.1. A preference statement of the form “ai is preferred to aj” implies an inequality in the space of possible weights according to the following relation:
∑ w [v ( x ) − v ( x )] ≥ 0 k
ik
k
jk
(3.2)
k
k
According to this interpretation, the statement that ai is preferred to aj means that the tradeoff weights are such that the total weighted value of ai is at least as great as that of aj. Direct pair-wise preferences among attributes also translate to inequalities, such as: w power ≥ wdollars Furthermore, all weights must be positive and their sum must be unity: ∀k, wk ≥ 0
(3.3)
∑w
(3.4)
k
=1
k
All these inequalities confine the weight space to a subspace, W’, that satisfies the inequalities. Thus, from pairwise-preference statements, ISMAUT determines ranges of attribute weights consistent with designer’s preferences. The imprecise value function v(V) can order pairs other than those specified by the designer: ai is preferred to aj if, for every possible vector of weights within W’, the value of ai is greater than the value of aj, i.e., Min
∑ w [v ( x ) − v ( x )] ≥ 0, k
ik
k
jk
k
wk ∈ W ′
k
This relation can be tested for every pair of alternatives that the designer has not already stated a preference. Thus, the preferences specified by a designer create a partial order over all design alternatives, and this partial order can identify the non-dominated set of design alternatives. The following example illustrates how implicit preference relations can be derived.
9
Assume that a1 and a2 are a random sample of feasible alternatives (see Table 3.1), and that v k (x k ) = xk. Since Table 3.1 specifies a2 is preferred to a1, v(a2) - v(a1) ≥ 04. Substituting into Eqn 3.2, [v1(a2) - v1(a1)] w1 + [v2(a2) - v2(a1)] w2 + [v3(a2) - v3(a1)] w3 ≥ 0 and using the levels for fi(aj) given in Table 3.1 yields: [0.5 - 0.75] w1 + [0.0 - 1.0] w2 + [0.8 - 0.4] w3 ≥ 0 -0.25 w1 + -1.0 w2 + 0.4 w3 ≥ 0 This constraint and the constraints given by Eqn. 3.3 and Eqn. 3.4 define the imprecise value function.
Alternative
x1
x2
x3
a1 a2 a3 a4
0.75 0.5 0.0 1.0
1.0 0.0 1.0 0.0
0.4 0.8 1.0 0.0
Preference Order 2 1 (highest) 4 (lowest) 3
Table 3.1: Feasible alternatives for an example design problem. From the imprecise value function, it can be determined that a2 is preferred to a4. For a2 to be preferred to a4, it must be true that: Min v(a2) - v(a4) ≥ 0 Solving the following linear program gives a positive value for Min v(a2) - v(a4): Minimize z(X) = v(a2) - v(a4) Subject to: -0.25 w1 + -1.0 w2 + 0.4 w3 ≥ 0 ∀k, wk ≥ 0 ∑ wk = 1 k
Thus, it can be concluded that a2 is preferred to a4 without a preference stated about them.
4 v ( a ) is the value of alternative i. i
10
ISMAUT provides the means to partially order a set of alternatives using a small set of preference statements, and thus identify a set of non-dominated alternatives guaranteed to contain the optimal one. This partial order is stronger than Pareto preference, in that there will be fewer alternatives in the final non-dominated set. In fact, without any preference statements, ISMAUT will produce the Pareto-optimal set. Although only a small set of preference statements is needed for ISMAUT, dominance checks between all feasible alternatives are still required to guarantee the optimal one will be found. To solve this problem, we use the imprecise value function to prune inferior paths during design-space search. Many design alternatives can be eliminated from consideration before they are fully constructed, thus reducing the complexity of the design process. 3.2 Identifying Partitions and Unconstrained Variables Constraint-graph analysis is the process of examining the feasibility dependencies between design variables. A graph describing the dependencies can be constructed where the nodes are design variables and the arcs are constraints. Problem decomposition can be achieved by partitioning the graph such that nodes connected by arcs are placed in the same partition. For the constraint graph given in Figure 3.2, StaticPartitioning (see Figure 3.1) divides the design variables into three subsets, {x1, x2, x3}, {x4, x5}, and {x6}. Design decisions related to feasibility for a subset can be made independently from the assignment of variables in other sets, since there is no constraint connecting them. The third subset, {x 6 }, is a special case, because it contains only one variable. The variable in this subset, x 6 , is unconstrained, since the feasibility of the assignment does not depend on the assignments of any other variables. As described later, identification of unconstrained variable increases the ability to perform dominance checks Dynamic constraint-graph analysis improves problem decomposition during search. For the graph given in Figure 3.2, the domains of variables x2 and x3 are constrained via constraints r1 and r2, respectively, by the assignment of x1. If the current state of the search process is such that x1 has been assigned, then the feasible domains for x2 and x3 cannot be impacted by any additional assignments. Domain-consistency checks can be performed between x1and x 2, and between x1 and x3 to identify the assignments of x2 and x3 that are consistent with the assignment of x 1 . With their domains limited, x2 and x3 become unconstrained variables. Similar to the methods proposed by Dechter and Pearl (1987) , dynamic constraint-graph analysis can be used to order the assignments of variables during search such that the number of unconstrained variables encountered along a search path is maximized.
11
r1
x2
r3
x1
x3
x4
x5
x6
r2 Figure 3.2: Constraint graph with variables x1,...,x6 and constraints r1,r2,r3 3.3 Preference-Directed Search Search algorithms, such as branch and bound, enumerate sets of solutions, hopefully pruning search paths to make the process tractable. For design problems, two classes of pruning checks are performed: feasibility checks and dominance checks. Feasibility checks use constraints, and are typically performed by a constraint network. Dominance checks remove preferentially inferior solutions from the search space. For branch and bound, if the best case cost of a partial solution is dominated by the cost of an existing solution, then the partial solution is no longer pursued. Preference-directed search differs from other search techniques in that it uses ISMAUT to create a global, multi-attribute value function to order alternatives based on designer’s preferences. In addition to performing branch-and-bound checks, preference-directed search decomposes the global value function into a summation of design-variable value functions, and prunes designvariable domains. A constraint network checks for constraint violations during the search process. If the problem can be solved in a practical amount of time, the set of non-dominated alternatives identified will contain the optimal one. Figure 3.3 gives the preference-directed search algorithm. PD_Search first calls CurrentSolnDominated, which performs a branch-and-bound check, comparing the current solution, X , to the existing solutions, S. If X is dominated, PD_Search returns to pursue another partial solution. Otherwise, RemoveVariable chooses the next design variable to process, attempting to maximize the number of unconstrained variables encountered along a search path. Currently, a greedy algorithm that selects the variable with the most adjacent variables is used. For the example given in Figure 3.2, the greedy algorithm would choose x1 first, since it has two adjacent design variables, and all of the others have just one or zero. If the design variable is unconstrained, then PruneVariableDomain removes dominated assignments from the variable’s domain, dn. For each possible assignment still in dn, PD_Search uses the assignment for X , and calls PropagateConstraints. PropagateConstraints uses the constraint network to enforce node- and arc-consistency, possibly pruning additional assignments from variable domains. PropagateConstraints also assigns either TRUE or FALSE to the flag violation, depending on if X
12
violates any constraints. Next, a recursive call to PD_Search processes the next design variable. This process is repeated until an assignment has been made to all design variables, which constitutes a new solutions. At this point, AddSolnToSolnSet is called to add the new solution to the set of solutions. Any existing solutions that are dominated by the new solution are removed. X ={}; PD_Search(in: X, v; in/out: S, D, X ) { if (CurrentSolnDominated(in: X ,S,v)) /* branch-and-bound check */ return; else { RemoveVariable(in/out: X; out: xn); if (x n ≠ {}) { if (Unconstrained(in: xn)) GetDomain(in: D, xn; out: dn); PruneVariableDomain(in: v; in/out: dn); for each xn ∈ dn { AddToSet(in: xn ; in/out: X ); PropagateConstraints(in: xn ; out: violation; in/out: D); if (!violation) PD_Search(in: X, v; in/out: S, D, X ); RemoveFromSet(in: xn ; in/out: X ); } } else AddSolnToSolnSet(in: X ; in/out: S); } } PruneVariableDomain(in: v; in/out: dn) { for each xi n ∈ dn
x j n ∈ dn, and x j n ≠ xi n if (I_Dominates_J(in: xi n , x j n , v)) RemoveValue(in: x j n ; in/out: d n );
for each
}
Figure 3.3: Preference-directed search algorithm. The procedure PruneVariableDomain compares possible assignments of an unconstrained design variable, and removes those that are dominated. Removing dominated assignments is beneficial when estimating costs for branch-and-bound checks is difficult. This pruning operation can only be performed if, for every dominated assignment, whenever the assignment satisfies constraints, at least one non-dominated assignment also satisfies constraints. Restating the restriction: it can never be the case that a dominated assignment can be valid when there is no valid non-dominated assignment to the variable. All current possible assignments are valid for an unconstrained variable, so restricting this pruning operation to unconstrained variables ensures proper application of the operation.
13
3.3.1 Decomposing Attribute Value Functions An imprecise value function is only valid for comparing complete designs, but preference-directed design requires evaluation of partial designs. Partitioning a problem dictates that the value of prospective solutions for a partition be compared. For example, in solving a partition, branch-andbound dominance checks compare the current best solution to an estimated solution. To perform these checks, a value function reflecting the value of the partition to the entire design is required. To obtain a value function for a partition, the global value function must be mathematically decomposed5 into values of the design variables contained in the partition. Similarly, PruneVariableDomain requires function decomposition to perform comparisons between assignments of a design variable. In this paper, we extended ISMAUT to facilitate dominance checks between design variable assignments for the case of additive attributes. An additive attribute k is defined as an attribute with a level given by the summation of attribute levels corresponding to design variables: xk = rk ( X ) = ∑ rn k (xn )
(3.5)
n
A common case is that rnk(xn) = xn if variable xn contributes to attribute k, or rnk(xn) = 0 otherwise. One interpretation of Equation 3.5 is that each design variable is a subsystem that contributes to the total level of an attribute. A linear attribute value function for attribute k can be expressed in slope-intercept form: vk (xk ) = mk xk + bk
(3.6)
Lemma 3.1: For an additive attribute k and a linear attribute value function, the attribute value of k for an alternative with N components is given by the summation of the alternative's component attribute values: vk (xk ) = ∑ vn k (xn )
(3.7)
n
5 Decomposing an attribute value function into values of design variables should not be confused with t h e standard value-analysis decomposition of attributes into preferentially independent sets.
14
Where a component attribute value is defined as: vn k (xn ) = mk rn k (xn ) +
bk N
(3.8)
Proof: Substituting Eqn. 3.5 into Eqn. 3.6, and bringing mk and bk into the summation yields: vk (xk ) =
∑ m
rn k (xn ) +
k
n
bk N
(3.9)
Substituting Eqn. 3.8 into Eqn. 3.9 gives Eqn. 3.7. Q.E.D. Theorem 3.1: For additive and mutually preferentially independent attributes with linear attribute value functions, the value of an alternative is given by the summation of the alternative's component values: v(V ) = ∑ vn (xn )
(3.10)
n
Where component value vn(xn) is defined as: vn (xn ) = ∑ wk vn k (xn )
(3.11)
k
Proof: Substituting Eqn. 3.9 into Eqn. 3.1 gives: v(V ) =
∑ w ∑ m k
k
k
rn k (xn ) +
n
bk N
(3.12)
Moving wk into the summation over n, and then switching the order of the summations yields: v(V ) =
∑ ∑ w
k
n
k
m r (x ) + bk n k nk N
(3.13)
Substituting Eqn. 3.8 into Eqn. 3.13 gives: v(V ) =
∑ ∑ (w
k
n
k
vn k (xn )
)
Substituting Eqn. 3.11 into Eqn. 3.14 result in Eqn. 3.10. Q.E.D.
15
(3.14)
Corollary 3.1: If for a given problem: • a variable xn is unconstrained • attributes are additive and mutually preferentially independent • attribute value functions are linear Then the assignment of variable xn is independent of the assignment of all other design variables, and the optimal alternative will have an assignment for xn such that vn(xn) is maximized. Proof: Follows directly from Eqn. 3.10 and the definition of unconstrained variables. Q.E.D. Corollary 3.1 states that for two possible assignments, xi n and x j n , for variable xn, x j n can be
( )
( )
pruned from the domain of xn if xn is unconstrained and vn xi n ≥ vn x j n . The latter condition can be checked by evaluating the difference in values between the two assignments: Min ∆vn = Min
∑w
k
∆vn k ≥ 0
(3.15)
k
where, from Lemma 3.1, the difference in value is:
[ ( )
( )]
∆vn k = mk rn k xi n − rn k x j n
(3.16)
Therefore, for problems meeting the restrictions given in Corollary 3.1, I_Dominates_J (see Figure 3.3) prunes x j n if the inequality Eqn 3.15 is true. Theorem 3.2: If for a given problem: • a set of variables is unconstrained • attributes are additive and mutually preferentially independent • attribute value functions are non-linear Then the optimal assignment to variable xn is dependent on the assignment of other design variables. Proof: Consider a set of design variables of size n, where the optimal assignment to variables x 1 ...x n-1 is x1 ... xn-1 . From the definition of a value function, the optimal assignment for variable xn can be found by: • Performing pairwise comparisons of the form:
[
( )]
∆v = ∑ w k ∆vk = ∑ w k rk ( Xi ) − rk X j k
k
16
(3.17)
(
)
(
)
where Xi = x1 ,... xn −1 , xi n , X j = x1 ,... xn −1 , x j n , and xi n and x j n are possible assignments for xn • Selecting assignment xi n such that ∀ x j n ∈dn , ∆v ≥ 0 The value of ∆v depends on attribute weights, wk, and on the attribute values, vk(xk). For a given set of preferences, the range of attribute weights is fixed. Using Eqn 3.5 the difference in attribute levels is:
( )
[
( )]
( )
( )
∆xk = rk ( Xi ) − rk X j = ∑ rn k ( Xi ) − rn k X j = rn k xi n − rn k x j n ( 3 . 1 8 ) n
For a given xi n and x j n , ∆xk is constant, but by definition the slope of the non-linear attribute
( )
value function, ∆vk ∆xk , varies depending on the absolute levels of r k ( Xi ) and r k X j .
Therefore, ∆vk varies for different assignments of x1 ... xn-1 , and as a consequence, so does ∆v . Q . E. D . Although Theorem 3.2 indicates the ability to perform dominance checks is limited for non-linear value functions, the value difference between two design variable can still be bounded. Substituting Eqn. 3.5 into Eqn. 3.6, and then taking the difference for the two assignments Xi = x1 ,..., xn-1 , xi n and X j = x1 ,..., xn-1 , x j n gives:
{
}
{
}
[ ( )
( )]
∆vk = mk rn k xi n − rn k x j n + bk
(3.19)
Eqn. 3.19 is only valid for linear attribute value functions, but if ∆xk is small, then a linear approximation can be used: ∆vk = mk ( xk′ ) ∆xk + bk ( xk′ )
(3.20)
where N -1
xk′ = ∑ rn k (xn )
(3.21)
n=1
identifies the region of the non-linear attribute value function to be modeled by a linear approximation, and mk ( xk′ ) and b k ( x ′k ) are the appropriate slope and intercept for this region of the curve.
17
xi n , x j n , X , v) { CalcDeltaVs(in: xi n , x j n , X , v; out: ∆vn1 ,... ∆v n k ); if (Min ∆vn > 0)
I_Dominates_J(in:
return(TRUE); else return(FALSE); } CalcDeltaVs(in: xi n , x j n , X , v; out: ∆vn1 ,... ∆vn k ){ for each attribute k { if (vk is linear) ∆vn k = mk [rnk( xi n ) - rnk( xi n )]; else if (r nk ( xi n )
≤ rnk( x j n ))
∆vn k = [Max(mk(rk( X )))] [rnk( xi n ) - rnk( x j n )]; else
∆vn k = [Min (mk(rk( X )))] [rnk( xi n ) - rnk( x j n )];
} }
Figure 3.4: Algorithm for pruning design variable domains. If the maximum and minimum slope of v k (x k ), for x k greater than x’ k , can be found, then the minimum ∆v k can be calculated. Recall that if ai is preferred to aj, Min ∆v must be greater than zero. To find Min ∆v, the minimum ∆vk for every k must be found. For a less-is-better attribute, if xi k < x j k , then ai is preferred with respect to attribute k, and ∆v k will be positive. For a monotonically decreasing curve, the minimum ∆v k is the maximum slope of the curve, Max(mk(xk)), times ∆xk: ∆vk = Max ( mk(xk) ) ∆xk = Max ( mk(xk) ) ( rnk( xi n ) - rnk( x j n ) )
(3.22)
If fk(ai) > fk(aj), then: ∆vk = Min ( mk(xk) ) ∆xk = Min ( mk(xk) ) ( rnk( xi n ) - rnk( x j n ) )
(3.23)
Using the algorithm given in Figure 3.4 the value difference, Min ∆vn , between two design variable assignments can be calculated. If Min ∆vn is positive, the first assignment dominates the second. For problems with non-linear value functions, the amount of pruning provided by I_Dominates_J depends on how much design information (assignments to design variables) is available. An
18
important research issue is the determination of a good heuristic for choosing which partitions and design variables to assign first.
4.0 Application Examples In this section, we present two application examples. The first is a simple problem intended to demonstrate the preference-directed design algorithm. The second application is more complex, and is included to show the effectiveness of our design approach. 4.1 Automotive Problem An electro-mechanical design problem from automotive design is given in Figure 4.1. Each of the ovals in the figure is a function that must be implemented, and boxes connected to the functions define the constraints among the functions. Next to each function is a list of components that are available to implement the functions; each component is described by two additive attributes: cost and power. In the example, the engine control module (ECM) can be implemented using either e1 or e2, but if component e1 is used, the inter-operability constraint between the ECM and the speed sensor indicates that s1 cannot be used. For this problem, functions are design variables and the components available for each function form the variable domains. The first step is to generate a random sample, so GenerateRandSample uses PD_Search to identify the two alternatives given in Table 4.1. Next, the interactive procedure RankSample queries the user to define the attribute value functions (curves) given in Figure 4.2. The range of possible attribute levels is obtained by ignoring constraints and calculating the minimum and maximum level for each attribute. As shown in Figure 4.2, the power consumed by the electrical components should be less than 5.0 Watts (note the dramatic reduction in vp for levels beyond 5.0 Watts), but slightly higher power consumption may be acceptable if a significant cost savings can be achieved. Once the attribute values curves are constructed, the user is asked to rank the elements in the sample. In this case, alternative 2 is preferred to 1, which defines the following constraint: 0.19 wcost - 0.38 wpower ≥ 0 After the constraint network is constructed, StaticPartitioning divides the functions into two groups. The first partition consists only of the function Radio, while the second partition contains ECM, Speed Sensor, and Fuel Injector. PD_Search is called to solve the Radio partition.
19
If (ECM = e1) Speed Sensor != s1
ECM
Radio C P r1 60.0 2.9 r2 62.0 2.4 r3 65.0 2.3
C P s1 1.0 0.0 s2 1.25 0.0
Speed Sensor
C P e1 10.0 2.5 e2 12.0 2.1
C P Fuel i1 2.5 0.0 Injectors i2 3.0 0.0 i3 3.25 0.0
If (ECM = e1) Fuel Injector != i1
Figure 4.1: An example automotive application with four variables and two constraints.
Alternatives
Cost
Power
vc
vp
Alt. 1 {s1,e2,i1,r2} Alt. 2 {s1,e2,i2,r1}
77.5
4.5
0.50
0.98
76.0
5.0
0.69
0.60
Table 4.1: A random sample of design alternatives.
Cost
Vp
Vc
1 0.8 0.6 0.4 0.2 0 73.5 75.5 77.5 79.5 81.5
1 0.8 0.6 0.4 0.2 0 4.4 4.6
4.8
5
5.2
5.4
Power
Figure 4.2: The attribute value functions for the automotive example. Figure 4.3 describes the main steps performed by PD_Search for each partition. For each variable, the set of possible assignments is shown. The arcs in the diagram indicate one of three operations: dominance checks (d), constraint propagation (cp), or search (s). An assignment to a variables is identified by a circle containing the assignment. To solve the first partition, RemoveVariable extracts variable Radio, and Unconstrained returns true since there are no variables connected by constraints to Radio. PruneVariableDomain performs dominance checks between r1 and r2, and r1 and r3, resulting in the removal of r3 from Radio’s domain. To perform dominance checks, each ∆vn k must be found. For the r1 to r3 comparison, the calculation of Min ∆vr follows:
20
∆rr cos t = 60.0 − 65.0 = −5.0 ∆rr power = 2.9 − 2.3 = 0.6 mcos t = −0.13 m power = Min(-0.25,-0.25,-1.5,-2.0,-0.5) = −2.0 ∆vr cos t = ( −0.13)( −5.0) = 0.65 ∆vr power = (−2.0)(0.6) = −1.2 Min ∆vr , w ∈ W ′ = Min 0.65wcos t − 1.2 w power , w ∈ W ′ = 0.04 Since Min ∆vr is greater than zero, r1 dominates r3. Executing the FOR loop in PD_Search results in the valid assignment of both r1 and r2 to Radio. Each assignment is a solution for the partition.
Partition 1 {r1,r2,r3}
Partition 2 {s1,s2},{e1,e2} {i1,i2,i3}
d
s
{r1, r2} s Radio = r1
s Radio = r2
ECM = e1 cp {s2},{i2,i3}
s ECM = e2 d {s1},{i1, i2,i3}
Sensor = s2
Sensor = s1
d {i2}
d {i1}
F-Inj. = i2
F-Inj. = i1
Figure 4.3: Searching for partition solutions. To solve the second partition, RemoveVariable selects ECM to process first. ECM is chosen since it has more variables connected to it by constraints (2) than the others (1 each). After assigning e1 to ECM, constraint propagation removes s1 from sensor and i1 from fuel injector since both violate constraints. At this point, the only valid assignment for sensor is s2. With ECM assigned, fuel injector becomes an unconstrained variable, so dominance checks can be performed by PruneVariableDomain. After dominance checks for fuel injector, the only remaining assignment is i2. Therefore, the combination of {e1,s2,i2} is one solution for the partition. For the assignment of e2 to ECM, the only solution found is {e2,s1,i1}. Finally CombinePartitions merges the solutions of the two partitions, producing four solutions: {r1,e1,s2,i2}, {r1,e2,s1,i1}, {r2,e1,s2,i2}, and {r2,e2,s1,i1}. Dominance checks between solutions are performed, reducing
21
the non-dominated set to the two solutions given in Table 4.2. Note that the second solution would not have been identified if a constraint restricting power to be below 5.0 Watts was used.
Solutions
Cost
Power
vc
vp
{s1,e2,i1,r1} {s2,e1,i2,r1}
75.50 74.25
5.0 5.4
0.75 0.91
0.6 0.0
Table 4.2: Non-dominated solutions for the automotive application. Of the thirty six possible combinations of components, twenty four are feasible solutions. The Pareto optimal set contains five solutions, including the two in Table 4.2. The imprecise value function, created from one preference statement, is able to reduce size on the non-dominated set to two. Note also that neither of the two designs in the random sample are in the non-dominated set. 4.2 Computer Design To evaluate the performance of preference-directed design, a suite of test cases based on a computer design problem was developed. The function specification for each test case is identical, but the number of parts (domain size) available to implement the functions ranges from 29 to 463. To highlight the performance of the dominance checks, no constraints were specified. Table 4.3 compares the performance of preference-directed design using designer’s preference to search using only Pareto preference. For the preference-directed design test cases, nine pairwise preference statements were used. One important finding from this suite of tests is that for problems of any reasonable size, optimal design using designer’s preferences requires less time to find a set of non-dominated solutions. Each dominance check based on designer’s preferences requires the execution of a linear program to determine Min ∆v . For trivial problems, the extra time required to solve the linear programs may result in preference-directed design executing longer than design based on Pareto preference. For problems of any significance, the extra pruning capability provided by preference-directed design dramatically reduces execution time. A second finding is that the set of non-dominated solutions is drastically reduced by dominance checks based on designer’s preferences. For the test case J90, Pareto preference produces 3495 non-dominated solutions, while designer’s preferences produces only 4. Our implementation cannot solve any of the Pareto-preference cases with more than 90 parts, since the memory required to maintain all of the solutions is too large. To solve these problems, attribute bounds
22
would have to be introduced, thus potentially eliminating the optimal solution from the Paretooptimal set.
# Feasible Alternatives Pareto Preference # Solutions Time (sec.) Pref.-Directed Design # Solutions Time (sec.)
J29 103
J63 1011
J77 1012
J90 1014
J109 1016
J194 1021
J465 1028
28 0.7
379 23.4
1698 310.6
3495 1303.4
NA NA
NA NA
NA NA
2 1.2
2 2.8
4 4.4
4 5.1
4 5.5
24 39.3
28 55.2
Table 4.3: Comparison of dominance checks based on Pareto preference and Preference-Directed Design.
5.0 Summary and Discussion In this paper, we introduced a new technique that extends the set of design problems that can be solved optimally. By first constructing an imprecise value function, the number of non-dominated alternatives that must be generated is reduced. We described an implementation based on combinatorial optimization and constraint satisfaction that achieves additional performance gains by decomposing the value function to identify dominated design-variable assignments. Test results indicate that our approach extends the set of problems that can be solved optimally. Other design tools have post-processed design results using ISMAUT. An iterative design style is employed by MICAD (Sykes & White, 1991) to identify several design alternatives, and the best one is chosen using ISMAUT. Ext_GOPS (Haworth & Birmingham, 1993) produces the Pareto optimal set of designs, and uses ISMAUT to select the best one. Unlike MICAD and ExtGOPS, preference-directed design performs ISMAUT pruning during search as opposed to after, reducing the complexity of the design task and guaranteeing identification of the optimal design. Although the worst-case complexity of preference-directed design is exponential, its execution performance rivals that of other design techniques. To find a feasible solution, the best-case complexity of a constraint-satisfaction approach is O(r d2), where d is the domain size of the of the variables and r is the number of constraints; the worst case is exponential. Preference-directed design incorporates constraint satisfaction into its search process, therefore, expected performance is at least as good. The performance of a mathematical-programming approach degrades as the number of integer variables increase. Similar to mathematical programming, preference-directed
23
design uses branch-and-bound to explore assignments of integer variables, however, preferencedirected design performs additional dominance checks among design variable assignments. Although the algorithm given in Section 3 can only explore a single configuration of standard components, this is not an inherent limitation to our approach. A design tool should be able to explore different topologies to implement a set of given functions. A one-to-many mapping defines how a single function can be implemented by a set of components. A many-to-one mapping defines how a set of functions can be implemented by a single component. For preference-directed design, function decomposition (one-to-many mapping) and multi-function components (many-toone mapping) can be implemented with techniques similar to those presented by Haworth and Birmingham (1993) . Our current research efforts are focused on constraint-graph analysis, variable ordering, and distributed design. Dynamic constraint-graph analysis can be used to perform partitioning during search. As variables are assigned, nodes are effectively removed from the constraint graph. Partitions whose feasibility is independent of assignments to other partitions can be identified. By properly choosing the order of variables to assign, the amount of dynamic partitioning, dominance checks, or both can be increased. We are also investigating problems where design knowledge is distributed among a number of autonomous agents (Darr & Birmingham, 1994) .
24
References Birmingham, W. P., Gupta, A. P., & Siewiorek, D. P. (1992). Automating the Design of Computer Systems. Jones and Bartlett. Bradley, S. R., & Agogino, A. M. (1993). Computer-assisted catalog selection with multiple objectives. ASME Design Theory and Methodology 53, 139-147. Darr, T., & Birmingham, W. P. (1994). Automated design for concurrent engineering. IEEE Expert, Oct. Decther, R., & Pearl, J. (1987). Network-based heuristics for constraint-satisfaction problems. Artificial Intelligence 34(1), 1-38. Fishburn, P. C. (1970). Utility Theory for Decision Making. John Wiley & Sons, New York. Gebotys, C. H., & Elmasry, M. I. (1993). Global optimization approach for architectural synthesis. Computer Aided Design of Integrated Circuits and Systems 12, Sept., 1266-1278. Grossmann, I. E. (1990). Mixed-integer nonlinear programming techniques for synthesis of engineering systems. Research in Engineering Design 1, 205-228. Hafer, L., & Parker, A. (1983). A formal method for the specification, analysis and design of register-transfer-level digital logic. IEEE Transactions on Computer-Aided Design CAD-2, Jan., 4-17. Haworth, M. S., & Birmingham, W. P. (1993). Towards optimal system-level design. Proc. of the 30th Design Automation Conference, 434-438. Keeney, R. L., & Raiffa, H. (1976). Decisions with Multiple Objectives: Preferences and Value Tradeoffs. Wiley and Sons, New York. King, B., & Akao, Y. (1989). Better Designs in Half the Time - Implementing QFD Quality Function Deployment in America. GOAL/QPC, Metheun, MA. Lee, J., Hsu, Y., & Lin, Y. (1989). A new integer linear programming formulation for the scheduling problem in data path synthesis. Proc. of the International Conference on Computer Aided Design. Mackworth, A. K. (1987). Constraint satisfaction. In Encyclopedia of Artificial Intelligence , (S. C. Shapiro (Ed.)), John Wiley & Sons, New York. Mittal, S., & Falkenhainer, B. (1990). Dynamic constraint satisfaction problems. Proceedings of the Eighth National Conference on Artificial Intelligence (AAAI-90), 25-32. Mittal, S., & Frayman, F. (1987). A constraint-based expert system for configuration tasks. Proc. of the 2nd International Conference on Applications of AI to Engineering. Murty, K. G. (1983). Linear Programming. John Wiley & Sons, New York. Nemhauser, G. L., Kan, A. H. G. R., & Todd, M. J. (Eds.). (1989). Optimization. North-Holland, New York. Peihua, G., & Andrew, A. (1993). Concurrent Engineering - Methodology & Applications. Elsevier, New York. Pekny, J. G. (1992). Combinatorial optimization in engineering systems: exploiting problem structure and parallelism. Proc. of the NSF Design and Manufacturing Systems Conference. Pugh, S. (1990). Total Design. Addison-Wesley, New York.
25
Sykes, E. A., & White, C. C. (1991). Multiobjective intelligent computer-aided design. IEEE Transactions on Systems, Man, and Cybernetics 21(6), 1498-1511. Thurston, D. L. (1991). A formal method for subjective design evaluation with multiple attributes. Research in Engineering Design 3, 105-122. Thurston, D. L., & Carnahan, J. V. (1992). Fuzzy ratings and utility analysis in preliminary design evaluation of multiple attributes. Journal of Mechanical Design 114, Dec., 648-658. Vanderplaats, G. N., & Sugimoto, H. (1985). Numerical optimization techniques for mechanical design. In Design and Synthesis , Elsevier Science Publishers B. V. (North-Holland). White, C. C., & al., e. (1984). A model of multi-attribute decision making and trade-off weight determination under uncertainty. IEEE Transactions on Systems, Man, and Cybernetics SMC-14(2), March/April, 223-229. Wood, K. L., & Antonsson, E. K. (1989). Computations with imprecise parameters in engineering design: background and theory. Journal of Mechanisms, Transmissions and Automation in Design 111, Dec., 616625. Wood, K. L., Antonsson, E. K., & Beck, J. L. (1990). Representing imprecision in engineering design: comparing fuzzy analysis and probability calculus. Research in Engineering Design 1, 187-203. Wu, J., & al., e. (1990, A model-based expert system for digital system design. IEEE Design and Test of Computers. Yu, P. L. (1989). Multiple criteria decision making: five basic concepts. In Optimization , (G. L. Nemhauser, A. H. G. R. Kan, & M. J. Todd (Eds.)), pp. 663-699. Elsevier Science Publishers B.V.
26
