An Interactive Search Method Based on User Preferences - INFORMS ...

Decision Analysis

informs

Vol. 5, No. 4, December 2008, pp. 203–229 issn 1545-8490 eissn 1545-8504 08 0504 0203

®

doi 10.1287/deca.1080.0125 © 2008 INFORMS

An Interactive Search Method Based on User Preferences Asim Roy

Department of Information Systems, Arizona State University, Tempe, Arizona 85287, [email protected]

Patrick Mackin

College of Business and Technology, Black Hills State University, Spearfish, South Dakota 57779, [email protected]

Jyrki Wallenius

Department of Business Technology, Helsinki School of Economics, 00100 Helsinki, Finland, jyrki.wallenius@hse.fi

James Corner

Department of Management Systems, Waikato Management School, University of Waikato, Private Bag 3105, Hamilton, New Zealand, [email protected]

Mark Keith, Gregory Schymik, Hina Arora

Department of Information Systems, Arizona State University, Tempe, Arizona 85287 {[email protected], [email protected], [email protected]}

T

his paper presents a general method for interactively searching for objects (alternatives) in a large collection the contents of which are unknown to the user and where the objects are defined by a large number of discrete-valued attributes. Briefly, the method presents an object and asks the user to indicate his or her preference for the object. The method allows preference indications in two basic modes: (1) by assignment of objects to predefined preference categories such as high, medium, and low preference or (2) by direct preference comparison of objects such as “object A preferred to object B.” From these preference statements, the method learns about the user’s preferences and constructs an approximation to a value or preference function of the user (additive or multiplicative) at each iteration. It then uses this approximate preference function to rerank the objects in the collection and retrieve the top-ranked ones to present to the user at the next iteration. The process terminates when the user is satisfied with the list of top-ranked objects. This method can also be used to solve general multiattribute discrete alternative problems, where the alternatives are known with certainty and described by a set of discrete-valued attributes. Test results are reported and application possibilities are discussed. Key words: interactive search; math programming; decision analysis; multiattribute; multiple criteria decision making; utility/preference: multiattribute History: Received on July 27, 2007. Accepted on August 19, 2008, after 3 revisions. Published online in Articles in Advance October 24, 2008.

1.

Introduction

large, it is difficult for a user or decision maker to examine the entire collection to find the most preferred, interesting, or relevant objects. However, the user has preferences over these N objects, although he or she never actually sees them all, whether houses or Web pages. The basic problem is to find a subset of objects from this large collection that are of high value to the user. The user is willing to spend some time to examine a few of the objects and indicate his or her levels of preference for them, but nothing more.

We consider the following problem scenario. Assume there is a collection of N objects (or alternatives, in decision analysis terminology) where N is usually quite large. The collection can be a set of Web pages from a Web search or a set of documents retrieved from a medical or legal database based on a set of keywords. Alternatively, a collection can be a set of houses for sale in a certain neighborhood and within a certain price range. Given that the collection is usually 203

204 The user expects the system to retrieve the desired high-valued objects based on these inputs. In addition, we assume that the user either can indicate his or her preferences over these objects in very coarse terms only, such as high (strong), medium, and low (weak) preference, or, in some cases, can make explicit preference statements such as “object A is preferred to objects B, C, and D.” This sets the protocol for interaction with the user in this problem setting. From the user’s point of view, the desire is to create an interactive system that is not too demanding on the user in terms of preference feedback. The overall philosophy is to work with whatever preference information we get from the user in whatever form. This feature of the proposed interactive search method is about giving the user some latitude in comparing alternatives. It is neither for computational necessity nor for computational convenience. We propose a general method for interactive search in this problem scenario, taking the user’s preferences into account. In other words, it is a method for user-guided search. The objects in this collection are defined by a large number of discrete-valued attributes whose number can be in the hundreds or sometimes even more. In a typical keyword-based search problem, the words in a document or a Web page are the attributes, and a word is either present or absent in a document. Hence, the attributes of a document are discrete valued, and we can represent the presence or absence of a word using binary values. Therefore, the typical keyword-based search problem can be framed as a problem with discretevalued attributes. At each iteration, the interactive search method presents the user with some new objects from the collection and asks him or her to indicate a preference for these objects and perhaps compare them to the ones seen before, if any. These preference statements compare entire objects, not particular attributes of the objects. From the accumulated preference statements, the method constructs an approximation of the user’s value function. Once the approximate value function is constructed from the accumulated preference statements, all the objects in the collection are reranked using this approximate value function, and then several of the top-ranked objects are presented to the user for evaluation at the next iteration. The

Roy et al.: An Interactive Search Method Based on User Preferences Decision Analysis 5(4), pp. 203–229, © 2008 INFORMS

interactive search process stops when the user is satisfied with the list of top-ranked objects. On the surface, this problem looks standard in the decision analysis literature. It deals with a discrete set of alternatives (objects) defined by a set of discretevalued attributes. However, the attribute-level preference elicitation methods of decision analysis become tedious at best when one has to deal with a large number of attributes. Hence, one of the contributions of this paper is to present a method of constructing an approximation of the user’s value function for discrete-valued attributes from object-level preference information, obviating the need for attribute-level preference elicitation. To handle object-level preference information, we formulate the value function approximation problem as a mathematical programming problem. The method proposed has similarities to those available in the multicriteria decision-making literature. Hence, we next review the literature of both fields. We note that although a few others have dealt with the generation of implicit value functions as proposed here, none that we could find approach the problem using our method or use it for search purposes (see, for instance, Maddulapalli et al. 2007). 1.1.

Multiple Criteria Decision-Making and Decision Analysis Methods In multiattribute decision making under certainty, there are broadly two classes of problems. One class mainly deals with problems with many choices that can be represented by continuous variables (e.g., rate or volume of production, investment amount). This class generally falls under the umbrella of multiple criteria decision-making problems, which are often formulated as mathematical programming problems (Geoffrion et al. 1972; Zionts and Wallenius 1976, 1983; Steuer 1977; Korhonen and Laakso 1986; Shin and Ravindran 1991; Roy and Wallenius 1991, 1992; Gardiner and Steuer 1994; Miettinen 2004; and others). A typical mathematical programming problem of this class is Max V f x s.t. gk x = 0

(1)

k = 1 m lj ≤ xj ≤ uj j = 1 n

Here x denotes the n-vector of decision variables, gk x the constraints, and f x the p-vector of criterion


or objective functions. The constraints usually define a convex feasible region and the objectives are concave, continuously differentiable functions of the decision variables. V f x represents the implicit value function of the decision maker, usually assumed to be concave in terms of the objective functions. An important class of multicriteria decision-making methods is built around interactive procedures to identify the most preferred solution (Zionts and Wallenius 1976, 1983; Korhonen and Laakso 1986; Shin and Ravindran 1991; Roy and Wallenius 1991, 1992). The methods iteratively present the decision maker with different combinations of feasible objective function values, ask him or her to make binary comparisons or to choose the best in a set, and, in the process, attempt to learn more about the decision maker’s underlying value function V f x. If an additive value function is postulated, the process periodically updates the criterion weights. In the second class of problems, the choices (commonly expressed in terms of attribute values in the decision analysis literature) are usually discrete and limited, and their number is finite. For example, when buying a car, you have limited choices on the color or the seat capacity. Similarly, when buying a house, there are limited choices on the number of bedrooms, bathrooms, garages, and so forth. For this class of problems, mathematical programming models are generally not used.1 This class of problems falls mainly under the umbrella of decision analysis (Keeney and Raiffa 1976, Edwards 1977, Kirkwood and Sarin 1980, Stillwell et al. 1981, Corner and Kirkwood 1991). Expressions (2) and (3) show two value functions widely used in this field: a weighted additive and a multiplicative value function. A study by Corner and Corner (1995) showed that nearly all of the 47 reallife decision analytic applications studied used one of these two functional forms: n (2) V x = i vi xi i=1

V x =

n

1 + kki vi xi

(3)

i=1 1

An early exception is Zionts (1981). See also Korhonen (1988) and Köksalan and Sagala (1995). Kirkwood’s text (1997) contains a chapter discussing combined uses of decision analysis and mathematical programming.

205 Here i and ki are the weights associated with the ith attribute, k is an additional parameter, vi xi designates a value function over the single attribute xi , and n is the number of attributes. In decision analysis, vi xi is constructed by questioning the decision maker about preferences for different values of the attribute xi . The weights i and ki are similarly determined by eliciting preference information for different attribute combinations or bundles. Once the decision maker’s value function V x is constructed from the collected preference information (that is, once both the weights i (ki ) and the single attribute value functions vi xi are determined), the most preferred alternative is found by evaluating the total set of alternatives using that value function. This paper deals with a problem of the second type, which is characterized by discrete-valued attributes. However, traditional decision analysis methods cannot be used here because the proposed interactive search method asks preference questions at the object level, not at the attribute level. Thus, the proposed method does not construct attribute level value functions vi xi . It constructs the overall value function V x directly from object-level preference statements, as explained in the sections below. To motivate our method, we describe two potential Internet applications. 1.2. Home Screening on the Internet Suppose a potential homebuyer is searching for houses on the Internet using a (fictitious) system called “FastHomeSearch.com.” After the homebuyer specifies some initial parameters (attributes), e.g., a certain neighborhood, a price range, or a range for the size of the house, suppose FastHomeSearch.com shows her some houses that she might be interested in. There are buttons next to each house to indicate whether she likes the house or not and a separate window to indicate preference for a house compared to some others already shown to her. Once she indicates which ones she likes or dislikes or prefers compared to some other ones, FastHomeSearch.com then uses that information to show her a new set of houses. This iterative process goes on until the homebuyer finds a set of houses very much to her liking. What the system does behind the screen is collect the preference information from all prior iterations and

Roy et al.: An Interactive Search Method Based on User Preferences

206 construct an approximation to the homebuyer’s value function, which is then used to find homes from the database in the next iteration that will interest her. Note that in this interactive session with the user, no attribute-level preference questions are ever asked. All that is asked for are some holistic preference statements on composite bundles or alternatives, houses in this case. Thus, the user never has to indicate whether she likes the color cherry over whitewash for kitchen cabinets or whether the price of a house and a swimming pool are more important than the color of kitchen cabinets. The method automatically determines her preferences on those issues from the holistic preference statements. 1.3. An Internet Search Scenario When Asim searches the Web using the keywords “Asim Roy,” Google retrieves 185,000 Web pages (documents). But he knows that not all of those 185,000 pages are related to him, because there are many other people with the same name. To find the relevant ones, he can look through all 185,000 Google snippets, but that would be a daunting task. He knows that Google has an advanced search tool where one can specify negative search words to exclude unwanted Web pages, but that is not very easy to do either. If 180,000 of the 185,000 Web pages are irrelevant or unwanted, to come up with negative words to exclude that many documents would be daunting. So he uses a new (fictitious) smart search tool called “UserMindReader.com” that allows him to easily access the documents he wants. UserMindReader.com works in the following iterative mode. At each iteration, a user examines only a few Google snippets and marks the corresponding Web pages to be either in a certain relevance category (high, medium, or low) or irrelevant. Alternatively, the user can indicate in a separate window that a certain Web page is preferred to some other ones. In a few iterations, UserMindReader.com finds the Web pages for which Asim is looking. How does UserMindReader.com find the documents of interest? Again, it constructs the user’s value function through the iterative markup process. The remainder of this paper is organized as follows. Section 2 transforms additive and multiplicative value functions into functions of 0-1 variables with

Decision Analysis 5(4), pp. 203–229, © 2008 INFORMS

weights on them. It also presents the search algorithm that uses this value function stated in terms of 0-1 variables. Section 3 illustrates the method with madeup examples. Section 4 reports the results of computational tests of the method, and §5 concludes the paper.

2. 2.1.

An Iterative Search Method Based on User Preferences

Representing Discrete Multivalued Attributes by a Vector of 0-1 Valued Attributes We represent each discrete multivalued attribute (an attribute with multiple discrete values, e.g., a color attribute that has a set of values such as red, green, and blue) by a vector of single-valued attributes, where each single-valued attribute represents one of the specific values of the multivalued attribute. Hence, a vector of three single-valued attributes can represent the color attribute as follows: Color = (Color-Red, ColorGreen, Color-Blue). Here Color-Red, Color-Green, and Color-Blue are the names of the three single-valued attributes, and the vector Color = 1 0 0 can represent the color of an alternative (say a red car) whose actual color is red. Similarly, the vector Color = 0 1 0 can represent the color of an alternative (say a green car) whose actual color is green. In this representation, a single-valued attribute (e.g., Color-Red) has a value of 1 when the multivalued attribute has that particular value and 0 otherwise. We start with the weighted additive value function of (2) and represent it in terms of a set of 0-1 valued attributes. Let xi , the ith multivalued attribute, have Pi discrete values given by aiq , q = 1 Pi . Furthermore, let vi aiq be the value of the attribute value function vi xi when the attribute value is aiq , and let iq be a 0-1 variable that has the value of 1 when xi = aiq and 0 otherwise. Thus, iq is a selector variable that is ON (has a value of 1), when the value of xi is aiq and is OFF (has a value of 0) otherwise. Although the variable iq can have two different values (0 and 1), it in effect turns on only one of the discrete (nonzero) values of xi . As we will show, this does not complicate the process from the user’s point of view, because she deals with holistic alternatives (a specific home, car, or internet document). The value function vi xi can


207


then be represented in terms of these binary valued attribute variables iq as follows: vi xi = Pi q=1

Pi q=1

vi aiq iq (4)

iq = 1

Substituting (4) into (2) yields the following expression for the value function V x in terms of the singlevalued attribute variables iq : V x =

n i=1

=

i

Pi q=1

Pi n i=1 q=1

vi aiq iq =

wiq iq

Pi n i=1 q=1

i vi aiq iq (5)

where wiq = i vi aiq . We call wiq the weighted value of the 0-1 attribute variable iq because it is the product of the weight i and the value vi aiq . 2.2.

Representing Multiplicative Value Functions by a Vector of 0-1 Valued Attributes In many situations, certain combinations of attribute values can have a positive or negative impact on the overall value of an object or alternative. For instance, a collection of certain words (attributes) in a document or Web page may have value from a user’s perspective when he is searching for relevant documents. Thus, when searching for “Asim Roy” at Arizona State University, all the three words “Arizona,” “State,” and “University” appearing on a Web page makes it much more relevant and valuable than a Web page that has only one or two of the three words. Similarly, one might have a preference for a black BMW over a black Lexus when they are otherwise similar in terms of price and other features. The multiplicative value function of (3) is one way to account for these types of interactions between attributes. A twoattribute multiplicative value function is: vx1 x2 = k1 v1 x1 + k2 v2 x2 + k3 v1 x1 v2 x2 , where v1 x1 v2 x2 is the interaction or cross-product term. To represent a multiplicative value function in terms of single-valued (0-1 valued) attributes, as in (5), each cross-product term becomes a separate singlevalued attribute. We explain how the transformation is

done. Let the jth cross-product term wcj be given by wcj = kj vr arp vs asq · · · vt atl , where wcj represents the weighted value of the cross-product term. It consists of Lj attributes xr xs xt with their values as follows: xr = arp xs = asq xt = atl . Here arp is the pth value of attribute xr , asq is the qth value of attribute xs , and atl is the lth value of attribute xt . Let cj be the selector variable for the jth cross-product term wcj . It has a value of 1 when xr = arp , xs = asq xt = atl and 0 otherwise. Suppose there are Q such cross-product terms in a multiplicative value function and cj is the selector variable for the jth one, j = 1 Q. Then the single-valued attribute representation of an additive value function in (5) can be extended in a straightforward manner to a multiplicative one as follows: V x =

Pi n i=1 q=1

wiq iq +

Q j=1

wcj cj

(6)

When there are thousands of attributes, such as in Web pages and documents, adding every conceivable cross-product term to (6) is not practical or efficient, especially when they do not occur in any of the objects or alternatives. Therefore, only cross-product terms that actually occur in the objects or alternatives are considered for inclusion in (6). As explained in the method below, the cross-product terms that are included in (6) can be selected using some heuristics so that only the ones that have an impact on the value of an object are included. 2.3.

Value Function Approximation Using Object-Level Preference Information

2.3.1. Vector Representation of Objects in Terms of Single-Valued Attributes. In §§2.1 and 2.2, we showed how additive and multiplicative value functions can be restated in terms of 0-1 valued (or singlevalued) attributes. Henceforth, we use the value function given by (6), because it accounts for both forms, additive and multiplicative. However, we simplify the notation of (6) before presenting the value function approximation and search methods. Suppose each object Dk , k = 1 N , in the collection is defined by a finite number M of single-valued attributes. Let Dki , i = 1 M, be the ith singlevalued attribute for the kth object. Thus, the kth object

208 Dk can be described by the vector Dk = Dk1 · · · DkM , where Dki = 1 if the ith single-valued attribute is present in that object, and Dki = 0 if the ith single-valued attribute is not present in that object. We illustrate using car objects. Suppose a certain model of a car comes in three different colors (red, black, and silver) and in three different prices ($20K, $30K, and $40K), depending on the options. Let the attribute numbers for color and price be 1 and 2, respectively. Therefore, P1 = P2 = 3, the total number of values of each attribute. As per the notation of §2.1, a11 = red, a12 = black, and a13 = silver. Similarly, a21 = $20K, a22 = $30K, and a23 = $40K. Six 0-1 valued attributes, three for color and three for price, describe each car. Accordingly, a car object Dk can be defined by the presence or absence of the following attributes: red, black, silver, $20K, $30K, and $40K. The car vector Dk = 1 0 0 0 1 0 represents a red car priced at $30K and the car vector Dk = 0 1 0 0 0 1 represents a black car priced at $40K. Suppose we add two cross-product terms to this car vector to examine certain interaction effects, one to get the combined effect of the color black and a price of $30K and another to get the combined effect of color red and a price of $40K. Therefore, we now have eight 0-1 valued attributes to describe a car: three for color, three for price, one for the attribute combination “black and $30K” and another for the attribute combination “red and $40K.” With this expanded vector representation, a red car priced at $30K now is Dk = 1 0 0 0 1 0 0 0 and the car vector for a black car priced at $30K now is Dk = 0 1 0 0 1 0 1 0, incorporating the appropriate interaction term. This expanded vector representation shows how crossproduct terms can be easily included to account for interaction effects. In the case of Web pages or documents, each possible word in a document is a single-valued attribute and the 0-1 values in a document vector Dk = 0 1 0 0 0 1 indicate the presence or absence of a particular word in that document, where 1 means the word is present and 0 means it is not. The size of these document vectors can be very large, sometimes in the thousands.


We restate (6) using this simplified object vector notation that is inclusive of all single-valued attributes: M (7) V Dk = wi Dki

i=1

V Dk represents the value of the kth object. Similarly, wi and Dki correspond to the weighted value and the attribute value (0 or 1) of the ith attribute, respectively. Dki essentially indicates whether the ith attribute is present in the kth object. Note that in this restated form of the value function, the groupings of the attributes disappear. Thus, we no longer know, or care to know, which sets of attributes are the color attributes and which ones are the price attributes. In fact, we may no longer know how many different colors or prices there are. This is particularly true of document vectors with thousands of words as 0-1 valued attributes with no natural groupings of those words. 2.3.2. A Linear Programming Formulation to Calculate the Approximate Value Function. The interactive search method proposed allows preference indications in two basic modes: (1) by assignment of objects to predefined preference categories such as high, medium, and low preference and (2) through preference statements such as “object A preferred to object B” that directly compare two individual objects. In general, let there be T preference categories. If high, medium, and low are the preference categories, then T = 3. At each iteration of the interactive search procedure, the user views a previously unseen object from the collection of N objects and either assigns it to one of the T preference categories or makes a preference comparison with one or more of the objects already seen. For example, the user might say, “I like this BMW better than the ones I have seen before.” All preference statements from the user are collected and stored and used by the method to approximate the value function. Let St be the cumulative set of objects in the preference category t, t = 1 T , at some iteration. Let the T categories be ordered such that the set of objects St in category t is preferred to the set of objects St+1 in category t + 1. Let R be the total number of direct preference statements made up to some iteration. Direct preference statements compare an object A with another object B. Let PA and PB be the vectors that store the preferred


209


and nonpreferred objects, respectively. Assuming the objects are stored sequentially in these vectors whenever a direct comparison is made between two objects, the jth object in PA will be preferred to the jth object P in PB , j = 1 R. Let Dj A be the jth object in PA P and Dj B be the jth object in PB . Based on the cumulative preference statements from the user up to some iteration, the following linear programming (LP) problem can be solved to obtain the weights of the single-valued attributes:2 Max ( Subject to:

M i=1

wi Dki −

M i=1

wi Dji ≥ (

∀k ∈ St j ∈ St+1 t = 1

T −1 M

M P P wi DjiA − wi DjiB i=1 i=1

0 ≤ wi ≤ 1

≥ (

(8)

j = 1

R

i = 1

M

( ≥ 0

The first set of constraints for different preference categories states that the kth object in set St is preferred to the jth object in set St+1 ; hence, there should be at least some ( difference in their values. The second set of constraints for direct preference statements states that the jth object in the vector PA is preferred to the jth object in the vector PB ; again, there should be at least some ( difference in their values. The objective of the LP problem is to maximize this difference (. The LP problem solves for the weights wi , i = 1 M, and (. If ( is strictly positive, the user’s preference statements are consistent with the underlying value function. If ( = 0, the user’s preference statements are inconsistent with the underlying value function. The user’s preference statements are also inconsistent with the underlying value if the LP is infeasible. One way to deal with inconsistent responses would be to minimize the amount of inconsistencies. Another approach would be to systematically drop the older LP constraints when they are in conflict with the newer ones (Zionts and Wallenius 1976, Roy and Wallenius 1991). For Internet 2 This problem is essentially the lambda problem of Zionts and Wallenius (1976) and Roy and Wallenius (1991).

search problems (e.g., Google search), certain words can have negative values. For example, Google allows one to indicate both positive and negative words for a search. One can easily allow for negative-valued attributes in the above formulation by letting wi be negative. 2.4.

An Interactive Search Algorithm Based on User Feedback Next we present a general interactive search procedure based on preference feedback from the user. Many variations of this algorithm are possible. At each iteration of this interactive procedure, a small subset of objects from the large collection is presented to the user for preference feedback. The user can provide preference feedback on the presented objects in one of the following two modes: (1) by assigning an object to one of the predefined preference categories such as high, medium, and low preference and (2) through preference statements such as “object A preferred to object B” that directly compare two individual objects. All preference statements are collected and stored on a cumulative basis during the iterative process. At each iteration, the LP of (8) is solved using the accumulated set of preference statements and a new proxy to the user’s value function is derived. The preference values of all N objects in the collection are then computed using this new proxy to the user’s value function. All N objects are then reordered on the basis of their preference values and the top few previously unseen objects from this reranked list are presented to the user in the next iteration for preference feedback. The collection of N objects can be obtained either through a keyword search or a standard query on a database. For example, for a car search, one can query a database of used cars to find cars in the $10K–$30K price range and 2004–2006 year range. Suppose this retrieves 500 used cars from the database; then N = 500. Similarly, for Web pages, one can do a search for “Craig Kirkwood” and Google might retrieve about 80,000 Web pages from the billions it has in its database; then N = 80 000. Our interactive search method starts with this initial set of N objects. The value of our approach is in quickly filtering this set of N objects using the user’s preference function. It can be seen as an efficient user-guided filtering of a large

210 collection of objects that has been produced by an initial search or query of a database. Let NT be the maximum number of preferred or relevant objects for which the user is searching. For example, a realtor may not want a list of more than 10 houses for a potential homebuyer to visit. We assume that the user specifies this maximum number NT before the search begins. The iterative search procedure stops when the user is satisfied with the top few objects (at most NT ) from the reranked list at any iteration. Cross-product terms can be added and dropped from (7) using a variety of heuristics. In general, there can be many cross-product terms. It is desirable to add only the ones that have an impact. For example, if cars are being searched for on the Internet and a preferred car is a “black BMW priced at $30K,” we can add the following cross-product terms to the value function of (7): “black and BMW,” “black and $30K,” “BMW and $30K,” and “black, BMW, and $30K.” Thus, cross-product terms are based on the attribute values of objects actually seen by the user. If the user has yet to see that “silver Lexus priced at $40K,” then no cross-product terms, such as “silver and Lexus,” are created from its attribute values. After solving the LP problem of (8) with the added crossproduct terms, suppose the term “black and BMW” is the only one with a nonzero weight. In that case, we can drop the other cross-product terms before proceeding to the next iteration. Thus, a simple heuristic for selecting cross-product terms at each iteration is as follows: (1) add some cross-product terms from the new object, (2) obtain the weights by solving the LP of (8), and (3) then drop cross-product terms that have zero weights. The algorithm uses three lists. List 1 consists of NL1 objects not seen by the user before; List 2 consists of objects already seen by the user in the prior iterations, and List 3 has the top NT objects from the reranked collection. All three lists are presented to the user at each iteration. The user is asked for preference feedback on the objects in List 1 and can compare them with objects in List 2. List 3 helps the user decide when to stop the iterative search. An Interactive Search Algorithm with User Feedback. We now present an interactive search algorithm based on the above discussion.


(0) Initialize the search: Arbitrarily select a diverse set of at least NL1 objects from the collection of N objects and add them to List 1. Initialize Lists 2 and 3 as empty lists. (1) Present three lists of objects to the user: (a) List 1, which has the newly selected objects not seen by the user before; (b) List 2, which has the objects already seen by the user in prior iterations; and (c) List 3, which has the top NT objects from the re-ranked collection. The objects in List 3 are rank ordered by their preference values computed from the last approximation to the value function. (2) Get preference feedback from the user on the new objects: Ask the user to provide preference feedback on the objects in List 1 either by (a) assigning an object in List 1 to one of the predetermined preference categories such as high, medium, and low preference or by (b) directly comparing an object in List 1 with an object in either List 1 or List 2. Preference feedback is required on at least one of the objects in List 1, but the rest can be skipped. The user can also provide additional preference feedback on the objects in List 2. Add all new preference statements to the cumulative set of preference statements. (3) Solve the LP of (8) for a new estimate of the user’s value function: Solve the LP problem of (8) with all the accumulated preference statements and the relevant cross-product terms to get new weights wi for the single-valued attributes and cross-product terms. Use the new weights wi to construct a new approximation to the user’s value function. Drop cross-product terms whose weights are negligible. (4) Rerank all objects in the collection using the new value function: Compute the preference values of all N objects in the collection and rerank them using this new approximation to the user’s value function. (5) Add/drop cross-product terms as necessary: Add and drop cross-product terms as necessary from the attribute values of objects that have user preference feedback. (6) Select the top few objects from the reranked list and check the stopping criterion: Select the top NT objects from this reranked list for List 3. If the user is satisfied with the list of NT objects, then stop. Otherwise continue to step (7). (7) Create a new list of objects to present to the user: Select NL1 objects from the top NT objects. These


211


NL1 objects should be the ones that the user has not seen before. Create a new List 1 with these NL1 objects and update List 2. Go back to step (1) for the next iteration. This iterative search process stops when the user is satisfied with the reranked list of objects. The proxy to the value function of the user essentially serves as a filter in the search process. Although the algorithm starts by presenting a diverse set of objects from a collection, a slight modification might be required in steps (6) and (7) to deal with searches for rare objects. When the user consistently indicates low preference for the objects presented, it is evident that she is searching for rare objects in the collection. For example, suppose that a used car dealer generally keeps cars in the $50K–$100K price range, but also holds some rare and expensive ones such as a $300K Rolls-Royce. Let us assume that the user is interested in finding rare cars in a dealership for bargains, but she does not know their make, their prices, and so on. If the search algorithm presents cars in the normal price range of $50K–$100K, they would all be of low preference to her, and that would certainly indicate that she is looking for rare cars. Therefore, in general, if the objects presented to the user consistently have low preference for a few iterations, then there has to be some intervention in steps (6) and (7) to present objects with rare attributes, such as the $300K Rolls-Royce. Such intervention might be invoked after two or three iterations of low preference feedback.

3.

Some Illustrative Examples

Next we illustrate the search algorithm of the previous section with an example based on the scenario of someone searching for cars on a used car dealer’s website. Suppose only three attributes—Color, Price, and Manufacturer—describe a car in the inventory of the used car dealer and the attributes have the following discrete values: Color = (red, black, or silver); Price = ($20K, $25K, $30K, $35K, or $40K); Manufacturer = (BMW, Acura, Lexus, or Honda). Therefore, the following vector Dk of 0-1 variables defines a car object: Dk = (Color-red, Color-black, Color-silver, Price$20K, Price-$25K, Price-$30K, Price-$35K, Price-$40K, Make-BMW, Make-Acura, Make-Lexus, Make-Honda).

Table 1

Vectors Describing Some of the 20 Cars in the Inventory

D1 = 0 0 1 0 0 1 0 0 0 0 1 0 = a D2 = 0 1 0 1 0 0 0 0 0 0 0 1 = a D3 = 0 1 0 0 0 1 0 0 1 0 0 0 = a D4 = 1 0 0 0 1 0 0 0 0 1 0 0 = a D5 = 0 1 0 0 0 0 0 1 1 0 0 0 = a D6 = 0 0 1 0 0 0 1 0 0 1 0 0 = a D7 = 1 0 0 1 0 0 0 0 0 0 0 1 = a

silver Lexus at $30K black Honda at $20K black BMW at $30K red Acura at $25K black BMW at $40K silver Acura at $35K red Honda at $20K

Here each 0-1 variable indicates the presence or absence of the corresponding attribute value. Thus, when the variable Color-red has a value of 1, the color of the car is red, and when it has a value of 0, the color of the car is not red. Therefore, the car vector Dk = 1 0 0 0 1 0 0 0 0 1 0 0 represents a red Acura priced at $25,000 and the car vector Dk = 0 1 0 0 0 1 0 0 1 0 0 0 represents a black BMW priced at $30,000. The vector Dk expands when crossproduct terms are added. Suppose a potential car-buyer is interested in looking at cars in the $28,000–$32,000 price range. She has some preference for color and manufacturer but would first like to see what is available and then make a final choice. She therefore decides to use the used car dealer’s interactive online system to search through the inventory and find a set of at most five cars for further evaluation. Thus, NT = 5. Table 1 shows the vectors for some of the 20 cars in the inventory of the dealer (N = 20). In the following two examples, we present different sets of cars to the user initially and demonstrate that the algorithm is not dependent on the selection of initial objects presented to the user. In the third example, we introduce cross-product terms and examine their potential usage. The predetermined preference categories for these examples are high, medium, and low. 3.1. Example 1 Suppose the online system initially shows the following cars—D1 , D2 , D4 , and D5 —to the user for preference feedback. Suppose she states her preferences as follows: (a) D1 : High preference, (b) D2 and D5 : Low preference, (c) D1 is somewhat preferred to D4 .


212


These preference statements translate to the following constraints in (8): Constraint 1: D1 is preferred to D2 w3 + w6 + w11 − w2 − w4 − w12 ≥ (

Constraint 2: D1 is preferred to D5 w3 + w6 + w11 − w2 − w8 − w9 ≥ (


Table 2 V D1 = 3 V D18 = 3 V D8 = 2 V D20 = 2 V D4 = 15 V D6 = 15 V D14 = 15 V D3 = 10 V D7 = 10 V D9 = 10

Rank-Ordering of the 20 Cars Based on Their Preference Values a a a a a a a a a a

silver Lexus at $30K red Lexus at $30K silver Lexus at $25Ka red Lexus at $40K red Acura at $25K silver Acura at $35K black Acura at $30K black BMW at $30K red Honda at $20K red BMW at $40K

V D10 = 10 V D11 = 10 V D12 = 10 V D13 = 10 V D15 = 10 V D17 = 10 V D16 = 05 V D2 = 0 V D5 = 0 V D19 = 0

a a a a a a a a a a

black black black silver silver silver black black black black

Lexus at $35K Lexus at $40K Honda at $30K BMW at $35K BMW at $35K Honda at $25K Acura at $40K Honda at $20K BMW at $40K BMW at $35K

a

Note that this alternative is not considered dominated by the first alternative, since there exist additional features not included in the vectors. If desired, we could easily incorporate constraints into the lambda problem accounting for dominance relations. For example, a $25K red Lexus would be preferred to a $30K red Lexus. This is, however, not relevant for google type searches, where we do not know whether certain keywords (attributes) are desirable or not.


Constraint 5: D4 is preferred to D2

w3 + w6 + w11 − w2 − w8 − w9 ≥ (

At each iteration in these examples, we present the user with two new objects (cars) for preference feedback; NL1 = 2. Of the top three cars in the above list, the user has not seen the cars D18 (a red Lexus priced at $30K) and D8 (a silver Lexus priced at $25K). Hence, they are presented next to the user for preference feedback. From here on we number the iterations and present the algorithmic steps and user interactions in a summary form using the notation of §2.4.

w3 + w6 + w11 − w1 − w5 − w10 ≥ (

Iteration 1:

w1 + w5 + w10 − w2 − w8 − w9 ≥ (

List 1 new objects presented to the user for preference feedback: (1) D18 (a red Lexus priced at $30K), (2) D8 (a silver Lexus priced at $25K).

w1 + w5 + w10 − w2 − w4 − w12 ≥ (

Therefore, the first LP problem of (8) for estimating the user’s value function is Maximize ( s.t. w3 + w6 + w11 − w2 − w4 − w12 ≥ (

w1 + w5 + w10 − w2 − w4 − w12 ≥ ( 0 ≤ wi ≤ 1

i = 1 12

( ≥ 0

The following weights are obtained by solving this LP: w1 (Color-red) = 0 0; w2 (Color-black) = 0 0; w3 (Color-silver) = 1 0; w4 (Price-$20K) = 0 0; w5 (Price-$25K) = 1 0; w6 (Price-$30K) = 1 0; w7 (Price-$35K) = 0 0; w8 (Price$40K) = 0 0; w9 (Make-BMW) = 0 0; w10 (Make-Acura) = 0 5; w11 (Make-Lexus) = 1 0; w12 (Make-Honda) = 0 0. The user’s value function is approximated using these weights and is then used to calculate the preference values of all 20 cars in the inventory. Table 2 shows the rank ordering of the twenty cars based on their preference values.

List 2 objects previously seen by the user: (1) D1 (a silver Lexus priced at $30K), (2) D2 (a black Honda priced at $20K), (3) D4 (a red Acura priced at $25K), (4) D5 (a black BMW priced at $40K). List 3 top five objects in the reranked list: D1 , D18 , D8 , D20 , and D4 User’s preference feedback: (a) D18 preferred to D1 , (b) D18 preferred to D8 . Constraints added to 8: (a) D18 preferred to D1 , (b) D18 preferred to D8 .


213


Weights from new LP solution: w1 (Color-red) = 1 0; w2 (Color-black) = 0 0; w3 (Color-silver) = 0 0; w4 (Price-$20K) = 0 0; w5 (Price-$25K) = 0 0; w6 (Price-$30K) = 1 0; w7 (Price-$35K) = 0 0; w8 (Price$40K) = 0 0; w9 (Make-BMW) = 0 0; w10 (Make-Acura) = 0 0; w11 (Make-Lexus) = 1 0; w12 (Make-Honda) = 0 0. New rank orderings of all twenty cars based on their preference values: V Dk = 3 V Dk = 2 V Dk = 1 V Dk = 0

D18 D1 , D20 D3 , D4 , D7 , D8 , D9 , D10 , D11 , D12 , D14 D2 , D5 , D6 , D13 , D15 , D16 , D17 , D19

w4 (Price-$20K) = 0 0; w5 (Price-$25K) = 0 5; w6 (Price-$30K) = 1 0; w7 (Price-$35K) = 0 0; w8 (Price$40 K) = 0 0; w9 (Make-BMW) = 0 0; w10 (Make-Acura) = 0 0; w11 (Make-Lexus) = 0 0; w12 (Make-Honda) = 0 0. New rank orderings of all 20 cars based on their preference values: V Dk = 1 5 V Dk = 1 25 V Dk = 1 V Dk = 0 75 V Dk = 0 5 V Dk = 0 25 V Dk = 0 0

D3 , D12 , D14 D18 D1 D4 D2 , D5 , D8 , D10 , D11 , D16 , D17 , D19 D7 , D9 , D20 D6 , D13 , D15

Of the top five cars in this reordered list, the user has not previously seen the cars D20 (a red Lexus priced at $40K) and D3 (a black BMW priced at $30K), and they are presented next to the user for preference feedback.

Of the top five cars in this reordered list, the user has not previously seen the cars D12 (a black Honda priced at $30K) and D14 (a black Acura priced at $30K). They are presented next to the user for preference feedback.

Iteration 2:

Iteration 3:

List 1 new objects presented to the user for preference feedback: (1) D20 (a red Lexus priced at $40K), (2) D3 (a black BMW priced at $30K).

List 1 new objects presented to the user for preference feedback: (1) D12 (a black Honda priced at $30K), (2) D14 (a black Acura priced at $30K).

List 2 objects previously seen by the user: (1) D1 (a silver Lexus priced at $30K), (2) D2 (a black Honda priced at $20K), (3) D4 (a red Acura priced at $25K), (4) D5 (a black BMW priced at $40K), (5) D18 (a red Lexus priced at $30K), (6) D8 (a silver Lexus priced at $25K). List 3 top five objects in the reranked list: D18 , D1 , D20 , D3 , and D4 User’s preference feedback: (a) D20 : Low preference, (b) D3 : Best one so far. Constraints added to 8: (a) D1 preferred to D20 , (b) D3 preferred to D18 . Weights from new LP solution: w1 (Color-red) = 0 25; w2 (Color-black) = 0 5; w3 (Color-silver) = 0 0;

List 2 objects previously seen by the user: (1) D1 (a silver Lexus priced at $30K), (2) D2 (a black Honda priced at $20K), (3) D4 (a red Acura priced at $25K), (4) D5 (a black BMW priced at $40K), (5) D18 (a red Lexus priced at $30K), (6) D8 (a silver Lexus priced at $25K), (7) D20 (a red Lexus priced at $40K), (8) D3 (a black BMW priced at $30K). List 3 top five objects in the reranked list: D3 , D12 , D14 , D18 , and D1 User’s preference feedback: (a) D12 : Medium preference, (b) D14 : Medium preference. Constraints added to 8: (a) D1 preferred to D12 , (b) D1 preferred to D14 , (c) D3 preferred to D12 , (d) D3 preferred to D14 .


214


Weights from new LP solution: w1 (Color-red) = 0 25; w2 (Color-black) = 0 0; w3 (Color-silver) = 0 0; w4 (Price-$20K) = 0 0; w5 (Price-$25K) = 0 75; w6 (Price-$30K) = 1 0; w7 (Price-$35K) = 0 0; w8 (Price$40K) = 0 0; w9 (Make-BMW) = 0 75; w10 (Make-Acura) = 0 0; w11 (Make-Lexus) = 0 25; w12 (Make-Honda) = 0 0. New rank orderings of all 20 cars based on their preference values: V Dk = 1 75 V Dk = 1 5 V Dk = 1 25 V Dk = 1 0 V Dk = 0 75 V Dk = 0 5 V Dk = 0 25 V Dk = 0 0

D3 D18 D1 D4 , D8 , D9 , D12 , D14 D5 , D13 , D15 , D17 , D19 D20 D7 , D10 , D11 D2 , D6 , D16

Because the user likes the top three cars in the above list, which are shown below, she decides to terminate the search and evaluate these three cars in some more depth. D3 = a black BMW at $30K D18 = a red Lexus at $30K D1 = a silver Lexus at $30K General Comment on LP Solutions. As more constraints are added to the LP in the iterative search process, the solution space for the weights wi tightens and a better approximation to the value function is obtained. This can be seen in the gradual convergence of the weights wi in this example and the next. 3.2.

How Is This Process of Search Different for Car Searches on the Internet? Currently, searching for houses or cars on the Internet is based on a database search through queries, which can be a tedious process. One basically specifies some broad parameters for the query and looks at the results. For example, we went to http://www.car.com to look for used passenger cars in the $10K–$20K range that were 2004 and newer. It found 70 Dodge Cobalts, 60 Dodge Calibers, 26 Ford Five Hundreds, 26 Ford Fusions, one Hyundai Azera, 5 Kia Amantis, and so on, for a total of 210 passenger cars. At this point,

one has to read through a lot of the car descriptions to find the most preferred one. There is no easy way to indicate to the system that you like some of these cars and do not like the others and from that information have it further filter the list of 210 cars. This is the basic difference between the existing systems and our value function–based guided search. Interactive search embodies “learning” by the system of the user’s preferences. In existing systems, the system makes no attempt to learn about the user’s preferences as she examines certain cars. The basic idea of learning a user’s preference function is to make the search process more efficient. 3.3.

Example 2—A Different Set of Cars at Start of Search This is the same search problem as the one in Example 1, but we present a different set of four cars to the user in the beginning. They are D20 , D19 , D17 , and D14 . In both examples, we start with cars that are not the most preferred ones. Suppose the user states her preferences as follows: (a) D19 : High preference, (b) D20 and D17 : Low preference, (c) D19 is preferred to D14 . For each iteration, we provide only the list of cars presented to the user and the user’s preference feedback. We show the rank orderings after the third iteration. Iteration 1: List 1 new objects presented to the user for preference feedback: (1) D13 (a silver BMW priced at $35K), (2) D3 (a black BMW priced at $30K). User’s preference feedback: (a) D13 : Medium preference, (c) D3 : Best one so far. Iteration 2: List 1 new objects presented to the user for preference feedback: (1) D15 (a silver BMW priced at $30K), (2) D5 (a black BMW priced at $40K). User’s preference feedback: (a) D5 : Low preference, (b) D3 preferred to D15 .


Iteration 3: List 1 new objects presented to the user for preference feedback: (1) D18 (a red Lexus priced at $30K), (2) D9 (a red BMW priced at $40K), User’s preference feedback: (a) D9 : Low preference, (b) D3 preferred to D18 . New rank orderings of all 20 cars based on their preference values: V Dk = 2

D3

V Dk = 1 75

D1 , D15 , D18

V Dk = 1 5

D10 , D19

V Dk = 1 25

D12 , D13 , D14

V Dk = 1 0

D5 , D11

V Dk = 0 75

D8 , D9 , D20 ,

V Dk = 0 5

D6

V Dk = 0 25

D2 , D16

V Dk = 0 0

D4 , D7 , D17

Because the user likes the top four cars in the above list, which are shown below, she decides to terminate the search and evaluate these four cars in some more depth. D3 = a black BMW at $30K D1 = a silver Lexus at $30K D15 = a silver BMW at $30K D18 = a red Lexus at $30K Note that the rank orderings in these two examples at the end of Iteration 3 are somewhat different, although the preferred cars D3 , D1 , and D18 “bubble up” to the top fairly quickly in both cases. This is generally what search is about—retrieving a set of preferred objects quickly. 3.4.

Example 3—Adding Cross-Product Terms for a Multiplicative Value Function Next we show how cross-product terms are added when a multiplicative value function is warranted. Cross-product terms can always be added at a later iteration once a few objects (cars) have been

215 shown to the user. Let us add the following cross-product variables to the LP of Iteration 3 in Example 1: Black_BMW, Red_BMW, Silver_BMW, Black_Lexus, Red_Lexus, Silver_Lexus, Black_Honda, Red_Acura, $30K_BMW, $30K_Lexus, Black_$30K, Red_$30K, Silver_$30K, and Red_$25K. These are some of the two-attribute value combinations that actually exist in the cars seen up to Iteration 3 in Example 1. The following expanded vector Dk of 0-1 variables now defines a car object: Dk = (Color-red, Color-black, Color-silver, Price-$20K, Price-$25K, Price-$30K, Price-$35K, Price-$40K, Make-BMW, Make-Acura, Make-Lexus, Make-Honda, Black_BMW, Red_BMW, Silver_BMW, Black_Lexus, Red_Lexus, Silver_Lexus, Black_Honda, Red_Acura, $30K_BMW, $30K_Lexus, Black_$30K, Red_$30K, Silver_$30K, and Red_$25K). For cross-product terms, each 0-1 variable indicates the presence or absence of the corresponding attribute value combination. Thus, when the car is a black BMW, the variable Black_BMW has a value of 1, and it has a value of 0 when it is not a black BMW. Therefore, the car vector Dk = 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 represents a red Acura priced at $25K and the car vector Dk = 0 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 represents a black BMW priced at $30K. With these cross-product variables added, the following weights are obtained by solving the LP of Iteration 3 in Example 1: w1 (Color-red) = 1 0; w2 (Color-black) = 0 0; w3 (Color-silver) = 1 0; w4 (Price-$20K) = 0 0; w5 (Price-$25K) = 0 7; w6 (Price-$30K) = 1 0; w7 (Price-$35K) = 0 0; w8 (Price$40K) = 0 0; w9 (Make-BMW) = 1 0; w10 (Make-Acura) = 1 0; w11 (Make-Lexus) = 0 0; w12 (Make-Honda) = 0 0; w13 (Black_BMW) = 1 0; w14 (Red_BMW) = 0 0; w15 (Silver_BMW) = 0 0; w16 (Black_Lexus) = 0 0; w17 (Red_Lexus) = 1 0; w18 (Silver_Lexus) = 1 0; w19 (Black_Honda) = 0 0; w20 (Red_Acura) = 0 0; w21 ($30K_BMW) = 1 0; w22 ($30K_Lexus) = 0 2; w23 (Black_$30K) = 1 0; w24 (Red_$30K) = 1 0; w25 (Silver_$30K) = 0 3; w26 (Red_$25K) = 0 0. Using this approximation to the multiplicative value function with cross-product terms, the rank-orderings


216


of the cars based on their preference values are as follows: New rank orderings of all 20 cars based on their preference values: V Dk = 5 V Dk = 4 25 V Dk = 3 5 V Dk = 3 0 V Dk = 2 75 V Dk = 2 0 V Dk = 1 75 V Dk = 1 0 V Dk = 0 0

D3 D18 D1 D14 D4 , D 8 D5 , D6 , D9 , D12 , D13 , D15 , D19 , D20 D17 D7 , D16 D2 , D10 , D11

With cross-product terms added, the weights change, and there is a slightly better differentiation of cars at the top. Note the cross-product variables with positive weights: w13 (Black_BMW) = 1 0; w17 (Red_Lexus) = 1 0; w18 (Silver_Lexus) = 1 0; w21 ($30K_BMW) = 1 0; w22 ($30K_Lexus) = 0 2; w23 (Black_$30K) = 1 0; w24 (Red_$30K) = 1 0; w25 (Silver_$30K) = 0 3.

4.

Computational Results

We have implemented a version of this interactive search algorithm in Visual Basic using a standard linear programming package. The purpose of our computational test was to show that the interactive search procedure works and can find the “most preferred” object or alternative in a collection in a reasonable number of iterations and with a reasonable amount of user feedback. Here finding the “most preferred” object meant that the algorithm stopped only after it presented the “most preferred” object to the user. Although this stopping criterion increased the total amount of user interaction, it allowed us to test the capability of the search algorithm to find the best alternative in a reasonable number of iterations. There were no actual users in the test runs. Instead, surrogate value functions were used to simulate users, and those value functions were randomly generated with random weights. We tested the algorithm on problems of different sizes and with different types of user feedback. In these tests, we randomly generated different

collections of objects and then searched each collection a number of times using randomly generated value functions and randomly generated starting objects for presentation to the user. 4.1.

Generating the Collections of N Objects of Different Types The collections of N objects were randomly generated, but in a way that reflected object collections normally encountered in Web and other types of searches on the Internet (for cars, houses, etc.). The objects in those collections usually have some special characteristics or attributes that define them in some unique way and that usually lead to different groupings of objects based on those unique attributes. For example, when searching for “Craig Kirkwood” on the Web, one finds a movie actor Craig Kirkwood, a decision analyst Craig Kirkwood, a marathon runner Craig Kirkwood, and so on. Each one of the Craig Kirkwoods may have hundreds or thousands of Web pages on the Internet. Most notably, not only are there different Craig Kirkwoods, but they also have different attributes that describe them uniquely. For example, decision analyst Craig Kirkwood has attributes (words in Google snippets) such as “Arizona,” “State,” “University,” “decision,” and “analysis,” whereas the movie actor has attributes such as “movie,” “photos,” “filmography,” “celebrity,” and “Hollywood.” This means that there are objects in these collections that are characterized by sets of distinct attributes, and the objects can be grouped together into different categories on the basis of those distinct attributes. Thus, all Web pages for decision analyst Craig Kirkwood can be in a group based on their unique attributes, and those for the movie actor can be in another group, and so on. In a similar manner, we can group cars on the basis of certain attributes, such as price, make, model, and so on. Thus, there can be a luxury car group consisting of certain models of Lexus, BMW, and Mercedes Benz that have prices greater than $80K. And there can be a cheaper compact car category consisting of certain models from Ford, General Motors, Kia, and Mitsubishi that have prices in the range of $10K–$20K. This implies that inexpensive compact cars do not have price tags of $80K and up and that there are no luxury cars at $10K.


217


We generated collections of objects based on these ideas to create our test problems. We created different categories of objects in each collection and used a set of attributes and attribute values to distinguish between the categories. We had 10 categories of objects in each test collection, and half the set of attributes was designated as special attributes whose values uniquely identified the categories. In a way, the 10 different object categories in each collection could have reflected, for example, 10 different Craig Kirkwoods, 10 different types of cars (small, medium, large, sport utility vehicle, and so on), or 10 different types of houses (condos, townhouses, 2,000-sq.-ft. houses, 3,000-sq.-ft. houses, and so on). We generated an equal number of objects for each category. Thus, if the collection of 10,000 objects represented cars, for example, it had 1,000 small cars, 1,000 medium-sized cars, and so on. For each special attribute that helped to define the object categories uniquely, we allocated four of its values to each category. Thus, for example, if car price was a special attribute and its values were in the range of $20K–$100K in increments of $2K, we allocated the top four prices ($94K–$100K) to the luxury car category, the bottom four prices ($20K–$26K) to the inexpensive compact car category, and so on. To create an object of a certain category, we randomly generated one of the four attribute values allocated to the category and assigned it to the object. Suppose, for example, a luxury car object had to be created for the collection. Then one of the four prices in the range of $94K–$100K was randomly generated and assigned to the object. In addition to the attributes that were unique to the different categories, we used other attributes that were common to all categories. For example, color is an attribute that is common to all categories of cars. Thus, there were two sets of attributes for objects in our test collections, the ones that were unique to the different categories and those that were common to all. For our test collections, we divided the attribute set equally—half were unique attributes and half were common attributes. Column 1 in Tables 3–10 shows the number of unique attributes in the collection and the number of different values that each unique attribute can take. The number of different values that each unique attribute can take was kept the same for all unique

attributes. So 10∗40 in column 1 means that there were 10 unique attributes in the collection and each unique attribute could take on 40 different values. For each unique attribute, the 40 different values were partitioned into 10 sets, with one set assigned to each of the 10 categories. Column 2 shows the number of common attributes in the collection and the number of different values that each common attribute can take. We created different search problems by randomly generating collections of 10,000 objects, with 1,000 objects per category in each collection. Each row in Tables 3–10 represents a different search problem defined by a collection of 10,000 objects and a set of unique and common attributes. Each collection of 10,000 objects was then searched 100 times by our search algorithm, where each of the 100 searches used a different randomly weighted surrogate value function. For each search, the initial set of objects presented to the surrogate user was randomly selected as well. Column 3 of Tables 3–8 and column 5 of Tables 9 and 10 report the average, standard deviation, and range (minimum, maximum) of the number of preference comparisons (or statements) made by the surrogate user (decision maker) over the 100 random searches. Column 4 of Tables 3–8 and column 6 of Tables 9 and 10 report the average, standard deviation, and range (minimum, maximum) of the number of iterations of the search algorithm over the 100 random searches until the “most preferred” alternative or object was found and presented to the user. Note that we did not provide the interactive search algorithm of §2.4 with any information about the existence of different categories of objects in the test collections or the existence of different attributes that uniquely defined the different categories. Thus, the interactive search algorithm was not altered in any way to take advantage of our document-generation method. 4.2.

Randomly Generated Surrogate Value Functions In our simulations, the surrogate value functions were randomly generated for the searches. On each collection of 10,000 objects with 10 categories of objects, we performed 100 searches with randomly generated surrogate value functions. Because our test collections had 10 categories of objects, we divided the 100 random searches equally between the 10 categories; thus,


218


Table 3

Average Number of Iterations and Preference Statements to Find the Best Alternative for Linear Value Functions with Random Weights and Random Initial Set of Objects and Preference Statement Type “High, Medium, or Low Preference”

Column 1

Column 2

No. of unique attributes ∗ no. of values per attribute

No. of common attributes ∗ no. of values per attribute

Column 3

Column 4

Number of preference comparisons by decision maker

Number if iterations to find the most preferred alternative

Average (std. dev./ min/max)


Column 5 MQ, minimum no. of questions by a decision analysis method

Column 6

Column 7

Ratio = MQ of column 5/ average no. of preference comparisons in column 3

Ratio = MQ of column 5/ max no. of preference comparisons in column 3

5 ∗ 40

5∗5

66.4 (24.9/20/140)

10.9 (4.6/2/25)

213

321

152

10 ∗ 40

10 ∗ 5

76.9 (28.2/30/165)

13.0 (5.4/4/28)

428

557

259

15 ∗ 40

15 ∗ 5

95.6 (40.0/15/215)

16.6 (7.9/2/40)

643

673

299

20 ∗ 40

20 ∗ 5

98.8 (44.3/20/250)

17.3 (8.6/2/47)

858

869

343

25 ∗ 40

25 ∗ 5

112.5 (54.2/25/255)

20.2 (10.8/3/48)

1073

954

421

30 ∗ 40

30 ∗ 5

124.1 (58.5/25/265)

22.5 (11.6/3/50)

1288

1038

486

40 ∗ 40

40 ∗ 5

125.3 (62.2/25/320)

22.9 (11.9/3/51)

1718

1371

537

Table 4

Average Number of Iterations and Preference Statements to Find the Best Alternative for Linear Value Functions with Random Weights and Random Initial Set of Objects and Preference Statement Type “A Preferred to B”

Column 1

Column 2



Column 3

Column 4






Column 6

Column 7



5 ∗ 40

5∗5

57.8 (33.8/10/240)

10.6 (6.8/1/47)

213

369

089

10 ∗ 40

10 ∗ 5

77.5 (50.3/10/245)

14.6 (10.1/1/48)

428

552

175

15 ∗ 40

15 ∗ 5

104.6 (68.5/15/395)

19.9 (13.7/2/78)

643

615

163

20 ∗ 40

20 ∗ 5

126.6 (87.4/20/430)

24.3 (17.5/3/85)

858

678

200

25 ∗ 40

25 ∗ 5

137.3 (98.1/10/580)

26.5 (19.6/1/115)

1073

782

185

30 ∗ 40

30 ∗ 5

156.6 (118.7/20/680)

30.3 (23.7/3/135)

1288

822

189

40 ∗ 40

40 ∗ 5

177.4 (147.4/20/755)

34.5 (29.5/3/148)

1718

969

228


219


Table 5

Average Number of Iterations and Preference Statements to Find the Best Alternative for Linear Value Functions with Random Weights and Random Initial Set of Objects and Preference Statement Type “Best Alternative so Far”

Column 1

Column 2



Column 3

Column 4






Column 6

Column 7



5 ∗ 40

5∗5

81.7 (51.1/15/325)

15.3 (10.2/2/64)

213

261

066

10 ∗ 40

10 ∗ 5

109.5 (63.6/10/305)

20.1 (12.7/1/60)

428

391

140

15 ∗ 40

15 ∗ 5

131.9 (103.9/10/525)

24.0 (20.8/1/104)

643

487

122

20 ∗ 40

20 ∗ 5

135.1 (107.8/10/610)

24.5 (21.6/1/121)

858

635

141

25 ∗ 40

25 ∗ 5

167.7 (133.6/10/530)

30.3 (24.2/1/105)

1073

640

202

30 ∗ 40

30 ∗ 5

186.8 (142.1/15/665)

36.4 (28.4/2/132)

1288

690

194

40 ∗ 40

40 ∗ 5

216.7 (151.5/15/720)

42.3 (30.3/2/143)

1718

793

239

Table 6

Average Number of Iterations and Preference Statements to Find the Best Alternative for Multiplicative Value Functions with Random Weights, 20 Cross-Product Terms, and Random Initial Set of Objects and Preference Statement Type “High, Medium, and Low”

Column 1

Column 2



Column 3

Column 4

Number of preference statements by decision maker

Number of iterations to find the most preferred alternative

Average (std. dev./min/max)


W/O CProd

With CProd

W/O CProd

With CProd

5 ∗ 40

5∗5

70.6 (26.9/25/140)

60.5 (18.6/10/125)

11.5 (5.1/3/24)

9.7 (3.2/1/22)

10 ∗ 40

10 ∗ 5

80.3 (33.6/20/155)

65.1 (18.2/20/140)

13.6 (6.5/2/30)

10.5 (3.4/2/25)

15 ∗ 40

15 ∗ 5

95.7 (48.4/10/285)

68.2 (22.0/20/135)

16.7 (9.6/1/55)

10.8 (4.0/2/22)

20 ∗ 40

20 ∗ 5

103.0 (49.5/10/320)

71.8 (30.1/25/185)

18.4 (9.9/2/62)

12.1 (5.6/3/34)

25 ∗ 40

25 ∗ 5

107.9 (47.5/20/305)

79.0 (32.2/15/185)

19.1 (9.0/2/60)

13.1 (6.2/2/33)

30 ∗ 40

30 ∗ 5

122.0 (74.1/20/340)

79.7 (32.2/15/185)

21.8 (14.4/2/66)

13.5 (6.2/2/33)

40 ∗ 40

40 ∗ 5

123.6 (97.2/20/470)

94.6 (42.2/20/230)

22.3 (19.3/2/93)

16.5 (8.2/2/42)


220


Table 7

Average Number of Iterations and Preference Statements to Find the Best Alternative for Multiplicative Value Functions with Random Weights, 20 Cross-Product Terms, and Random Initial Set of Objects and Preference Statement Type “A Preferred to B”

Column 1

Column 2



Column 3

Column 4





W/O CProd

With CProd

W/O CProd

With CProd

5 ∗ 40

5∗5

59.8 (22.5/10/100)

54.8 (20.3/10/155)

10.6 (4.5/1/19)

10.0 (4.1/1/30)

10 ∗ 40

10 ∗ 5

92.0 (47.7/15/325)

57.5 (24.6/10/125)

17.5 (9.5/2/64)

10.5 (4.9/1/24)

15 ∗ 40

15 ∗ 5

104.0 (66.1/10/335)

63.3 (28.7/15/190)

19.8 (13.2/1/66)

11.7 (5.7/2/37)

20 ∗ 40

20 ∗ 5

121.8 (88.4/15/630)

74.9 (34.9/15/190)

23.3 (17.7/2/125)

14.0 (7.0/2/37)

25 ∗ 40

25 ∗ 5

134.0 (91.0/15/485)

76.8 (31.2/15/150)

25.4 (18.2/2/96)

14.4 (6.2/2/29)

30 ∗ 40

30 ∗ 5

147.3 (93.4/20/500)

98.6 (45.0/15/295)

27.9 (18.7/3/99)

18.7 (9.0/2/58)

40 ∗ 40

40 ∗ 5

159.1 (130.8/15/755)

100.6 (46.4/25/245)

30.8 (26.2/2/150)

19.1 (9.3/4/48)

Table 8

Average Number of Iterations and Preference Statements to Find the Best Alternative for Multiplicative Value Functions with Random Weights, 20 Cross-Product Terms, and Random Initial Set of Objects and Preference Statement Type “Best Alternative so Far”

Column 1

Column 2



Column 3

Column 4





W/O CProd

With CProd

W/O CProd

With CProd

5 ∗ 40

5∗5

91.8 (75.9/10/420)

66.6 (38.6/10/320)

17.4 (15.2/1/83)

12.3 (7.7/1/63)

10 ∗ 40

10 ∗ 5

106.2 (91.9/10/430)

70.9 (37.9/15/220)

20.2 (18.4/1/85)

13.2 (7.6/2/43)

15 ∗ 40

15 ∗ 5

124.0 (103.9/10/525)

76.7 (48.2/15/365)

23.8 (20.8/1/104)

14.3 (9.6/2/72)

20 ∗ 40

20 ∗ 5

140.4 (108.0/10/610)

80.3 (35.9/10/215)

27.1 (21.6/1/121)

15.1 (7.2/1/42)

25 ∗ 40

25 ∗ 5

165.0 (130.9/20/615)

93.8 (60.5/20/470)

32.0 (26.2/3/122)

17.8 (12.1/3/93)

30 ∗ 40

30 ∗ 5

172.3 (120.5/25/710)

107.9 (63.7/25/330)

34.3 (24.1/4/141)

20.6 (12.8/4/65)

40 ∗ 40

40 ∗ 5

197.7 (157.9/15/755)

125.9 (87.2/10/505)

38.5 (31.6/2/150)

24.2 (17.5/1/100)


221


Table 9

Changing Preferences—Average Number of Iterations and Preference Statements to Find the Best Alternative for Linear Value Functions with Random Weights and Random Initial Set of Objects and Preference Statement Type “A Preferred to B”

Column 1

Column 2



Column 3

Column 4

Average from Table 2

Changed @ iteration

5 ∗ 40

5∗5

10.56

6

10 ∗ 40

10 ∗ 5

14.55

8

15 ∗ 40

15 ∗ 5

19.93

10

20 ∗ 40

20 ∗ 5

24.32

12

25 ∗ 40

25 ∗ 5

26.45

13

30 ∗ 40

30 ∗ 5

30.32

15

40 ∗ 40

40 ∗ 5

34.47

18

Column 6





W/O Change

W/Change

W/O Change

W/Change

63.0 (26.9/35/245) 92.0 (42.0/45/275) 127.3 (70.5/55/385) 155.4 (87.5/65/665) 180.0 (107.0/70/545) 196.0 (104.6/80/710) 236.0 (130.0/95/615)

83.2 (48.5/35/410) 127.5 (94.5/45/890) 160.0 (102.0/55/850) 199.0 (135.0/65/990) 231.0 (139.0/70/690) 202.6 (126.0/80/620) 277.0 (169.0/95/1,090)

11.6 (5.4/6/48) 17.4 (8.4/8/54) 24.5 (14.1/10/76) 30.0 (17.5/12/132) 35.0 (21.4/13/108) 38.2 (21.0/15/141) 46.2 (26.0/18/122)

15.6 (9.7/6/81) 24.5 (18.9/8/177) 31.0 (20.5/10/169) 38.7 (27.0/12/197) 45.1 (27.8/13/137) 39.5 (25.2/15/123) 54.4 (34.0/18/217)

10 of the searches had the “most preferred” object in the first category, another 10 had it in the second category, and so on. We constructed appropriate surrogate value functions, called category value Table 10

Column 5

functions, so that the “most preferred” object was in a certain category. To create a surrogate value function for a particular category, we assigned random weights to the unique attribute values assigned to that

Attributes Added Later—Average Number of Iterations and Preference Statements to Find the Best Alternative for Linear Value Functions with Random Weights and Random Initial Set of Objects and Preference Statement Type “A Preferred to B”

Column 1

Column 2



Column 3 Average from Table 2

Column 4 Changed @ iteration

5 ∗ 40

5∗5

10.56

6

10 ∗ 40

10 ∗ 5

14.55

8

15 ∗ 40

15 ∗ 5

19.93

10

20 ∗ 40

20 ∗ 5

24.32

12

25 ∗ 40

25 ∗ 5

26.45

13

30 ∗ 40

30 ∗ 5

30.32

15

40 ∗ 40

40 ∗ 5

34.47

18

Column 5

Column 6





W/O Change

W/Change

W/O Change

W/Change

57.4 (20.8/35/150) 92.0 (42.0/45/275) 114.0 (86.0/55/650) 155.4 (87.5/65/665) 153.4 (98.6/70/610) 196.0 (104.6/80/710) 214.0 (139.0/95/810)

63.0 (26.9/35/245) 106.8 (73.4/45/645) 127.3 (70.5/55/385) 163.9 (124.0/65/765) 180.0 (107.0/70/545) 200.0 (130.5/80/620) 236.0 (130.0/95/615)

10.5 (4.2/6/29) 17.4 (8.4/8/54) 21.8 (17.0/10/129) 30.0 (17.5/12/132) 29.7 (19.7/13/121) 38.2 (21.0/15/141) 41.7 (27.7/18/161)

11.6 (5.4/6/48) 20.4 (14.7/8/128) 24.5 (14.1/10/76) 31.8 (24.9/12/152) 35.0 (21.4/13/108) 39.0 (26.0/15/123) 46.2 (26.0/18/122)

222 category in addition to the common attributes. For unique attribute values assigned to a particular category, the random weights wi were in the range of 5–10. For common attributes, the random weights wi were in the range of 1–5. All other weights wi were in the range of 0–1. As an example, suppose we are generating a surrogate value function for the luxury car category and the unique attributes are “manufacturer” and “price.” Assume the manufacturer attribute has the following values: Lexus, BMW, Mercedes Benz, Ford, General Motors, Kia, and Mitsubishi. Let Lexus, BMW, and Mercedes Benz be the only ones manufacturing luxury cars. Then a surrogate value function for the luxury car category will have random positive weights between 5 and 10 for the manufacturers Lexus, BMW, and Mercedes Benz but weights between 0 and 1 for the other manufacturers. Similarly, let the luxury car prices be $80K and higher. In that case, only those prices will have random positive weights between 5 and 10, whereas the other prices will have weights between 0 and 1. The use of random surrogate value functions makes each search different and ensures that every object in the collection has an equal chance of being the “most preferred” object in a given search. 4.3.

Parameter Settings for Computational Testing The parameters of the search algorithm were set to some reasonable values for our computational tests. We did not try to fine-tune them to a particular problem in a trial-and-error manner to get the best results for that problem. They were set to the same values for all search problems. In our tests, we initially presented 10 objects (alternatives) to the user and then presented five new ones in subsequent iterations. A diverse set of 10 random objects was presented to the user initially. Therefore, NL1 , which is the list of objects not seen by the user before, was initially 10 and then changed to 5 for subsequent iterations. Again, these settings were not changed for any of the search problems. Thus, they were not optimally set in any sense. They just seemed reasonable from a user interaction point of view. However, they do not guarantee a minimal amount of preference feedback for the problems solved. NT is defined as the maximum number of preferred objects the user is searching for and was set to 5 in our



tests. That means the algorithm stops only after the “most preferred” object is in the top 5 of the reranked collection. 4.4.

Testing the Effectiveness of Different Types of User Feedback The interactive search algorithm of §2.4 allows two basic types of preference feedback: (1) through assignment of an object to one of the predefined preference categories such as high, medium, and low preference and (2) through preference statements such as “object A preferred to object B” that directly compare individual objects. In our tests, we added a variation of the second type of preference feedback, where the user can designate an alternative (object) to be the “best alternative (object) so far.” The computational results in Tables 3–10 are based on one of the following three types of preference feedback: (1) by indicating the preference category of an alternative as either high, medium, or low preference; (2) by indicating that alternative A is preferred to alternative B; and (3) by designating an alternative to be the “best alternative so far.” Although the algorithm of §2.4 allows the user to use any combination of these preference feedback types during a search, as shown in the examples of §3, in our computational tests we used only a particular type of feedback during a search. The purpose of this restriction was to find the most effective feedback type for quickly finding the “most preferred” alternative. However, there is no guarantee that the search method would converge to the “most preferred” alternative in a reasonable number of iterations, if it converges at all, for high, medium, and low type of preference feedback. In some cases, it might get stalled because assignment of alternatives to preference categories does not provide enough information to differentiate alternatives within a category. So the high, medium, low type of preference feedback should be used in conjunction with other preference feedback types to guarantee convergence to the “most preferred” alternative. When only the high, medium, and low type of preference feedback is used, convergence to the “most preferred” alternative would depend on the number of objects in the collection that are highly preferred. In our tests, we had 100 objects (alternatives) that were highly preferred in the collection of 10,000 objects, and we had convergence to the “most preferred” alternative in all cases.


223


4.5.

Performance Measurement—Evaluating the Efficiency of the Search Procedure for Different Feedback Types We used two measures to evaluate the efficiency of this search procedure for different feedback types: (1) the average number of preference feedbacks provided by the surrogate user to find the “most preferred” alternative and (2) the average number of iterations of the procedure to find the “most preferred” alternative. The averages are computed over the 100 random searches of each collection of 10,000 objects. We also provide the standard deviations and the ranges of the number of preference feedbacks and the number of iterations of the procedure for the 100 random searches of each collection. In our tests, the search procedure stops only after the “most preferred” alternative is presented to the surrogate user. The reason we used stringent stopping criterion was to avoid any questions about the quality of the solution obtained by this search procedure. 4.6.

Presentation of Alternatives and Counting the Number of Preference Feedbacks In the tests, we initially presented a diverse set of 10 objects (alternatives) to the surrogate user. At subsequent iterations, we presented five new objects to the user until termination. We now describe how the number of preference feedbacks was counted for column 3 of Tables 3–8 and column 5 of Tables 9 and 10. From the initial set of 10 diverse objects (alternatives), the surrogate user identified the best object (alternative) for both the “best alternative so far” and “A preferred to B” types of preference feedback. Thus, the initial set of user feedbacks generated nine constraints and was counted as nine preference statements. For the high, medium, and low type of preference feedback, each object (alternative) was assigned to a preference category, resulting in 10 preference statements. In subsequent iterations, for the “best alternative so far” type preference feedback, the prior best alternative was compared with the five new ones and a new “best alternative so far” was identified by the surrogate user. That counted as five additional preference statements and constraints at each iteration. For “A preferred to B” type of preference feedback, one of the five new objects (alternatives) was compared

with one of the top five old objects (alternatives), where each object was randomly selected from their respective lists. Thus, for “A preferred to B” type of preference feedback, there were five additional preference statements and constraints at each iteration. For the high, medium, and low type of preference feedback, each object (alternative) was assigned to a preference category, and, like the other two types of feedback, there were five preference statements at each iteration. This explains how the number of preference statements was counted and reported in column 3 of Tables 3–8 and column 5 of Tables 9 and 10. The following numbers are reported in the tables: the average, the standard deviation, and the range (minimum, maximum) of the number of preference statements over 100 random searches. 4.7.

Comparing the Efficiency of This Search Method with Decision Analysis Procedures Standard decision analysis procedures first construct a user’s value function and then use that to evaluate the alternatives (Keeney and Raiffa 1976, Edwards 1977, Kirkwood and Sarin 1980, Stillwell et al. 1981, Corner and Kirkwood 1991). For the linear additive value function of (2), a two-step procedure is used to assess the value function: (1) evaluate the single attribute value function vi xi for each attribute xi and (2) determine the relative weights i for those single attributes. These methods assess the single attribute value function vi xi by questioning the decision maker about preferences for different values of the attribute xi . A similar questioning method is used to determine the relative weights i . Let MQ be the minimum number of questions asked by a decision analysis procedure to assess a linear additive value function. If there are n attributes and each has P discrete values, then MQ = n ∗ P − 2 + n − 1 (Kirkwood 1997, Keeney and Raiffa 1976). This does not include questions related to consistency checks. In the test problems, we have different types of attributes. Each unique attribute of column 1 has 40 different values, whereas each common attribute of column 2 has just 5 different values. Thus, for a problem with 25 unique attributes and 25 common attributes, we computed MQ as follows: MQ = 25 ∗ 40 − 2 + 25 − 1 + 25 ∗ 5 − 2 + 25 − 1 = 1 073.


224


MQ estimates for the search problems are shown in column 5 of Tables 3–5 and are used to compare the efficiency of our search procedure with decision analysis methods. Because we could not find a similar estimate for the multiplicative value functions, MQ estimates are not shown in Tables 6–8. However, for the same number of attributes, the MQ estimates for linear value functions could serve as lower bounds for the minimum number of questions that would be asked to determine a multiplicative value function. 4.8.

Multiplicative Value Functions

4.8.1. Randomly Generating Surrogate Value Functions of the Multiplicative Form. To create surrogate value functions of the multiplicative form for our simulations, we added 20 two-term cross products to the linear value functions. Examples of twoterm cross products include “black and BMW,” “black and $30K,” and “BMW and $30K.” Both cross-product terms and their weights were randomly generated for each search. In other words, each single-valued attribute (or term) in the cross-products, such as “BMW” and “black,” was randomly selected from the list of unique and common attribute values actually used to construct a linear value function for a particular category. In addition, these cross-product terms were assigned higher weights, in the range of 10–15, compared to those of single-valued attributes (or terms). We restricted the multiplicative value functions to have two-term cross-products only. 4.8.2. The Search Method Is Robust—Linear Approximation Works for Multiplicative Value Functions Too. In all our simulations, the interactive search algorithm was never given any information about the value function the surrogate user was using. In other words, the search algorithm never knew whether the surrogate user had a linear value function or a multiplicative one or what the weights were on the different terms of the value function. Our test results show, in column “W/O CProd” of Tables 6–8, where “W/O CProd” means without crossproduct terms, that the search algorithm converges to the “most preferred” alternative by simply using a linear approximation to the value function even when the surrogate value function is of the multiplicative form.

Thus, the search method is very robust and can, in the worst case, construct an equivalent linear approximation to a nonlinear value function and use it to find the “most preferred” alternative. This process might take more iterations and require more user feedback, but it does work. 4.8.3. Heuristic for Adding and Dropping CrossProduct Terms During Search to Capture Interaction Effects Present in Multiplicative Value Functions. We also made separate simulation runs to test the capability of our search method to capture interaction effects present in multiplicative value functions. In these simulation runs, we tried to capture the interaction effects by creating cross-product terms by a trial-and-error process in the approximation to the value function in the LP of (8). We found that the search method actually converged faster to the “most preferred” alternative when we tried to capture the interaction effects (see column “With CProd” of Tables 6–8, where “With CProd” means with crossproduct terms). Thus, although a linear approximation to the value function works, the convergence is much faster when the interaction effects are captured in the approximation. We used a simple heuristic to capture the interaction effects during search. The heuristic creates cross products from two single-valued attributes (single terms), such as “BMW” and “$30K,” that are active. Singlevalued attributes are considered active if they actually exist in some of the top-ranked objects (alternatives) in the collection after the collection is reranked at each iteration using the new approximation to the user’s value function from the LP solution of (8). Thus, if there are no “black BMWs” in, say, the top five objects in the reranked collection at an iteration, then the single-valued attributes (terms) “BMW” and “black” cannot be combined to form a cross-product term. Use of only active single-valued attributes (terms) in cross-product terms essentially avoids creating crossproduct terms that are non-existent in the collection (e.g., there is no Lexus priced at $10K) or that do not appear to have significant value to the user based on the preference feedback up to that iteration. All cross-product terms become additional 0-1 variables in (8). Let TC be the maximum number of new cross-product terms that can be added to (8) at each iteration. In steps (3) and (4) of the algorithm in §2.4,


we rerank the objects (alternatives) in the collection using the new approximation to the value function of the user from the LP solution of (8). Let SAi, i = 1 NC, be the set of single-valued attributes (terms) that occur in i objects of the top NC objects in the reranked collection at an iteration. Suppose NC = 3 and the single-valued attributes (terms) that appear in all of the top three objects in the reranked collection are “$30K,” “black,” “power steering,” and “power brake.” Then SA3 = {“$30K,” “black,” “power steering,” “power brake”}. Suppose the single-valued attributes (terms) “BMW,” “automatic,” “sunroof,” “leather interior,” and “250 hp” appear only in two of the top three objects in the reranked collection. Then SA2 = {“BMW,” “automatic,” “sunroof,” “leather interior,” “250 hp”}. Let NAi be the number of single-valued attributes (terms) in the set SAi. Using each set SAi, with NAi single-valued attributes (terms), we can create NAi ∗ NAi − 1/2 cross-product terms. 4.8.4. Heuristic: “Add and Drop Cross-Product Terms.” We used the following heuristic to add and drop cross-product terms in step (5) of the algorithm of §2.4: (1) Create the sets SAi, i = 1 NC, of singlevalued attributes (terms) that occur in exactly i objects of the top NC objects in the reranked collection; drop sets SAi with less than two single-valued attributes; (2) Set i = NC, count = 0; (3) Initialize counters: j = 1, k = 2; (4) Create a new cross-product term from the jth and kth single-valued attributes (single terms) in the set SAi. If this cross-product term already exists, then go to (5). Otherwise, increase count: count ← count + 1. If count = TC, go to (6); else go to (5). (5) Increase k* k ← k + 1. If k ≤ NAi, go to step (4); else increase j* j ← j + 1. If j < NAi, set k = j + 1 and go to step (4); else decrease i* i ← i − 1. If i ≥ 1, go to step (3); otherwise, go to (6). (6) Solve the LP problem of (8) with all the accumulated preference statements and the new crossproduct terms to get new weights wi for the singlevalued attributes and the cross-product terms. (7) Drop cross-product terms whose weights are less than the maximum of the weights of the

225 single-valued attributes (terms) in those cross-product terms. We next present an example of how cross-product terms are dropped in step (7) above. Suppose “black BMW” is the cross-product term and its weight in the LP solution is 0.5. In addition, suppose that the weights of the single-valued attributes “BMW” and “black” are 0.4 and 0.7, respectively. Because the maximum of the weights of “BMW” and “black” is 0.7 and it is greater than the weight (0.5) of the crossproduct term “black BMW,” the cross-product term “black BMW” is dropped. In other words, we only keep cross-product terms that have high value to the user. In our tests, we set TC = M/2, where M is the total number of single-valued attributes, and NC = 3. Note that a variety of other heuristics can be designed to account for interaction effects in multiplicative value functions. 4.9. Discussion of Computational Results We tested the interactive search algorithm with random collections, random value functions, random starting objects, and different types of preference feedbacks. The test results, presented in Tables 3–10, show that the interactive search procedure works and can find the “most preferred” object or alternative in a collection in a reasonable number of iterations and with a reasonable amount of user feedback compared to traditional decision analysis methods. Although there is a good chance that the procedure might get stalled for high, medium, and low type of preference feedback and not find the “most preferred” alternative, this did not occur in our tests. However, convergence to the “most preferred” alternative is guaranteed for the other two feedback types, “A preferred to B” and “best alternative so far.” Convergence is also guaranteed when all three different feedback types are used in combination to avoid any stalling. The results also show that the high, medium, and low type of preference feedback converges slightly faster than the other two feedback types. This is because many more preference constraints can be created with high, medium, and low type preference feedback than with the other two types and there were only 100 “highly preferred” objects in the collection of 10,000 objects. In addition, the results show that the average number of preference comparisons (statements) required

226 of the user by this search procedure is much lower than that required by standard decision analysis methods. Column 6 in Tables 3–5 shows the ratio of MQ in column 5 and the average number of preference comparisons in column 3. Column 7 in Tables 3–5 shows the ratio of MQ in column 5 and the maximum number of preference comparisons in column 3. As the tables show, these ratios generally increase with problem size, as given by the number of attributes. Tables 3–5 show that for a problem with 40 ∗ 40 unique attributes and 40 ∗ 5 common attributes, the minimum number MQ of preference comparisons required by a traditional decision analysis method is 1,718, which is at least 8 times more than the average number of preference comparisons required by this search method (see column 6) and at least two times more than the maximum number of preference comparisons required (see column 7). That indicates that this search procedure is very effective in guiding the user to the right preference questions and in using that information to get a good approximation of the user’s value function quickly, which then is used to find the “most preferred” alternative. Human fatigue in answering preference questions is an issue in interactive processes (Takagi 2001, Korhonen et al. 1990). The comparison of our search method results with decision analysis methods indicates that users would have substantially less fatigue with our method when they do searches in a single session. Simulations that used a linear value function for the surrogate user are presented in Tables 3–5, and those that used a multiplicative value function are found in Tables 6–8. When the surrogate user used the multiplicative value function, we ran the simulation in two ways. In the first case, those results are shown in the column labeled “W/O CProd,” the search method used a linear approximation to the value function. That is, no cross-product terms were used in the LP of (8). In the second case, those results are shown in the column labeled “With CProd,” the search method used the heuristic of §4.8.4 above to add cross-product terms to (8) and thereby tried to capture the interaction effects present in the multiplicative value function. Tables 6–8 show that a linear approximation to the multiplicative value function works and converges to the “most preferred” alternative, although a bit slower



than the case where interaction effects are accounted for with cross-product terms. 4.9.1. Changing User Preference. Table 9 shows computational results where the surrogate user randomly changes the value function about halfway through the search. We used a linear value function in these simulations and randomly changed the weights of the single-valued attributes in the value function, but the “most preferred” object—although a different one now—was still in the same category of objects that the user was searching for. Although the search method can handle a major shift in preference of the user by dropping older preference constraints in (8), in these simulations, we avoided the following kind of irrational shift in preference. That is, we avoided a situation, for example, where a potential car buyer goes to a used car dealer looking for a Lexus or BMW, but after seeing some of them, changes his preference to a Ford Escort or a Yugo. Column 3 in Table 9 shows the average number of iterations for these search problems as reported in Table 4 for preference statement type “A preferred to B.” Column 4 shows at what iteration the surrogate value function was actually changed for these “changing user preference” simulation runs. In Table 9, the column labeled “W/O Change” shows results when the value function of the surrogate user did not change. The column labeled “W/Change” shows results when the surrogate user randomly changed the value function at the iteration number in column 4. In general, these results show that changing preferences can be handled by the search method, although the shift in preference causes it to take longer to converge at the “most preferred” alternative. 4.9.2. New Attributes Added to the Value Function During Search. Table 10 shows computational results where the surrogate user adds new singlevalued attributes to the value function about halfway through the search. We used a linear value function in these simulations and added 40% more common single-valued attributes about halfway through the search. These new attributes were then added to the user’s value function and assigned weights in the range of 5–8. However, as in the case of changing preference simulations discussed above, the “most preferred” object, although a different one now, was still


227


in the same category of objects that the user was searching for. Thus, again, we avoided an irrational shift in preference as before. Column 3 in Table 10 shows the average number of iterations for these search problems as reported in Table 4 for preference statement type “A preferred to B.” Column 4 shows at what iteration new attributes were added to the surrogate value function for these simulation runs. In Table 10, the column labeled “W/O New Attributes” shows results when no new attributes were added to the problem. The column labeled “W/New Attributes” shows results when 40% more common single-valued attributes were added at the iteration number in column 4 and random weights, in the range of 5–8, were assigned to those new attributes in the surrogate value function. In general, these results show that the search method can handle the addition of new attributes, although it takes longer to converge to the “most preferred” alternative. In a way, the addition of new attributes is very similar to the changing preference case previously discussed. 4.10.

Computational Complexity of the Search Algorithm Computational complexity is related to problem size and is a measure of the amount of computation required to solve a problem as a function of the problem size. Generally an algorithm is considered to be good if the computation time is a linear or polynomial function of the problem size and bad if the computation time increases exponentially with problem size. Problem size in our case is determined by the number of attributes and the number of values per attribute. In other words, the total number of singlevalued attributes M determines the problem size. The total number of single-valued attributes M essentially determines the weight space of the value function. As shown in Tables 3–10, the problem size in our tests ranged from 225 LP variables (M = 225) to 1,800 LP variables (M = 1 800), without counting the crossproduct terms. Thus, in our tests, the problem size was increased almost ninefold. The two indirect measures of computation time in our case are (1) the total number of iterations to find the “most preferred” alternative and (2) the total number of preference questions asked to find the “most

preferred” alternative. Our test results show that these two measures increase less than linearly with problem size. Thus, although we do not have a theoretical estimate for the computational complexity of our algorithm, these test results suggest that computation time is not growing enormously as the problem size increases. Additionally, neither the number of iterations to find the “most preferred” alternative nor the total number of preference questions asked, which determines the number of constraints in the LP, is an exponential function of problem size. Thus, these empirical results indicate that this is a low-complexity algorithm.

5.

Conclusion

This paper presents an interactive search procedure that allows the user to specify the kind of objects he or she is looking for in a large collection. We focus on user-guided interactive search with the user’s guidance in terms of preference for objects, given their descriptions and features. Search in general is a growing problem in the Internet era and with terabytes of data in large corporate databases. There is a substantial need for search procedures to take user preferences into account. The method proposed here could open the door to widespread use of decision analysis techniques in our everyday life. This search procedure can be used in a wide variety of Google-like search situations on the Internet. It can also be used to search for documents in corporate, legal, and medical databases. The type of user feedback–based interactive search proposed has not been used in these Internet or database search domains to our knowledge. The proposed approach is more effective than currently available search tools that are primarily based on key words (key word–based searches). The reason for that is as follows. Key word–based searches are notoriously complicated because it is often difficult to specify the exact set of key words needed to retrieve the documents (objects) of interest. For example, for a set of key words like “Craig Kirkwood,” Google retrieves thousands of Web pages. Currently, the only way to refine that search is to add more key words. This is exactly what our interactive search procedure does automatically from the user feedback, thus relieving the user of that burden. In other words, to refine

228 the search, our interactive procedure does not have to ask the user for additional key words; it generates them internally from the user feedback. For Internet searches, for example, once the user points out documents that are preferred and those that are not using preference statements, our interactive procedure finds a set of preferred (positive) and not preferred (negative) key words and also determines the weights on them. Thus, for Internet searches, preference feedback at the document level quickly identifies the positive and negative key words (attributes) to the system. This effectively transfers the job of finding additional key words to the search system itself and removes that burden from the user. This makes the search more effective and efficient. The idea of user-guided search has been applied in the information retrieval community for more than 30 years (Rocchio 1971, Salton and Buckley 1990, Vinay et al. 2005, Shen and Zhai 2005). Traditional ad hoc methods adjust weights on key words. In our preference-function–based approach, we give the weight determination approach a sound theoretical basis. Additionally, our method uses a more comprehensive set of user interactions (A preferred to B, “best alternative so far,” and “high, medium, and low” type preferences) than that used in traditional information retrieval. Information retrieval– relevant feedback methods allow only one type of feedback: documents are either “relevant” or “irrelevant.” The traditional methods of multicriteria decision making and decision analysis are not well equipped to handle the search problem described in this paper. Whereas mathematical programming–based multicriteria decision-making methods cannot generally deal with large sets of discrete valued attributes, the decision analysis methods ask preference questions at the attribute level (e.g., which color do you like better, red or green?) in order to construct the preference or value function of the decision maker. In our problem scenario, there can be many discrete attributes, and it would be practically impossible to ask the decisionmaker preference questions at the attribute level. For example, for Web page searches on the Internet, the list of words (the attribute list in this case) can easily be in the hundreds.



The method presented is quite general and can be considered for use in many standard deterministic decision analysis applications. Moreover, the alternative or object-level preference questions required in our procedure should be less burdensome to the decision maker compared with traditional approaches.4 Acknowledgments

The authors thank Craig W. Kirkwood of Arizona State University for useful comments. The third author was a visiting professor at Arizona State University during the spring semester 2006. He wishes to acknowledge the hospitality of Arizona State University and thanks the Foundation for Economic Education (Finland) for financial support.

References Corner, J. L., P. D. Corner. 1995. Characteristics of decisions in decision analysis practice. J. Oper. Res. Soc. 46(3) 304–314. Corner, J. L., C. W. Kirkwood. 1991. Decision analysis applications in the operations research literature, 1970–1989. Oper. Res. 39(2) 206–219. Edwards, W. 1977. How to use multiattribute utility measurement for social decision making. IEEE Trans. Systems, Man Cybernetics SMC-7, 326–340. Gardiner, L. R., R. E. Steuer. 1994. Unified interactive multiple objective programming. Eur. J. Oper. Res. 74(3) 391–406. Geoffrion, A. M., J. S. Dyer, A. Feinberg. 1972. An interactive approach for multicriterion optimization, with an application to the operation of an academic department. Management Sci. 19(4) 357–368. Keeney, R. L., H. Raiffa. 1976. Decisions with Multiple Objectives* Preferences and Value Tradeoffs. Wiley, New York. Kirkwood, C. W. 1997. Strategic Decision Making* Multiobjective Decision Analysis with Spreadsheets. Duxbury Press, Belmont, CA. Kirkwood, C. W., R. K. Sarin. 1980. Preference conditions for multiattribute value functions. Oper. Res. 28(1) 225–232. Köksalan, M. M., P. N. S. Sagala. 1995. Interactive approaches for discrete alternative multiple criteria decision making with monotone utility functions. Management Sci. 41(7) 1158–1171. Korhonen, P. 1988. A visual reference direction approach to solving discrete multiple criteria problems. Eur. J. Oper. Res. 34(2) 152–159. Korhonen, P., J. Laakso. 1986. A visual interactive method for solving the multiple criteria problem. Eur. J. Oper. Res. 24(2) 277–287. Korhonen, P., H. Moskowitz, J. Wallenius. 1990. Choice behavior in interactive multiple criteria decision making. Ann. Oper. Res. 23 161–179. Maddulapalli, A. K., S. Azarm, A. Boyars. 2007. Sensitivity analysis for product design selection with an implicit value function. Eur. J. Oper. Res. 180(3) 1245–1259. 4 U.S. and international patents pending on this interactive search method.


Miettinen, K. 2004. Nonlinear Multiobjective Optimization. Kluwer, Boston. Rocchio, Jr., J. J. 1971. Relevance feedback in information retrieval. G. Salton, ed. The SMART Retrieval System* Experiments in Automatic Document Processing. Prentice-Hall, Englewood Cliffs, NJ, 313–323. Roy, A., J. Wallenius. 1991. Nonlinear and unconstrained multipleobjective optimization: Algorithm, computation and application. Naval Res. Logist. 38 623–635. Roy, A., J. Wallenius. 1992. Nonlinear multiple objective optimization: An algorithm and some theory. Math. Programming 55 235–249. Salton, G., C. Buckley. 1990. Improving retrieval performance by relevance feedback. J. Amer. Soc. Inform. Sci. 41 288–297. Shen, X., C. Zhai. 2005. Active feedback in ad hoc information retrieval. Proc. 28th Annual Internat. ACM SIGIR Conf. Res. Development Inform. Retrieval. ACM Press, New York. Shin, W. S., A. Ravindran. 1991. Interactive multiple objective optimization, survey I—Continuous case. Comput. Oper. Res. 18(1) 97–114.

229

Steuer, R. 1977. An interactive multiple objective linear programming procedure. TIMS Stud. Management Sci. 6 225–239. Stillwell, W. G., D. A. Seaver, W. Edwards. 1981. A comparison of weight approximation techniques in multiattribute utility decision making. Organ. Behav. Human Performance 28 62–77. Takagi, H. 2001. Interactive evolutionary computation: Fusion of the capabilities of EC optimization and human evaluation. Proc. IEEE 89(9) 1275–1296. Vinay, V., K. Wood, N. Milic-Frayling, I. Cox. 2005. Comparing relevance feedback algorithms for web search. Special Interest Tracks and Posters of the 14th Internat. Conf. World Wide Web. ACM Press, New York. Zionts, S. 1981. A multiple criteria method for choosing among discrete alternatives. Eur. J. Oper. Res. 8 143–147. Zionts, S., J. Wallenius. 1976. An interactive programming method for solving the multiple criteria problem. Management Sci. 22(6) 652–663. Zionts, S., J. Wallenius. 1983. An interactive MOLP method for a class of underlying nonlinear utility functions. Management Sci. 29(5) 519–529.

An Interactive Search Method Based on User Preferences - INFORMS ...

An Interactive Search Method Based on User Preferences - INFORMS ...

Suggest Documents

An Approach based on user preferences for Selecting SaaS Product

An Approach based on user preferences for Selecting SaaS Product

Personalizing Search Based on User Search Histories

Personalizing Search Based on User Search Histories

Personalized Search Based on User Search Histories

Query Personalization based on User Preferences

An Interactive Electronic Art System Based on ... - User Web Pages

Dynamic User Task Composition Based on User Preferences

an interactive agent-based system for concept-based web search

An effective attack method based on information exposed by search ...

Process Planning Based on User Preferences - Solid Freeform ...

An Interactive Web-based Visualization Tool in Action: User Testing ...

an educational interface based on interactive ...

an educational interface based on interactive

An Ontology-Based Interactive Tool to Search ... - Stanford University

A Concept for an Interactive Search-Based Software Testing System

Practitioner-Oriented Visualization in an Interactive Search-Based ...

A Concept for an Interactive Search-Based ... - Semantic Scholar

User-Driven Topic Modeling Based on Interactive ... - chandan reddy

User-Driven Topic Modeling Based on Interactive ... - chandan reddy

Relevant Term Suggestion in Interactive Web Search Based on ...

interactive multiobjective tabu/scatter search based on reference point ...

MindFinder: interactive sketch-based image search on ... - BCMI Lab

Mining User Contextual Preferences