System and method for budgeted generalization search in hierarchies

Abstract

An improved system and method is provided for searching a collection of objects that may be located in hierarchies of auxiliary information for retrieval of response objects. A framework to perform a generalization search in hierarchies may be used to generalize a search by moving up to a higher level in a hierarchy of taxonomies or to specialize a search by moving down to a lower level in the hierarchy of taxonomies. Once the system may decide to enumerate response objects at a particular level of generalization, a budgeted generalization search may be used for enumerating a set of response objects within a budgeted cost.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram generally representing a computer system into which the present invention may be incorporated;

FIG. 2 is a block diagram generally representing an exemplary architecture of system components in an embodiment for searching a collection of objects that may each have textual content and that may each be furthermore located in hierarchies of auxiliary information for retrieving a list of response objects, in accordance with an aspect of the present invention;

FIG. 3 is an illustration depicting a generalization path within a taxonomy in the embodiment of a weighted tree, in accordance with an aspect of the present invention;

FIG. 4 is a flowchart generally representing the steps undertaken in one embodiment for performing a generalization search in hierarchies, in accordance with an aspect of the present invention;

FIG. 5 is an illustration depicting in an embodiment a space of possible multi-dimensional generalizations for the generalization paths of FIG. 3, in accordance with an aspect of the present invention;

FIG. 6 is a flowchart generally representing the steps undertaken in one embodiment for determining a level of generalization within a hierarchy of taxonomies for searching for a ranked list of documents when performing a generalization search, in accordance with an aspect of the present invention;

FIG. 7 is a flowchart generally representing the steps undertaken in one embodiment for enumerating a ranked list of documents at a level of generalization using a budgeted generalization search, in accordance with an aspect of the present invention; and

FIG. 8 is an illustration depicting in an embodiment a set of rectangles that may cover an area within a hierarchy of taxonomies bounded by the locations specified for a query, in accordance with an aspect of the present invention.

DETAILED DESCRIPTION

Exemplary Operating Environment

FIG. 1 illustrates suitable components in an exemplary embodiment of a general purpose computing system. The exemplary embodiment is only one example of suitable components and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the configuration of components be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in the exemplary embodiment of a computer system. The invention may be operational with numerous other general purpose or special purpose computing system environments or configurations.

The invention may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, and so forth, which perform particular tasks or implement particular abstract data types. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in local and/or remote computer storage media including memory storage devices.

With reference to FIG. 1, an exemplary system for implementing the invention may include a general purpose computer system 100. Components of the computer system 100 may include, but are not limited to, a CPU or central processing unit 102, a system memory 104, and a system bus 120 that couples various system components including the system memory 104 to the processing unit 102. The system bus 120 may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus.

The computer system 100 may include a variety of computer-readable media. Computer-readable media can be any available media that can be accessed by the computer system 100 and includes both volatile and nonvolatile media. For example, computer-readable media may include volatile and nonvolatile computer storage media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by the computer system 100. Communication media may include computer-readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. For instance, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media.

The system memory 104 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 106 and random access memory (RAM) 110. A basic input/output system 108 (BIOS), containing the basic routines that help to transfer information between elements within computer system 100, such as during start-up, is typically stored in ROM 106. Additionally, RAM 110 may contain operating system 112, application programs 114, other executable code 116 and program data 118. RAM 110 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by CPU 102.

The computer system 100 may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only, FIG. 1 illustrates a hard disk drive 122 that reads from or writes to non-removable, nonvolatile magnetic media, and storage device 134 that may be an optical disk drive or a magnetic disk drive that reads from or writes to a removable, a nonvolatile storage medium 144 such as an optical disk or magnetic disk. Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the exemplary computer system 100 include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive 122 and the storage device 134 may be typically connected to the system bus 120 through an interface such as storage interface 124.

The drives and their associated computer storage media, discussed above and illustrated in FIG. 1, provide storage of computer-readable instructions, executable code, data structures, program modules and other data for the computer system 100. In FIG. 1, for example, hard disk drive 122 is illustrated as storing operating system 112, application programs 114, other executable code 116 and program data 118. A user may enter commands and information into the computer system 100 through an input device 140 such as a keyboard and pointing device, commonly referred to as mouse, trackball or touch pad tablet, electronic digitizer, or a microphone. Other input devices may include a joystick, game pad, satellite dish, scanner, and so forth. These and other input devices are often connected to CPU 102 through an input interface 130 that is coupled to the system bus, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB). A display 138 or other type of video device may also be connected to the system bus 120 via an interface, such as a video interface 128. In addition, an output device 142, such as speakers or a printer, may be connected to the system bus 120 through an output interface 132 or the like computers.

The computer system 100 may operate in a networked environment using a network 136 to one or more remote computers, such as a remote computer 146. The remote computer 146 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer system 100. The network 136 depicted in FIG. 1 may include a local area network (LAN), a wide area network (WAN), or other type of network. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet. In a networked environment, executable code and application programs may be stored in the remote computer. By way of example, and not limitation, FIG. 1 illustrates remote executable code 148 as residing on remote computer 146. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.

Generalization Search in Hierarchies

The present invention is generally directed towards a system and method for querying a set of objects that may each include textual content and that may also be located within several independent taxonomies of auxiliary information such as geographic location, topic, and so forth. A query may consist of a traditional textual query augmented with a requested location in zero or more of the taxonomies. A candidate result document may be rewarded for matching the textual query, and for matching a requested taxonomy location as closely as possible. The query answer may consist of a ranked list of documents in descending order of a score function which captures document quality, textual match, and taxonomy match.

The generalization search driver may guide a search for an appropriate level of generalization within a hierarchy of taxonomies using various techniques. As will be seen, the techniques described may adjust the degree of generalization dynamically based upon the response objects seen so far. Once the system may decide to enumerate response objects at a particular level of generalization, a budgeted generalization search may be used in an embodiment for enumerating the set of response objects within a budgeted cost. As will be understood, the various block diagrams, flow charts and scenarios described herein are only examples, and there are many other scenarios to which the present invention will apply.

Turning to FIG. 2 of the drawings, there is shown a block diagram generally representing an exemplary architecture of system components in an embodiment for searching a collection of objects that may each have textual content and that may each be furthermore located in hierarchies of auxiliary information for retrieving a list of response objects. Those skilled in the art will appreciate that the functionality implemented within the blocks illustrated in the diagram may be implemented as separate components or the functionality of several or all of the blocks may be implemented within a single component. For example, the functionality for the budgeted search analysis engine 226 may be included in the same component as the generalization search driver 216. Or the functionality of the search analysis engine 224 may be implemented as a separate component from the generalization search driver 216. Moreover, those skilled in the art will appreciate that the functionality implemented within the blocks illustrated in the diagram may be executed on a single computer or distributed across a plurality of computers for execution.

In various embodiments, a client computer 202 may be operably coupled to one or more servers 210 by a network 208. The client computer 202 may be a computer such as computer system 100 of FIG. 1. The network 208 may be any type of network such as a local area network (LAN), a wide area network (WAN), or other type of network. A web browser 204 may execute on the client computer 202 and may include functionality for receiving a query request from a user and displaying result objects obtained as search results from query processing. The web browser 204 may be operably coupled to a client query handler 206 The client query handler 206 may include functionality for receiving a query request from the web browser and for sending the query request to a server to obtain search results. The web browser 204 and the client query handler 206 may be any type of interpreted or executable software code such as a kernel component, an application program, a script, a linked library, an object with methods, and so forth.

The server 210 may be any type of computer system or computing device such as computer system 100 of FIG. 1. In general, the server 210 may provide query processing services for obtaining search results for query requests. The server 210 may include a server query handler 212 for receiving and responding to query requests for obtaining result objects. The server 210 may also include a query processor 214 for providing services for querying a set of objects that may each include textual content and that may also be located within several independent taxonomies of auxiliary information such as geographic location, topic, and so forth. The query processor 214 may be operably coupled to a generalization search driver 216 for directing a search through levels of a hierarchy of taxonomies to find response objects matching keywords of a query and matching locations in the taxonomies, a search analysis engine 224 for determining a ranked list of response objects matching keywords of a query and matching locations in a hierarchy of taxonomies, and a budgeted search analysis engine 226 for finding response objects matching keywords of a query and matching locations in a hierarchy of taxonomies within a budgeted cost.

The generalization search driver 216 may guide a search for an appropriate level of generalization within a hierarchy of taxonomies using various techniques. Accordingly, the generalization search driver 216 may include a top-down search driver 218, a bottom-up search driver 220, and a binary search driver 222. The top-down search driver 218 may begin processing at the top-most level of the hierarchy of taxonomies and search downward through the levels of the hierarchy of taxonomies. The bottom-up search driver 220 may begin processing at the bottom-most level of the hierarchy of taxonomies and search upward through the levels of the hierarchy of taxonomies. And the binary search driver 222 may begin processing at a middle level of the hierarchy of taxonomies and may either move up or down the levels of the hierarchy of taxonomies, as in a usual binary search. Those skilled in the art will appreciate the any one of these search drivers may be used for determining a level of generalization within a hierarchy of taxonomies for searching for response objects when performing a generalization search.

The budgeted search analysis engine 226 may find response objects within a budgeted cost at a given level of generalization within a hierarchy of taxonomies. The budgeted search analysis engine 226 may include a cover set analysis engine 228 for determining sets of points covering an area within a hierarchy of the taxonomies bounded by locations of the taxonomies. The cover set analysis engine 228 may, in turn, include a cost cover set analysis engine 230 for determining an optimal cost cover set for an area of a hierarchy of two taxonomies bounded by locations of the taxonomies. And the cover set analysis engine 228 may also include a weighted cover set analysis engine 232 for determining a weighted cover set for an area of the hierarchy of taxonomies bounded by locations of the taxonomies.

Each of the drivers and engines included in the server 210 may be any type of executable software code such as a kernel component, an application program, a linked library, an object with methods, or other type of executable software code. The server 210 may be operably coupled additionally to a database of objects such as object store 234 that may include any type of objects 236 that may have textual content and that may also be located within several independent taxonomies of auxiliary information, such as geographic location, topic, and so forth.

There may be a variety of applications in which a set of candidate response objects, such as documents, may be placed into multiple taxonomies. In some applications, a user may enter a query, and the system may search the multiple taxonomies and return response objects that may best match the query. Consider an example in which there may be a corpus of various documents that may be homepages of stores, and assume that there may be two taxonomies for this corpus: T₁ may be a taxonomy on locations and T₂ may be a taxonomy on store types. Several stores may each have a location that corresponds to a node in T₁ and a store type that corresponds to a node in T₂. Focusing for now on the hierarchical aspects of a query, consider that a user, who may be interested in finding a pizza place on University Avenue in Palo Alto, Calif., enters a textual query of “pizza places on University Avenue in Palo Alto Calif” in a web browser. Such a query may be represented as a pair of leaf nodes, one from each taxonomy: <l₁,l₂>, in which l₁ may be a node of T₁ corresponding to University Ave, and l₂ may be a node of T₂ corresponding to pizza places. If there may be sufficient pizza places on University Avenue, the query may be trivially computed. However, as may be the case, there may be no results that exactly match the query, and it may be necessary to generalize in one or both dimensions in order to find a matching pizza place.

For each taxonomy, the options for generalizing may be determined by tracing a path from the queried node l_j to the root of the taxonomy. For example, FIG. 3 presents an illustration depicting a generalization path within a taxonomy in the embodiment of a weighted tree. More particularly, FIG. 3 illustrates two generalization paths 302 and the cost of each generalization for taxonomy tree T₁ 304 and taxonomy tree T₂ 306. Notice that generalizing from pizza places to Italian restaurants for taxonomy tree T₂ may be fairly inexpensive, while generalizing from restaurants to other types of stores may be very expensive. A reasonable generalization therefore may allow other types of restaurants, but may not be likely to return a document about a chandlery. As this example may illustrate, generalizing from pizza places to Italian restaurants should cost 1, while generalizing to other types of restaurants should cost 4. Accordingly, the appropriate measure of generalization cost may be the distance from the query node to the least common ancestor (LCA) of the query node and the document. For instance, a proposed response of a Greek restaurant in Palo Alto would incur a cost of 2 for taxonomy tree T₁ to generalize from University Ave to Palo Alto, and a cost of 4 for taxonomy tree T₂ to generalize from a pizza place to an arbitrary restaurant. The overall generalization cost would therefore be 6.

FIG. 4 presents a flowchart generally representing the steps undertaken in one embodiment for performing a generalization search in hierarchies. At step 402, a set of documents may be indexed and may be placed within locations of taxonomies of auxiliary information. More formally, consider D to be a corpus of documents and a taxonomy to be represented as a tree whose edges have non-negative weights. The notation t∈T may be used to denote that a node t belongs to the taxonomy tree T and use T|_t to denote the subtree of T rooted at node t. Consider root(T) to denote the root of T, wdepth(T) to denote the maximum weighted path length in T, and depth(T) to denote the maximum unweighted path length. For a taxonomy T, consider that each document d∈D may be associated with at most one node T, denoted d^T∈T. For t∈T, docs(t) may be used to denote the set of documents that may be associated with some node in the subtree T|_t; this definition may capture the generalization aspect of taxonomies. Consider T₁, . . . ,T_m to be the given taxonomies and consider d_j^T∈T_j to denote the node in the j-th taxonomy associated with document d.

After the set of documents have been placed into multiple taxonomies, a document may appear at zero or more nodes of each taxonomy. At step 404, a textual query and a set of requested locations within the taxonomies may be received. For example, a user-entered query may have two components: a text component and a set of taxonomy nodes. More formally, a query Q may consist of text keywords Q^k and a vector of taxonomy nodes Q^T=<Q₁^T, . . . ,Q_m^T>, where Q_j^T∈T_j. In various embodiments, each query may have a node associated with every taxonomy. If a taxonomy may not contain all documents of a corpus, the taxonomy may be extended by adding a new root node with two children: the original root, and a new child called ‘other’. Additionally, a parameter k specifying the number of desired results may also be included in the query in an embodiment.

In response to receiving a textual query and a set of requested locations within the taxonomies, the system may determine what level of generalization within the space of possible generalizations may be appropriate for searching for a list of documents at step 406. In an embodiment, the search may be directed to be more generalized by increasing the level of generalization or the search may be directed to be more specialized by decreasing the level of generalization. Upon determining a level of generalization, a ranked list of documents may be determined at step 408 from the set of documents that match the textual query and the locations in the taxonomies. In an embodiment, the answer to a query may be a list of the top k results, ranked in decreasing order according to the following scoring function:

score(d, Q)=static(d)+text(d, Q^k)+tax(d, Q^T), where static(d) may return a static score for document d, text(d, Q^k) may return a text score for document d with respect to keywords Q^k, and tax(d, Q^T) may returns a taxonomy score that may be a generalization cost for document d with respect to taxonomy nodes Q^T.

In an embodiment, the static score may be defined as static(d) ∈ [0, U_s], where U_s may be an upper bound on the static score of any document. In this case, a lower static score may indicate a better match for a document. The text score may be defined in an embodiment for general text matching as text(d, Q^k) ∈ [0, U_t], where U_t may be an upper bound on the text score of any document for any query. Or, in an embodiment for boolean text matching, the text score may be defined as text(d, Q^k) ∈ {0,∞}, where 0 may correspond to match and ∞ may correspond to no match. Finally, the taxonomy score may be defined in an embodiment to be

$\mathrm{tax}\left(d,Q^T\right)=\sum _{j=1}^m\mathrm{tax}\left(d,Q_j^T\right),$

where tax_j(d, Q_j^T) gives the generalization cost for document d with respect to the taxonomy node as:

tax_j(d, Q^T_j)=d_Tj(Q_T^j,lca(d^T_j,Q^T_j)), where d^T_j may be the tree distance in taxonomy j, based on the weights on the edges of the tree T_j.

In another embodiment, the taxonomy score may be defined as a symmetric function of a query node and a document node. In this embodiment, the taxonomy score may be a symmetric taxonomy cost defined as tax_j′(d, Q^T_j)=φ_j(lca(d^T_j,Q^T_j). The weights may be chosen such tax_j′(d, Q^T_j)=tax_j(d, Q^T_j)+f(Q^T_j), for some function f(•). Thus, the two measures may differ in this embodiment by an additive factor that may be independent of the result object, so that the top result objects under the two measures may be identical. To achieve this property, the weights may be assigned such that the weight of node t may be φ_j(t)=wdepth(T_j)−d_Tj(t, root(T_j).

After a ranked list of documents may be determined from the set of documents that match the textual query and the locations in the taxonomies, the ranked list of documents may be output at step 410 and processing may be finished for performing a generalization search in hierarchies.

In order to provide a ranked list of documents according to the scoring function score(d,Q), the system may first determine what level of generalization within the space of possible generalizations may be appropriate for searching for a ranked list of documents. For example, FIG. 5 presents an illustration depicting in an embodiment a space of possible multi-dimensional generalizations for the generalization paths presented in FIG. 3. The possible generalizations in T₁ may be placed on the x-axis and the possible generalizations in T₂ may be placed on the y-axis of a Cartesian plane 502 as illustrated in FIG. 5. For each axis, a tick mark may be placed at all points for which a generalization exists. A grid point (x,y) for which both coordinates lie at a tick mark may represent a possible node in the product taxonomy, and the generalization cost of this node may be the sum of its coordinate, x +y. For instance, the top right tick mark may correspond to the node (Bay Area, Store), and its generalization cost may be 20.

More formally, notice that for document d and query q=<l₁, . . . ,l_m>, the taxonomy score may be represented as tax_j(d,l_j)=d_T(l_j,lca(d,l_j)), which depends on the least common ancestor of d and q. A node that may be a least common ancestor may be defined to be an ancestor of q, and for any such ancestor, the value of tax_j may be simply the distance from q to this ancestor. Thus, possible generalization costs may be the distances from q to an ancestor, and such a framework may match the cost measure illustrated in FIG. 3. The overall space of possible generalizations in zero or more taxonomies may thus be a Cartesian product of the possible generalization in each dimension, which may be just the set of ancestors of q in each dimension. Hence, the overall space of possible generalizations can be modeled as an m-dimensional grid, where each grid point (t₁, . . . ,t_m) may be such that t_j ∈ T_j. Each grid point may therefore be an element of the product taxonomy T₁ x . . . x T_m, and in fact, t_j may be on the path from q_j to root (T_j).

Furthermore, a grid point (t₁, . . . , t_m) may implicitly correspond to a subset of documents given by the intersection of the taxonomy nodes at each point; for example, all objects that may have both geography Palo Alto and restaurant type Italian. More formally, this may be defined as:

docs(t₁, . . . ,t_m)=∩_j=1^m docs(t_j). The generalization cost of this grid point with respect to the taxonomy nodes (Q₁^T, . . . Q_m^T) of the query Q may then be defined as:

$\mathrm{tax}\left(t_1,\dots ,t_m,Q\right)=\sum _{j=1}^md_{T_j}\left(t_j,Q_j^T\right).$

It may therefore be natural to locate (t₁, . . . ,t_m) in R^m at coordinates (d_T1(t₁, Q₁^T), . . . ,d_Tm(t_m, Q_m^T)). The generalization cost of this point may then be exactly its L₁ norm, the sum of its coordinates. This may be the embedding shown in FIG. 5 for the possible generalizations of the two taxonomies.

Moreover, consider the continuum of generalization costs in the interval I=[0,tax(root(T₁), . . . ,root(T_m),Q)]. Each point b∈I may correspond to a simplex S(b) in the m-dimensional grid such that:

S(b)={(t₁, . . . , t_m)|tax(t₁, . . . , t_m, Q≦b}, so that S(b) may include all points in the grid that may have a generalization cost at most b. Thus, all the documents present in the nodes defined by the simplex S(b) may be defined by the expression, docs(S(b))=∪_{(t1, . . . ,tm)∈S(b)}docs (t₁, . . . ,t_m) Turning again to FIG. 5, the set of all nodes in the grid with a generalization cost less than 10 may be the set of all nodes that satisfy x+y<10. In this representation, all points that can be represented with a particular upper bound on generalization cost may always be expressed as a simplex (which in two dimensions may be a triangle) whose diagonal edge may have the same slope. If the generalization cost may be given by the function tax(•), the slope may be −1. If instead it becomes valuable to place more weight on generalizations in T₁ rather than T₂ in an embodiment, then lines of any negative slope may be admitted. FIG. 5 also shows the simplex for cost≦4 which may be S(4)={(Univ Ave, Pizza), (Palo Alto, Pizza), (Univ Ave, Italian), (Palo Alto, Italian), (Univ Ave, Restaurant)}.

Notice that even though b∈I may be a continuous quantity, b∈I may have a discrete behavior because of the discrete nature of path lengths in the trees. By precomputation, an ordered list of values B=b₁, . . . ,b_L may be identified, with b_j∈I such that for any b′∈ [b_j,b_i+1) , S(b′)=S(b_j). As used herein, the notation of level j may denote b_j. The total number of levels may then be defined as:

L≦m•max_j=1^m depth(T_j). The notion of generalization and specialization have natural interpretations in the language of levels: generalization, as used herein, may mean to increase the level; and specialization, as used herein, may mean to decrease the level. In reference to FIG. 5 for example, the level corresponding to cost≦10 may be a generalization of the level corresponding to cost≦4, and the level corresponding to cost≦4 may be a specialization of the level corresponding to cost≦10.

Thus, for two grid points g=(t₁, . . . ,t_m) and g′=(t₁′, . . . ,t_m′), their least common ancestor may be defined to be lca(g,g′)=(lca(t₁,t₁′), . . . , lca(t_m,t_m′)), that is, the coordinate-wise least common ancestors in the corresponding trees. This notion may be extended to a subset G of grid points whereby lca(G) may denote their least common ancestor. In FIG. 5 for example, lca(S(4))=(Palo Alto, Restaurant) and lca(S(10))=(Store, Bay Area)). Note that by definition, docs (S(b))⊂ docs(lca(S(b) ). As a result, focus on documents in docs(S(b))may be restricted at a particular level by treating lca(S(b)) as a “query”. For example, in reference to FIG. 5, to access documents in docs(S(4)), the query would be “Palo Alto AND Restaurants.”

FIG. 6 presents a flowchart generally representing the steps undertaken in one embodiment for determining a level of generalization within a hierarchy of taxonomies for searching for a ranked list of documents when performing a generalization search. More particularly, this process may find the minimal generalization cost b* such that Idocs(S(b*))|≧k. At step 602, the level in the hierarchy of taxonomies may be initialized. In an embodiment, the level may be set at the bottom-most level, the top-most level, or at the middle level L/2. At step 606, documents may be found at the current level in the hierarchy of taxonomies that match keywords of the query. The documents at the current level l may be accessed by using the query lca(S(b_l)) on a conventional inverted index that may have been built over the documents previously.

At step 608, the documents found at the current level in the hierarchy of taxonomies may be scored. In an embodiment, each document may be scored using the function score(d,Q). At step 610, it may be determined whether to generalize the search for matching documents. In an embodiment, if all the documents found at this level may be scored before a threshold of k results may be obtained, then it may be determined to generalize further. And this may correspond to going one level up in the list B.

If it may be determined to generalize further at step 610, then processing may continue at step 604 where the next level in the hierarchy may be determined and then documents may be found at step 608. Otherwise, it may be determined whether to specialize the search for matching documents at step 612. In an embodiment, if there may be more than a threshold of k results obtained from scoring documents found at this level, then it may be determined to specialize further. And this may correspond to going down a level in the list B. If it may be determined to specialize further, then processing may continue at step 604 where the next level in the hierarchy may be determined. Otherwise, processing may be finished for determining a level of generalization within a hierarchy of taxonomies for searching for a ranked list of documents when performing a generalization search.

The following pseudocode may provide an implementation of the process described above for determining a level of generalization within the hierarchy of taxonomies for searching for a ranked list of documents:

initialLevel (L)
levelDone = false
while |R| < k     levelDone)
l = getNextLevel (l,levelDone)
if (l < 0   l > L − 1) break
levelDone = false
while (|R| < k   ∃d ∈ R, tax(d,Q) > bl)
levelDone
levelDone = processNextDoc (Q,R,bl).

This pseudocode may search for the minimal level l* such that |docs(S(b_l*))|≧k. Consider L to denote the maximum level and l denote the current level. Also consider R to be the current set of results. The function processNextDoc (Q,R,b_l) may take the current generalization cost be and returns a set of documents R by scanning through the documents at level l. The function processNextDoc (Q,R,b_l) may issue the query lca(S(b_l)) to the index. If it may finish scanning all the documents in docs(S(b_l)) and |R|<k, then it may set the flag levelDone to true, indicating the need to generalize and proceed bottom-up. If |R| gets larger than k and all the documents in R have generalization cost at most b_l, then it sets levelDone to false and returns in order to indicate that specialization proceeding top-down may be possible without compromising the desired number of results.

There may two factors in this embodiment that may control the processing of the query when determining a minimum level of generalization within a hierarchy of taxonomies for searching for a ranked list of documents. The first may be the level at which the processing may begin, given by the function initialLevel (•). The second may be how to go from one level to another, given by the function getNextLevel (oldLevel, levelDone), where oldLevel may be the current level and levelDone may be a boolean flag that indicates whether scanning all the documents at the current level has completed. There may be three basic choices to realize these functions: bottom-up search, top-down search and binary search.

In an embodiment that may use a bottom-up search, processing may begin at the bottom-most level. If there may be at least k documents in the current level l, then processing may be done. Otherwise, there may be a need to generalize and this corresponds to going one level up to l+1. In this case, the querying process may need to be restarted, issuing a new query to the index that corresponds to lca(S(b_l+1)). The bottom-up search may perform well if there may be enough documents corresponding to the taxonomy nodes of the query. For example, if the taxonomy nodes of the query may be (Univ. Ave, Pizza) and if there may be more than k documents in (Palo Alto, Pizza), then the bottom-up algorithm can be expected to perform very well.

In another embodiment that may use a top-down search, processing may begin at the top-most level corresponding to level L. If there may be at most k documents at the current level l, processing may be done since specializing further will not help. Otherwise, it may be possible to specialize and still obtain k documents, but with a lower score given by the function score(d,Q). If so, then there may be a need to move down to level l−1. However, unlike in the bottom-up case, the results R that have been computed so far do not need to be abandoned. A postfiltering may be applied to R to realize the specialization corresponding to setting R=R ∩ docs(S(b_l)). An important benefit may be that the cursors in the index that were used to realize the query lca(S(b_l)) need not be discarded and may be re-used in realizing the query lca(S(b_l−1)). The top-down search, therefore, would perform extremely well if generalization may be an efficient way to obtain k documents. In our example in FIG. 5, this would correspond to the case to continue to generalize until (South Bay, Restaurants) to obtain k results.

By using the levelDone flag in the pseudocode discussed above for providing an implementation of the process for determining a level of generalization, a single implementation of the getNextLevel (•) function may be provided for both the bottom-up and top-down search using the following pseudocode:

getNextLevel (oldLevel, levelDone)
if (levelDone) return oldLevel + 1
else return oldLevel − 1.

In yet another embodiment that may use a binary search, processing may begin at the middle level corresponding to level L/2. Depending on whether there may be enough documents at the current level l, there may be a need to either move up or down the levels, as in a normal binary search. The binary search may be expected to quickly adjust to find the level of generalization. Pseudocode to implement the functions initialLevel (•) and getNextLevel(•) in this case would be as follow:

initialLevel (L)
low = 0
high = L − 1
getNextLevel (oldLevel, levelDone)
if (levelDone) low = oldLevel + 1
else high = oldLevel − 1
newLevel = (low + high)/2
if (newLevel = oldLevel) return allDone
else return newLevel.

Any one of these three choices may be used for determining a level of generalization within a hierarchy of taxonomies for searching for a ranked list of documents when performing a generalization search.

Once the system may decide to enumerate documents at a particular level of generalization, a budget may be provided in an alternate embodiment for enumerating the set of documents. As previously presented, a set of documents in docs(S(b)) may be enumerated by issuing a single query g to the index, where g is the m-dimensional grid point, such that g=lca(S(b)). Alternately, it may be more efficient to issue multiple queries h₁, . . . ,h_m to the index so that there may still remain docs(S(b)) ⊂ U_i≧1docs(h_i) but the cost of executing the queries h₁, . . . ,h_m may be less than the cost of executing the query g. This may advantageously be applicable when considering specialization as in the top-down search method.

For example, consider a simple scenario in which taxonomies T₁ and T₂ are unweighted. In this case, each generalization step may add one to the overall generalization cost. For a given query, consider the two-dimensional grid formed by the paths Q₁^T to root(T₁) and Q₂^T to root(T₂). Also consider setting the generalization cost b=1 for accessing the documents in docs(S(1)). Further consider lca(docs(S(1))=g=(g₁, g₂), child(g₁) to be defined as the child of g₁ in T₁ along the path from root(T₁) to Q₁^T, and child(g₂) to be defined as the child of g₂ in T₂ along the path from root(T₂) to Q₂^T. There may be two possible evaluation plans to compute docs(S(1)) in this instance: a single query for g=(g₁, g₂) may be submitted or two distinct queries may be submitted: {(g₁, child(g₂)), (child(g₁), g₂)}. Note that this latter plan may be equivalent to querying for “(g₁ AND child(g₂)) OR (child(g₁) AND g₂).” The cost of these two plans may be quite different. The first plan may produce unnecessary elements of (docs(g₁) \ docs(child(g₁))) \ (docs(g₂) \ docs(child(g₂))); these elements may be unnecessary since they may have a generalization cost of 2 whereas the generalization cost was fixed at b=1. The second plan may produce each element of docs(child(g₁))\docs(child(g₂)) twice. Deciding which plan to choose may depend on which type of unnecessary work may be least expensive.

For larger values of b, it may become less obvious what the possible query plans may be. It may be desirable to seek plans that may be minimal in the sense that no query may be specialized without losing potentially valid response documents, and it may be possible to construct situations for which any minimal plan may be fine. Thus, in general, there may be a large number of candidate query plans to consider.

More concretely, consider looking for documents in reference to FIG. 5 where the generalization cost may be set to b=4. There may be several query plans for finding documents in docs(S(4)). For the query plan (Palo Alto, Restaurants), the documents in (Palo Alto, Restaurants) \ (Palo Alto, Italian) may have cost more than 4 and hence may be unnecessary. A possible second query plan may be (Univ. Ave, Restaurant) OR (Palo Alto, Italian), where the documents corresponding to (Univ. Ave, Italian) may be repeated twice. Suppose that there may be no Italian restaurants in Palo Alto, which may be indicated in FIG. 5 by the fact the corresponding grid point may have zero documents. In this case, a valid third query plan may be (Univ. Ave, Restaurant) OR (South Bay, Pizza).

FIG. 7 presents a flowchart generally representing the steps undertaken in one embodiment for enumerating a ranked list of documents at a level of generalization using a budgeted generalization search. At step 702, a textual query and a set of requested locations within a hierarchy of taxonomies may be received. In response to receiving a textual query and a set of requested locations within a hierarchy of taxonomies, sets of points covering an area within the hierarchy of the taxonomies bounded by the set of requested locations may be determined at step 704. For example, a query (x,y) may represent the textual query that may return the set of documents docs(x,y). If x′≦x and y′≦y, then docs(x′,y′) ⊂ docs (x,y). A rectangle whose corners may be {(x,y), (x, 0), (0, y), (0, 0)} may be determined to indicate the set of queries that are subsumed by the query (x,y). To generate possible objects within a particular budget, a set of rectangles which cover the simplex may be selected. FIG. 8 may provide an illustration in an embodiment depicting a set of rectangles that may cover an area within a hierarchy of taxonomies bounded by the locations specified for a query. In particular, FIG. 8 presents an illustration depicting in an embodiment a set of rectangles, {Q1,Q2,Q3}, covering a space of possible multi-dimensional generalizations represented in a Cartesian plane 802 for the generalization paths presented in FIG. 3.

In another embodiment where there may be more than two taxonomies, it may be possible to obtain a simple approximation algorithm by treating the budgeted multi-taxonomy search as an instance of finding a weighted set cover for an m-dimensional grid of points. In general, each point in the grid may be considered to “cover” all the points “below” it. More precisely, the point g=(g₁, . . . ,g_m) whose weight may be C(g) may be defined to cover all the points g′=(g₁′, . . . ,g_m′) where each g_i′≦g_i.

A budgeted cost cover of the area may be determined at step 706. Assume the cost may be known for each possible query, each query may be annotated with the cost C(x,y) of performing the query (x,y). In an embodiment where there may be two taxonomies, a minimal-cost cover may be determined using a simple dynamic program. For a fixed simplex S(b), consider (x, S(b,x)) to denote at point at which x may intersect a diagonal face of the simplex, and consider B(x₀) to denote the cost of the minimal-cost cover of those points of the simplex with x≧x₀. Then the cost of the minimal-cost cover may be define as

$B\left(x_0\right)=\underset{x\ge x_o}{\min }C\left(x,S\left(b,x\right)\right)+B\left(\mathrm{next}\left(x\right)\right)$

where next(x) may denote the first x-axis tick mark strictly greater than x. This dynamic program may be iteratively solved until reaching a final solution of B(0) and may require time proportional to the number of points in the simplex to iteratively solve this dynamic program.

In another embodiment where there may be more than two taxonomies, the solution for finding a minimal weight set cover to cover all the points in S(b) may be approximated using standard greedy algorithm to within factor O(log|S(b)|). Since the problem may have a geometric structure, it may be possible to apply other approximation algorithms known to those skilled in the art.

After determining a budgeted cost cover, a list of response objects located within the budgeted cost cover may be output at step 710. In an embodiment, the list of response objects output may be ranked by scoring each response object as described in reference to step 408 of FIG. 4 above and may be sent to a web browser for display to a user. After outputting the list of response objects, processing may be finished for performing a budgeted generalization search in hierarchies.

Thus the present invention may efficiently enumerate a ranked list of documents at a level of generalization using a budgeted generalization search The system and method may apply broadly to any domains which are amenable to multifaceted search and navigation, including product and local search. Moreover, the system and method may be applied to online advertising for matching users' queries in a particular context to potential advertisements. Users, queries, and advertisements may each be viewed as sitting within a number of taxonomies. Users for example may be characterized based on locations and interests; queries may be classified into topical taxonomies; and advertisements may be assigned market segments, and potentially placed into other taxonomies either automatically or by the advertiser. Those skilled in the art will appreciate that any domains including objects having textual content may be queried for response objects using the framework described.

As can be seen from the foregoing detailed description, the present invention provides an improved system and method for searching a collection of objects having textual content and being furthermore located in hierarchies of auxiliary information for retrieval of response objects. The system and method may guide a search for an appropriate level of generalization within a hierarchy of taxonomies using the various techniques described. Advantageously, these techniques may adjust the degree of generalization dynamically based upon the response objects seen during the search. Upon deciding to enumerate response objects at a particular level of generalization, a budgeted generalization search may be used in an embodiment for enumerating the set of response objects within a budgeted cost. Such a framework for query processing may flexibly provide sufficiently relevant response objects. As a result, the system and method provide significant advantages and benefits needed in contemporary computing and in online applications.

While the invention is susceptible to various modifications and alternative constructions, certain illustrated embodiments thereof are shown in the drawings and have been described above in detail. It should be understood, however, that there is no intention to limit the invention to the specific forms disclosed, but on the contrary, the intention is to cover all modifications, alternative constructions, and equivalents falling within the spirit and scope of the invention.

Claims

1. A computer system for searching a collection of objects having textual content, comprising: a query processor for providing services for querying the collection of objects having textual content, a plurality of the objects being associated with one or more locations in a plurality of taxonomies;a budgeted search analysis engine operably coupled to the query processor for finding response objects matching one or more keywords of the query and matching the one or more locations in the plurality of taxonomies within a budgeted cost; anda cover set analysis engine operably coupled to the budgeted search analysis engine for determining sets of points covering an area within a hierarchy of the plurality of taxonomies bounded by the one or more locations.

2. The system of claim 1 further comprising a cost cover set analysis engine operably coupled to the cover set analysis engine for determining an optimal cost cover set for the area of the hierarchy of the plurality of taxonomies bounded by the one or more locations.

3. The system of claim 1 further comprising a weighted set cover analysis engine operably coupled to the cover set analysis engine for determining a weighted cover set for the area of the hierarchy of the plurality of taxonomies bounded by the one or more locations.

4. The system of claim 1 further comprising a generalization search driver for directing the search through levels of the hierarchy of the plurality of taxonomies to find response objects matching the one or more keywords of the query and matching the one or more locations in the taxonomies.

5. A computer-readable medium having computer-executable components comprising the system of claim 1.

6. A computer-implemented method for searching a collection of objects having textual content, comprising: receiving a query and one or more locations within a plurality of taxonomies, the one or more locations having at least one associated response object;determining sets of points covering an area within a hierarchy of the plurality of taxonomies bounded by the one or more locations;finding a set of points having a total cost no greater than a budgeted cost within the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations; andoutputting a list of response objects associated with the one or more locations within the set of points having the total cost no greater than the budgeted cost.

7. The method of claim 6 further comprising determining an area within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

8. The method of claim 6 further comprising ranking the list of response objects associated with the one or more locations within the set of points having the total cost no greater than the budgeted cost.

9. The method of claim 8 wherein ranking the list of response objects associated with the one or more locations within the set of points having the cost no greater than the budgeted cost comprises scoring the response objects using a text score for matching the one or more keywords of the query and using a generalization cost for matching the one or more locations within the set of points.

10. The method of claim 6 wherein determining the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises determining a set of rectangles covering a simplex within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

11. The method of claim 10 wherein finding a set of points having a total cost no greater than a budgeted cost within the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises applying dynamic programming to iteratively determine a minimal-cost cover for the set of rectangles covering the simplex within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

12. The method of claim 6 wherein determining the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises determining a weighted set cover for a multi-dimensional grid of points within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

13. The method of claim 12 wherein determining the weighted set cover for the multi-dimensional grid of points within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises assigning a weight representing a cost to one or more points in the multi-dimensional grid.

14. The method of claim 13 wherein finding the set of points having the total cost no greater than the budgeted cost within the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises applying a greedy algorithm to adaptively determine a minimal weight set cover for the multi-dimensional grid of points within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

15. A computer-readable medium having computer-executable instructions for performing the method of claim 6.

16. A computer system for searching a collection of objects having textual content, comprising: means for receiving a query and one or more locations within a plurality of taxonomies, the one or more locations having at least one associated response object;means for finding a set of points having a total cost no greater than a budgeted cost within sets of points covering an area within a hierarchy of the plurality of taxonomies bounded by the one or more locations; andmeans for outputting a list of response objects associated with the one or more locations within the set of points having the total cost no greater than the budgeted cost.

17. The computer system of claim 16 further comprising means for determining the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

18. The computer system of claim 16 wherein means for finding the set of points having the total cost no greater than the budgeted cost within the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises means for applying dynamic programming to iteratively determine a minimal-cost cover for a set of rectangles covering a simplex within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

19. The computer system of claim 16 wherein means for finding the set of points having the total cost no greater than the budgeted cost within the sets of points covering the area within the hierarchy of the plurality of taxonomies bounded by the one or more locations comprises means for applying a greedy algorithm to determine a minimal weight set cover for a multi-dimensional grid of points within the hierarchy of the plurality of taxonomies bounded by the one or more locations.

20. The computer system of claim 16 further comprising means for ranking the list of response objects associated with the one or more locations within the set of points having the total cost no greater than the budgeted cost.