Abstract:
A method, system and computer program product for measuring a relevance and diversity of a ranking list to a given query. The ranking list is comprised of a set of data items responsive to the query. In one embodiment, the method comprises calculating a measured relevance of the set of data items to the query using a defined relevance measuring procedure, and determining a measured diversity value for the ranking list using a defined diversity measuring procedure. The measured relevance and the measured diversity value are combined to obtain a measure of the combined relevance and diversity of the ranking list. The measured relevance of the set of data items may be based on the individual relevance of each of the data items to the query, and the diversity value may be based on the similarities of the data items to each other.

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
       [0001]    This application is related to application no. (attorney Docket YOR920110481US1), filed herewith, for “Finding a Top-K Diversified Ranking List on Graphs”, the disclosure of which is hereby incorporated by reference in its entirety. 
     
    
     STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH AGREEMENT 
       [0002]    This invention was made with Government support under Contract No.: W911NF-09-2-0053 (Army Research Office (ARO)). The Government has certain rights in this invention. 
     
    
     BACKGROUND OF THE INVENTION 
       [0003]    The present invention generally relates to ranking data items, and more specifically, to measuring the goodness of a set of data items based on both the relevance and the diversity of those data items. 
         [0004]    It is now widely recognized that diversity is a highly desired property in many data mining tasks, such as expertise and legal search, recommendation systems, blog filtering, document summarization, and others. It is a powerful tool to address the uncertainty and ambiguity and/or to cover the different aspects of an information need. Diversity is also positively associated with personnel performances and job retention rates in a large organization. 
         [0005]    Diversified ranking on graphs is a fundamental mining task and has a variety of high-impact applications. Two important questions remain open in diversified ranking on large graphs. The first challenge is the measure—for a given top-k ranking list, how can we quantify its goodness? Intuitively, a good top-k ranking list should capture both the relevance and the diversity. For example, given a task which typically requires a set of different skills, if we want to form a team of experts, not only should the people in the team have relevant skills, but also they should somehow be ‘different’ from each other so that the whole team can benefit from the diversified, complementary knowledge and social capital. However, there does not exist such a goodness measure for the graph data in the literature. Most of the existing works for diversified ranking on graphs are based on some heuristics. One exception is described in a paper by Mei, et al. (Q. Mei, J. Guo, and D. R. Radev. Divrank: the interplay of prestige and diversity in information networks. In KDD, pages 1009-1018, 2010.) In this paper, the authors made an important step towards this goal by providing some optimization explanations, which is achieved by defining a time-varying objective function at each iteration. But still, it is not clear what overall objective function the algorithm tries to optimize. 
         [0006]    The second challenge lies in the algorithmic aspect—how can we find an optimal, or near-optimal, top-k ranking list that maximizes the goodness measure? Bringing diversity into the design objective implies that we need to optimize on the set level. In other words, the objective function for a subset of nodes is usually not equal to the sum of objective functions of each individual node. It is usually very hard to perform such set-level optimization. For instance, a straight-forward method would need exponential enumerations to find the exact optimal solution, which is infeasible even for medium size graphs. This, together with the fact that real graphs are often of large size, reaching billions of nodes and edges, poses the challenge for the optimization algorithm—how can we find a near-optimal solution in a scalable way? 
         [0007]    In the recent years, set-level optimization has been playing a very important role in many data mining tasks. Many set-level optimization problems are NP-hard. Therefore, it is difficult, if not impossible, to find the global optimal solutions. However, if the function is monotonic sub-modular with 0 function value for the empty set a greedy strategy can lead to a provably near-optimal solution. This powerful strategy has been recurring in many different settings, e.g., immunization, outbreak detection, blog filtering, sensor placement, influence maximization and structure learning. 
       BRIEF SUMMARY 
       [0008]    Embodiments of the invention provide a method, system and computer program product for measuring a relevance and diversity of a ranking list to a given query. The ranking list is comprised of a set of data items responsive to the given query; and, in one embodiment, the method comprises calculating a measured relevance of the set of data items to the query using a defined relevance measuring procedure, and determining a measured diversity value for the ranking list using a defined diversity measuring procedure. The measured relevance and the measured diversity value are combined, in accordance with a defined combining procedure, to obtain a measure of the combined relevance and diversity of the ranking list. In an embodiment, at least one of the calculating the measured relevance, determining the measured diversity, and combining the measured relevance and the measured diversity are carried out by a computer device. 
         [0009]    In an embodiment, the measured relevance of the set of data items is determined by calculating an individual relevance of each of the data items in the set of data items, and combining the calculated individual relevance of the data items in the set of data items. 
         [0010]    In one embodiment, the individual relevance of the data items are summed to obtain the relevance of the set of data items. 
         [0011]    In an embodiment, the measure of the combined relevance and diversity value is obtained by summing a weighted multiple of the measured relevance and the measured diversity value. 
         [0012]    In one embodiment, the measured diversity value is obtained by calculating a similarity value representing the similarity of the data items in the data set. 
         [0013]    In an embodiment, this similarity value may be obtained by using a graph to represent the set of data items responsive to the query. This graph has a multitude of nodes, and each of the data items is represented by a respective one of the nodes of the graph. Some of the nodes are connected to others of the nodes. A similarity value is calculated for each pair of connected nodes, and the similarity values for these node pairs are used to determine the similarity value representing the similarity of the data items of the set of data items. 
         [0014]    In one embodiment, the similarity values calculated for the connected node pairs are aggregated to determine the measured diversity value of the set of data items. 
         [0015]    In an embodiment, the negative of the measured diversity value is added to a weighted multiple of the measured relevance to determine the combined relevance and diversity of the ranking list. 
         [0016]    Embodiments of the invention provide a goodness measure which intuitively captures both (a) the relevance between each individual node in the ranking list, and (b) the diversity among different nodes in the ranking list. 
     
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
         [0017]      FIG. 1(   a ) illustrates an algorithm used in an embodiment of the invention. 
           [0018]      FIG. 1(   b ) shows the operation of the algorithm of  FIG. 1(   a ). 
           [0019]      FIG. 2  illustrates a fictitious co-authorship network with each node representing an author and the edge weights representing the number of co-authorized papers. 
           [0020]      FIGS. 3(   a ) and  3 ( b ) show data items grouped in order to achieve a balance between diversity and relevance, using two different measures of diversity. 
           [0021]      FIG. 4(   a ) shows scores for diversity and relevance for a number of data sets, plotted vs. the sizes of the data sets, where those data sets are obtained from a particular co-authorship network using four different methods. 
           [0022]      FIG. 4(   b ), similar to  FIG. 4(   a ), shows scores for diversity and relevance for a number of data sets, plotted vs. the sizes of the data sets, where those data sets are obtained from a second co-authorship network using four different methods. 
           [0023]      FIG. 4(   c ) shows scores for diversity and relevance for a number of data sets, plotted vs. the sizes of the data sets, where those data sets are obtained from a third co-authorship network using four different methods. 
           [0024]      FIG. 4(   d ) shows scores for diversity and relevance for a number of data sets, plotted vs. the sizes of the data sets, where those data sets are obtained from a fourth co-authorship network using four different methods. 
           [0025]      FIG. 5  illustrates how various ranking procedures balance between an optimization quality and speed. 
           [0026]      FIG. 6(   a ) compares the quality of and the amount of time taken by several ranking procedures. 
           [0027]      FIG. 6(   b ) compares the amount of time taken by several ranking procedures. 
           [0028]      FIGS. 7(   a ) and  7 ( b ) illustrate the scalability of an algorithm used in an embodiment of the invention;  FIG. 7(   a ) shows the scalability of the algorithm with respect to the number of nodes in the graph, with the number of edges fixed; and  FIG. 7(   b ) shows the scalability of the algorithm with the number of nodes fixed. 
           [0029]      FIG. 8  shows a computing environment that may be used to implement embodiments of the invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0030]    As will be appreciated by one skilled in the art, embodiments of the present invention may be embodied as a system, method or computer program product. Accordingly, embodiments of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, embodiments of the present invention may take the form of a computer program product embodied in any tangible medium of expression having computer usable program code embodied in the medium. 
         [0031]    Any combination of one or more computer usable or computer readable medium(s) may be utilized. The computer-usable or computer-readable medium may be, for example but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, device, or propagation medium. More specific examples (a non-exhaustive list) of the computer-readable medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CDROM), an optical storage device, a transmission media such as those supporting the Internet or an intranet, or a magnetic storage device. Note that the computer-usable or computer-readable medium could even be paper or another suitable medium, upon which the program is printed, as the program can be electronically captured, via, for instance, optical scanning of the paper or other medium, then compiled, interpreted, or otherwise processed in a suitable manner, if necessary, and then stored in a computer memory. In the context of this document, a computer-usable or computer-readable medium may be any medium that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device. The computer-usable medium may include a propagated data signal with the computer-usable program code embodied therewith, either in baseband or as part of a carrier wave. The computer usable program code may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc. 
         [0032]    Computer program code for carrying out operations of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). 
         [0033]    The present invention is described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer program instructions may also be stored in a computer-readable medium that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable medium produce an article of manufacture including instruction means which implement the function/act specified in the flowchart and/or block diagram block or blocks. 
         [0034]    The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. 
         [0035]    The present invention relates to measuring the goodness of a set of data items based on both the relevance and the diversity of those data items. In embodiments of the invention, these data items are selected based on a graph of a larger set of data items, and embodiments of the invention provide a scalable algorithm (linear with respect to the size of the graph) that generates a provably near-optimal top-k ranking list. In embodiments of the invention, this algorithm has a clear optimization formulation, finds a provable near-optimal solution, and enjoys the linear scalability. 
         [0036]    Table I lists the main symbols used in this description of the invention. 
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Symbols 
               
             
          
           
               
                   
                 Symbol 
                 Definition and Description 
               
               
                   
                   
               
               
                   
                 A, B, . . . 
                 matrices (bold upper case) 
               
               
                   
                 A(i, j) 
                 the element at the i th  row and j th  column of A 
               
               
                   
                 A(i, :) 
                 the i th  row of matrix A 
               
               
                   
                 A(:, j) 
                 the j th  column of matrix A 
               
               
                   
                 A′ 
                 transpose of matrix A 
               
               
                   
                 a, b, . . . 
                 vectors 
               
               
                   
                 I, J, . . . 
                 sets (calligraphic) 
               
               
                   
                 
                           
                 
                 element-wise Hadamard product 
               
               
                   
                 r 
                 an n × 1 ranking vector 
               
               
                   
                 p 
                 an n × 1 query vector (p(i) ≧ 0, Σ i=1   n  p(i) = 1) 
               
               
                   
                 I 
                 an identity matrix 
               
               
                   
                 1 
                 a vector/matrix with all elements set to 1s 
               
               
                   
                 0 
                 a vector/matrix with all elements set to 0s 
               
               
                   
                 n, m 
                 the number of the nodes and edges in the graph 
               
               
                   
                 k 
                 the budget (i.e., the length of the ranking list) 
               
               
                   
                 c 
                 the damping factor 0 &lt; c &lt; 1 
               
               
                   
                   
               
             
          
         
       
     
         [0037]    In the description below, we consider the most general case of directed, weighted, irreducible unipartite graphs. We represent a general graph by its adjacency matrix. In practice, we store these matrices using an adjacency list representation, since real graphs are often very sparse. We represent a general graph by its adjacency matrix. Following the standard notation, we use bold upper-case for matrices (e.g., A), bold lower-case for vectors (e.g., a), and calligraphic fonts for sets (e.g., I). We denote the transpose with a prime (i.e., A′ is the transpose of A). For a bipartite graph with adjacency matrix W, we can convert it to the equivalent uni-partite graph: 
         [0000]    
       
         
           
             A 
             = 
             
               
                 ( 
                 
                   
                     
                       0 
                     
                     
                       W 
                     
                   
                   
                     
                       W 
                     
                     
                       0 
                     
                   
                 
                 ) 
               
               . 
             
           
         
       
     
         [0000]    We use subscripts to denote the size of matrices/vectors (e.g., A n×n  means a matrix of size n×n). When the sizes of matrices/vectors are clear from the context, we omit such subscripts for brevity. Also, we represent the elements in a matrix using a convention similar to Matlab, e.g., A(i, j) is the element at the i th  row and j th  column of the matrix A, and A(:, j) is the j th  column of A, etc. With this notation, we can represent a sub-matrix of A as A(I, I), which is a block of matrix A that corresponds to the rows/columns of A indexed by the set I. 
         [0038]    In the description below, we focus on personalized PageRank since it is one of the most fundamental ranking methods on graphs, and has shown its success in many different application domains in the past decade. Formally, it can be defined as follows: 
         [0000]        r=cA′r +(1− c ) p   (1)
 
         [0000]    where p is an n×1 personalized vector (p(i)≧0, Σ i=1   n p(i)=1). Sometimes, we also refer to p as the query vector, c(0&lt;c&lt;1) is a damping factor; A is the row-normalized adjacency matrix of the graph (i.e., Σ j=1   n A(i, j)=1(i=1, . . . , n); and r is the n×1 resulting ranking vector. Note that if p(i)=1/n(I=1, . . . , n), it is reduced to the standard PageRank; if p(i)=1 and p(j)=0(j≠i), the resulting ranking vector r gives the proximity scores from node I to all the other nodes in the graph. 
         [0039]    In order to simplify the description of our upcoming method, we also introduce matrix B: 
         [0000]        B=cA ′+(1 −c ) p 1 1×n   (2)
 
         [0000]    where 1 1×n  is a 1×n row vector with all elements set to 1s. Intuitively, the matrix B can be viewed as the personalized adjacency matrix that is biased towards the query vector p. In turns out that the ranking vector r defined in eq. (1) satisfies r=Br. In other words, the ranking vector r is the right eigenvector of the B matrix with the eigenvalue 1. It can be verified that B is a column-wise stochastic matrix (i.e., each column of B sums up to 1). By Perron-Frobenius theorem, it can be shown that 1 is the largest (in module) simple eigenvalue of the matrix B; and the ranking vector r is unique with all non-negative elements since the graph is irreducible. 
         [0040]    Aspects of the invention provide (1) a goodness measure to quantify the quality of a given top-k ranking list that captures both the relevance and the diversity; and (2) given the goodness measure, an optimal or near-optimal or near-optimal algorithm to find a top-k ranking list that maximizes such goodness measure in a scalable way. With the above notations and assumptions, these problems can be formally defined as follows: 
         [0041]    Problem 1. (Goodness Measure.) 
         [0000]    Given: A large graph A n×n , the query vector p, the damping factor c, and a subset of k nodes S;
 
Output: A goodness score f (S) of the subset of nodes S, which measures (a) the relevance of each node in S with respect to the query vector p, and (v) the diversity among all the nodes in the subset S.
 
         [0042]    Problem 2. (Diversified Top-k Ranking Algorithm.) 
         [0000]    Given: A large graph A n×n , the query vector p, the damping factor c, and the budget k;
 
Find: A subset of k nodes S that maximizes the goodness measure f(S).
 
         [0043]    Solutions for these two problems are discussed below. 
       The Goodness Measure 
       [0044]    An aspect of an embodiment of the invention is to define a goodness measure to quantify the quality of a given top-k ranking list that captures both the relevance and the diversity. We first discuss some design objective of such a goodness measure; and then present a solution followed by some theoretical analysis and discussions. 
         [0045]    Design Objectives 
         [0046]    As said before, a good diversified top-k ranking list should balance between the relevance and the diversity. The notion of relevance is clear for personalized PageRank,—larger value in the ranking vector r means more relevant with respect to the query vector p. On the other hand, the notion of diversity is more challenging. Intuitively, a diversified subset of nodes should be dis-similar with each other. Take the query ‘Find the top-k conferences for Dr. Y. from the author-conference network’ as an example. Dr. Y Yu is a professor at a University, and his recent major research interest lies in databases and data mining. He also has broad interests in several related domains, including systems, parallel and distributed processing, web applications, and performance modeling, etc. A top-k ranking list for this query would have high relevance if it consists of all the conferences from databases and data mining community (e.g., SIGMOD, VLDB, KDD, etc.) since all these conferences are closely related to his major research interest. However, such a list has low diversity since these conferences are too similar with each other (e.g., having a large overlap of contributing authors, etc.). Therefore, if we replace a few databases and data mining conferences by some representative conferences in his other research domains (e.g., ICDCS for distributed computing systems, WWW for web applications, etc.), it would make the whole ranking list more diverse (e.g., the conferences in the list are more dis-similar to each other). 
         [0047]    Furthermore, if we go through the ranking list from top down, we would like to see the most relevant conferences appear first in the ranking list. For example, a ranking list in the order of ‘SIGMOd’, ‘ICDCS’, ‘WWW’ is better than ‘ICDCS’, ‘WWW’, ‘SIGMOD’ since databases (SIGMOD) is a more relevant research interest for Dr. Y, compared with distributed computing systems (ICDCS), or web applications (WWW). In this way, the user can capture Dr. Y&#39;s main research interest by just inspecting a few top-ranked conferences/nodes. This suggests the so-called diminishing returns property of the goodness measure—it would help the user to know better about Dr. Y&#39;s whole research interest if we return more conferences/nodes in the ranking list; but the marginal benefit becomes smaller and smaller as we go down the ranking list. 
         [0048]    Another implicit design objective lies in the algorithmic aspect. The proposed goodness measure should also allow us to develop an effective and scalable algorithm to find an optimal (or at least near-optimal) top-k ranking list from large graphs. 
         [0049]    To summarize, for a given top-k ranking list, we aim to provide a single goodness score that (1) measures the relevance between each individual node in the list and the query vector p; (2) measures the similarity (or dis-similarity) among all the nodes in the ranking list; (3) exhibits some diminishing returns property with respect to the size of the ranking list; and (4) enables some effective and scalable algorithm to find an optimal (or near-optimal) top-k ranking list. 
         [0050]    The Measure 
         [0051]    Let A be the row-normalized adjacency matrix of the graph, B be the matrix defined in eq (2), p be the personalized vector and r be the ranking vector. For a given ranking list S (i.e., S gives the indices of the nodes in the ranking list; and |S|=k), a goodness measure in an embodiment of the invention is formally defined as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     f 
                      
                     
                       ( 
                       S 
                       ) 
                     
                   
                   = 
                   
                     
                       2 
                        
                       
                         
                           ∑ 
                           
                             i 
                             ∈ 
                             S 
                           
                         
                          
                         
                             
                         
                          
                         
                           r 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                     - 
                     
                       
                         ∑ 
                         
                           i 
                           , 
                           
                             j 
                             ∈ 
                             S 
                           
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0052]    We can also represent f(S) by using the matrix A instead: 
         [0000]    
       
         
           
             
               f 
                
               
                 ( 
                 S 
                 ) 
               
             
             = 
             
               
                 2 
                  
                 
                   
                     ∑ 
                     
                       i 
                       ∈ 
                       S 
                     
                   
                    
                   
                       
                   
                    
                   
                     r 
                      
                     
                       ( 
                       i 
                       ) 
                     
                   
                 
               
               - 
               
                 c 
                  
                 
                   
                     ∑ 
                     
                       i 
                       , 
                       
                         j 
                         ∈ 
                         S 
                       
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       A 
                        
                       
                         ( 
                         
                           j 
                           , 
                           i 
                         
                         ) 
                       
                     
                      
                     
                       r 
                        
                       
                         ( 
                         j 
                         ) 
                       
                     
                   
                 
               
               - 
               
                 
                   ( 
                   
                     1 
                     - 
                     c 
                   
                   ) 
                 
                  
                 
                   
                     ∑ 
                     
                       j 
                       ∈ 
                       S 
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       r 
                        
                       
                         ( 
                         j 
                         ) 
                       
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           S 
                         
                       
                        
                       
                           
                       
                        
                       
                         p 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0000]    where c is the damping factor in personalized PageRank, and 1 1×|S|  is a row vector of length |S| with all the elements set to 1s. It can be shown that it is equivalent to eq. (3). 
         [0053]    Notice that the goodness measure in eq. (3) is independent of the ordering of the different nodes in the subset S. If we simply change the ordering of the nodes for the same subset S, it does not affect the goodness score. However, as discussed below, we can still output an ordered subset based on the diminishing returns need when the user is seeking a diverse top-k ranking list. 
         [0054]    Proofs and Analysis 
         [0055]    Let us analyze how the proposed goodness measure of eq. (3) meets the design objective discussed above. 
         [0056]    There are two terms in eq. (3), the first term is twice the sum of the ranking scores in the ranking list. For the second term, recall that B can be viewed as the personalized adjacency matrix with respect to the query vector p, where B(i,j) indicates the similarity (i.e., the strength of the connection) between nodes I and j. In other words, the second term in eq. (3) is the sum of all the similarity scores between any two nodes i, j(i,j∈S) in the ranking list (weighted by r(j)). Therefore, the proposed goodness measure captures both the relevance and the diversity. The more relevant (higher r(i)) each individual node is, the higher the goodness measure f(S). At the same time, it encourages the diversity within the ranking list by penalizing the (weighted) similarity between any two nodes in S. 
         [0057]    The measure f(S) of eq. (3) also exhibits the diminishing returns property, which is summarized in Theorem 1 below. The intuitions of Theorem 1 are as follows: (1) by P1, it means that the utility of an empty ranking list is always zero; (2) by P2, if we add more nodes into the ranking list, the overall utility of the ranking list does not decrease; and (3) by P3, the marginal utility of adding new nodes is relatively small if we already have a large ranking list. 
         [0058]    Theorem 1. Diminishing Returns Property of f(S). 
         [0059]    Let Φ be an empty set; I, J, R be three sets s.t., I         J, and R∩J=Φ. The following facts hold for f(S): 
         [0000]    P1: f(Φ)=0;
 
P2: f(S) is monotonically non-decreasing, i.e., f(I)≦f(J);
 
P3: f(S) is sub modular, i.e., f(I∪R)−F(I)≧f(J∪R)−f(J).
 
         [0060]    PROOF of P1. It is obviously held by the definition of f(S). 
         [0061]    PROOF of P2. Let T=J \I. Substituting eq. (3) into f(J)−f(I) and canceling the common terms, we have 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             f 
                              
                             
                               ( 
                                
                               ) 
                             
                           
                           - 
                           
                             f 
                              
                             
                               ( 
                               ℐ 
                               ) 
                             
                           
                         
                         = 
                           
                          
                         
                           
                             2 
                              
                             
                               
                                 ∑ 
                                 
                                   i 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 r 
                                  
                                 
                                   ( 
                                   i 
                                   ) 
                                 
                               
                             
                           
                           - 
                           
                             
                               ∑ 
                               
                                 i 
                                 ∈ 
                                 I 
                               
                             
                              
                             
                                 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   j 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   r 
                                    
                                   
                                     ( 
                                     j 
                                     ) 
                                   
                                 
                               
                             
                           
                           - 
                           
                             
                               ∑ 
                               
                                 i 
                                 ∈ 
                                  
                               
                             
                              
                             
                                 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   j 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   r 
                                    
                                   
                                     ( 
                                     j 
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     ∈ 
                                      
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   r 
                                    
                                   
                                     ( 
                                     j 
                                     ) 
                                   
                                 
                               
                               - 
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     ∈ 
                                      
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ∑ 
                                     
                                       i 
                                       ∈ 
                                       ℐ 
                                     
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     
                                       B 
                                        
                                       
                                         ( 
                                         
                                           i 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                      
                                     
                                       r 
                                        
                                       
                                         ( 
                                         j 
                                         ) 
                                       
                                     
                                   
                                 
                               
                             
                             ) 
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           ( 
                           
                             
                               
                                 ∑ 
                                 
                                   i 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 r 
                                  
                                 
                                   ( 
                                   i 
                                   ) 
                                 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     ∈ 
                                      
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     B 
                                      
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     r 
                                      
                                     
                                       ( 
                                       j 
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0062]    Recall that the matrix B is a column-wise stochastic matrix (i.e., each column of B sums up to 1). The first half of eq. (4) satisfies 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           ( 
                           
                             
                               
                                 ∑ 
                                 
                                   j 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 r 
                                  
                                 
                                   ( 
                                   j 
                                   ) 
                                 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   j 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     ∈ 
                                     ℐ 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     B 
                                      
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     r 
                                      
                                     
                                       ( 
                                       j 
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           ) 
                         
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               j 
                               ∈ 
                                
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               r 
                                
                               
                                 ( 
                                 j 
                                 ) 
                               
                             
                              
                             
                               ( 
                               
                                 1 
                                 - 
                                 
                                   
                                     ∑ 
                                     
                                       i 
                                       ∈ 
                                       ℐ 
                                     
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     B 
                                      
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 j 
                                 ∈ 
                                  
                               
                             
                              
                             
                                 
                             
                              
                             
                               
                                 r 
                                  
                                 
                                   ( 
                                   j 
                                   ) 
                                 
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     ∉ 
                                     ℐ 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                           ≥ 
                           0 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0063]    For the second half of eq. (4), we have that 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           ( 
                           
                             
                               
                                 ∑ 
                                 
                                   i 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 r 
                                  
                                 
                                   ( 
                                   i 
                                   ) 
                                 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   ∈ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     ∈ 
                                      
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     B 
                                      
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     r 
                                      
                                     
                                       ( 
                                       j 
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           ) 
                         
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               i 
                               ∈ 
                                
                             
                           
                            
                           
                               
                           
                            
                           
                             ( 
                             
                               
                                 r 
                                  
                                 
                                   ( 
                                   i 
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     ∈ 
                                      
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     B 
                                      
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     r 
                                      
                                     
                                       ( 
                                       j 
                                       ) 
                                     
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 i 
                                 ∈ 
                                  
                               
                             
                              
                             
                                 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   j 
                                   ∉ 
                                    
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   B 
                                    
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   r 
                                    
                                   
                                     ( 
                                     j 
                                     ) 
                                   
                                 
                               
                             
                           
                           ≥ 
                           0 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0064]    The last equality in eq. (6) is due to the fact that r=Br, and each element is r is non-negative. 
         [0065]    Putting eq. (4)-(6) together, we have that f(J)≧f(I), which completes the proof of P2. 
         [0066]    PROOF of P3. Again, let T=J \I. Substituting eq. (4) into (f(I∪R)−f(I))−(f(J∪r)−f(J)) and canceling the common terms, we have 
         [0000]    
       
         
           
             
               
                 ( 
                 
                   
                     f 
                      
                     
                       ( 
                       
                         ℐ 
                         ⋃ 
                          
                       
                       ) 
                     
                   
                   - 
                   
                     f 
                      
                     
                       ( 
                       ℐ 
                       ) 
                     
                   
                 
                 ) 
               
               - 
               
                 ( 
                 
                   
                     f 
                      
                     
                       ( 
                       
                          
                         ⋃ 
                          
                       
                       ) 
                     
                   
                   - 
                   
                     f 
                      
                     
                       ( 
                        
                       ) 
                     
                   
                 
                 ) 
               
             
             = 
             
               
                 
                   ( 
                   
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ∑ 
                           
                             j 
                             ∈ 
                              
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             B 
                              
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                            
                           
                             r 
                              
                             
                               ( 
                               j 
                               ) 
                             
                           
                         
                       
                     
                     - 
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           ℐ 
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ∑ 
                           
                             j 
                             ∈ 
                              
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             B 
                              
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                            
                           
                             r 
                              
                             
                               ( 
                               j 
                               ) 
                             
                           
                         
                       
                     
                   
                   ) 
                 
                 + 
                 
                   ( 
                   
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ∑ 
                           
                             j 
                             ∈ 
                             
                                
                               ⋃ 
                                
                             
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             B 
                              
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                            
                           
                             r 
                              
                             
                               ( 
                               j 
                               ) 
                             
                           
                         
                       
                     
                     - 
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ∑ 
                           
                             j 
                             ∈ 
                             
                               ℐ 
                               ⋃ 
                                
                             
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             B 
                              
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                            
                           
                             r 
                              
                             
                               ( 
                               j 
                               ) 
                             
                           
                         
                       
                     
                   
                   ) 
                 
               
               = 
               
                 
                   
                     
                       ∑ 
                       
                         j 
                         ∈ 
                          
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                   
                   + 
                   
                     
                       ∑ 
                       
                         i 
                         ∈ 
                          
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           j 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                   
                 
                 ≥ 
                 0 
               
             
           
         
       
     
         [0067]    Therefore, we have that f(I∪R)−f(I)≧f(J∪R)−f(J), which completes the proof of P3. 
         [0068]    Discussion 
         [0069]    In eq. (3), the coefficient ‘2’ balances between the relevance (the first term) and the diversity (the second term). If we change the coefficient ‘2’ to a parameter w, we have the following generalized goodness measure: 
         [0000]    
       
         
           
             
               
                 
                   
                     g 
                      
                     
                       ( 
                       S 
                       ) 
                     
                   
                   = 
                   
                     
                       w 
                        
                       
                         
                           ∑ 
                           
                             i 
                             ∈ 
                             S 
                           
                         
                          
                         
                             
                         
                          
                         
                           r 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                     - 
                     
                       
                         ∑ 
                         
                           i 
                           , 
                           
                             j 
                             ∈ 
                             S 
                           
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0070]    We have the following corollary for this generalized goodness measure. It says that as long as the weight w≧2, the generalized goodness measure g(S) still exhibits the diminishing returns property. This gives our method extra flexibility if the user wants to put more emphasis on relevance for some applications. 
         [0071]    Corollary 2. Generalized Goodness Measure. 
         [0072]    Let Φ be an empty set: I, J, R be three sets s.t. I         J, and R∩J=Φ. For any w≧2, the following facts hold for g(S): 
         [0073]    P1: g(Φ)=0; 
         [0074]    P2: g(S) is monotonically non-decreasing, i.e., g(I)≦g(         ); 
         [0075]    P3: g(S) is submodular, i.e., g(I∪         )−g(I)≧g(         ∪         )−g(         ). 
         [0076]    The Algorithm 
         [0077]    In this section, we address Problem 2. Here, given the initial query vector p and the budget k, we want to find a subset of k nodes that maximizes the goodness measure defined in eq. (3). We would like to point out that although we focus on eq. (3) for the sake of simplicity, the proposed algorithm can be easily generalized to eq. (7) where the user wants to specify the weight w for the relevance. 
         [0078]    Challenges 
         [0079]    Problem 2 is essentially a subset selection problem to find the optimal k nodes that maximize eq. (3). Theorem 1 indicates that it is not easy to find the exact optimal solution of Problem 2—it is NP-hard to maximize a monotonic submodular function if the function value is 0 for an empty set. For instance, a straight-forward method would take exponential enumerations 
         [0000]    
       
         
           
               
             
               ( 
               
                 
                   
                     n 
                   
                 
                 
                   
                     k 
                   
                 
               
               ) 
             
           
         
       
     
         [0000]    to find the exact optimal k nodes, which is not feasible in computation even for a medium size graph (e.g., with a few hundred nodes). 
         [0080]    We can also formulate Problem 2 as a binary indicator vector (x(i)=1 means node i is selected in the subset S, and 0 means it is not selected). Problem 2 can be expressed as the following binary quadratic programming problem: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                     
                     
                       
                         
                           x 
                           ′ 
                         
                          
                         Dx 
                       
                     
                   
                   
                     
                       
                         Subject 
                          
                         
                             
                         
                          
                         to 
                          
                         
                           : 
                         
                       
                     
                     
                       
                         
                           x 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                         ∈ 
                         
                           
                             { 
                             
                               0 
                               , 
                               1 
                             
                             } 
                           
                            
                           
                             ( 
                             
                               
                                 i 
                                 = 
                                 1 
                               
                               , 
                               … 
                                
                               
                                   
                               
                               , 
                               n 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             n 
                           
                            
                           
                               
                           
                            
                           
                             x 
                              
                             
                               ( 
                               i 
                               ) 
                             
                           
                         
                         = 
                         k 
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where D=(B−2I n×n )diag(r), I n×n  is an identity matrix of size n×n, and diag(r) is a diagonal matrix with r(i,i)(i=1, . . . , n) being the diagonal elements. 
         [0081]    The Algorithm 
         [0082]      FIG. 1(   a ) shows an algorithm used in an embodiment of the invention, and  FIG. 1(   b ) illustrates the operation of this algorithm. With reference to  FIG. 1(   a ), in step 1 of the algorithm, we compute the ranking vector r (e.g., by the power method, etc.) Then after some initializations (steps 2-5), we select k nodes one-by-one as follows. At each time, we compute the score vector s in step 7. Then, we select one node with the highest score in the vector s and add it to the subset S (steps 8-9). After that, we use the selected node to update the two reference vectors u and v (steps 10-11). Note that ‘         ’ denotes the element-wise product between two matrices/vectors. Intuitively, the score vector s keeps the marginal contribution of each node for the goodness measure given the current selected subset S. From step 7, it can be seen that at each iteration, the values of such marginal contribution either remain unchanged or decrease. This is consistent with P3 of Theorem 1—as there are more and more nodes in the subset S, the marginal contribution of each node is monotonically non-increasing. It is worth pointing out that we use the original normalized adjacency matrix A, instead of the matrix B in Alg. 1. This is because for many real graphs, the matrix A is often very sparse, whereas the matrix B might not be. To see this, notice that B is a full matrix if p is uniform. In the case B is dense, it is not efficient in either time or space to use B in Alg. 1. 
         [0083]    In Alg. 1, although we try to optimize a goodness measure that is not affected by the ordering of different nodes in the subset, we can still output an ordered list to the user based on the iteration in which these nodes are selected—earlier selected nodes in Alg. 1 are placed at the top of the resulting top-k ranking list. This ordering naturally meets the diminishing returns need when the user is seeking a diverse top-k ranking list as we analyzed above. 
         [0084]    Analysis 
         [0085]    In the discussion below, we analyze the optimality as well as the complexity of Algorithm 1. This discussion shows that this algorithm leads to a near-optimal solution, and at the same time it enjoys linear scalability in both time and space. 
         [0086]    The optimality of Algorithm 1 is given in Lemma 1, below. According to this Lemma, this algorithm is near-optimal—its solution is within a fixed fraction (1−1/e≈0.63) from the global optimal one. Given the hardness of Problem 2, such near—optimality is acceptable in terms of optimization quality. 
         [0087]    Lemma 1. Near-Optimality 
         [0088]    Let S be the subset found by Alg. 1: |S|=k; and S*=argmax |S|=k f(S). We have that f(S)≧(1−1/e)f(S*), where e is the base of the natural logarithm. 
         [0089]    PROOF. Let T be the subset found at the end of the t th  (t=1, . . . , k−1) iteration of Alg. 1. At step 7 of the (t+1) th  iteration, for any node i∉T, we have that 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       u 
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       
                         c 
                          
                         
                           
                             ∑ 
                             
                               x 
                               ∈ 
                                
                             
                           
                            
                           
                               
                           
                            
                           
                             A 
                              
                             
                               ( 
                               
                                 i 
                                 , 
                                 x 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       
                         
                           ( 
                           
                             1 
                             - 
                             c 
                           
                           ) 
                         
                          
                         
                           
                             ∑ 
                             
                               x 
                               ∈ 
                                
                             
                           
                            
                           
                               
                           
                            
                           
                             p 
                              
                             
                               ( 
                               x 
                               ) 
                             
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       v 
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       
                         c 
                          
                         
                           
                             ∑ 
                             
                               y 
                               ∈ 
                                
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               
                                 A 
                                 ′ 
                               
                                
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   y 
                                 
                                 ) 
                               
                             
                              
                             
                               r 
                                
                               
                                 ( 
                                 y 
                                 ) 
                               
                             
                           
                         
                       
                       + 
                       
                         
                           ( 
                           
                             1 
                             - 
                             c 
                           
                           ) 
                         
                          
                         
                           p 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                          
                         
                           
                             ∑ 
                             
                               y 
                               ∈ 
                                
                             
                           
                            
                           
                               
                           
                            
                           
                             r 
                              
                             
                               ( 
                               y 
                               ) 
                             
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       s 
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           s 
                           ^ 
                         
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                       - 
                       
                         
                           u 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                       - 
                       
                         v 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0090]    For any node i∉T, plugging eq. (3) into f(T∪{I})−f(T) and canceling the common terms, we have that 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                        
                       
                         ( 
                         
                            
                           ⋃ 
                           
                             { 
                             i 
                             } 
                           
                         
                         ) 
                       
                     
                     - 
                     
                       f 
                        
                       
                         ( 
                          
                         ) 
                       
                     
                   
                   = 
                   
                     
                       2 
                        
                       
                           
                       
                        
                       
                         r 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                     - 
                     
                       
                         B 
                          
                         
                           ( 
                           
                             i 
                             , 
                             i 
                           
                           ) 
                         
                       
                        
                       
                         r 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                     - 
                     
                       
                         r 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                        
                       
                         
                           ∑ 
                           
                             x 
                             ∈ 
                              
                           
                         
                          
                         
                             
                         
                          
                         
                           B 
                            
                           
                             ( 
                             
                               x 
                               , 
                               i 
                             
                             ) 
                           
                         
                       
                     
                     - 
                     
                       
                         ∑ 
                         
                           y 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               y 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             y 
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0091]    By eq. (2), we can further verify that 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         s 
                         ^ 
                       
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       
                         2 
                          
                         
                             
                         
                          
                         
                           r 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                       - 
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               i 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       u 
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       
                         r 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                        
                       
                         
                           ∑ 
                           
                             x 
                             ∈ 
                              
                           
                         
                          
                         
                             
                         
                          
                         
                           B 
                            
                           
                             ( 
                             
                               x 
                               , 
                               i 
                             
                             ) 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       v 
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           y 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           B 
                            
                           
                             ( 
                             
                               i 
                               , 
                               y 
                             
                             ) 
                           
                         
                          
                         
                           r 
                            
                           
                             ( 
                             y 
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0092]    Therefore, we have that s(i)=f(T∪{i})−f(T). In other words, at step 8 of each iteration of Alg. 1, we always select a node with the highest marginal increase of the goodness measure. By Theorem 1, the goodness measure f(S) is a non-decreasing submodular function with f(Φ)=0. According to A. Krause and C. Guestrin, Beyond convexity—submodularity in machine learning, (In ICML, 2008), we have that f(S)≧(1−1/e)f(S*), which completes the proof. 
         [0093]    Time Complexity. 
         [0094]    The time complexity of the proposed DRAGON is given in Lemma 2. According to Lemma 2, our DRAGON has linear time complexity with respect to the size of the graph. Therefore it is scalable to large graphs in terms of computational time. 
         [0095]    Lemma 2. Time Complexity. 
         [0096]    The time complexity of Alg. 1 is O(m+nk). 
         [0097]    We would like to point out that the Alg. 1 can be further sped up. Firstly, notice that the O(m) term in Lemma 2 comes from computing the ranking vector r (step 1) by the most commonly used power method. There are a lot of fast methods for computing r, either by effective approximation or by parallelism. These methods can be naturally plugged in to Alg. 1, which might lead to further computational savings. Secondly, the O(nk) term in Lemma 2 comes from the greedy selection step in steps 6-12. Thanks to the monotonicity of f(S) as we show in Theorem 1, we can use the similar lazy evaluation strategy as J. Leskovee, A. Krasue, C. Guestrin, C. Faloutsos, J. M. VanBriesen, and N. S. Glace, Cost-effective outbreak detection in networks, (In KDD, pages 420-429, 2007), to speed up this process, without sacrificing the optimization quality. 
         [0098]    Space Complexity. 
         [0099]    The space complexity of Alg. 1 is given in Lemma 3. According to Lemma 3, Alg. 1 has linear space complexity with respect to the size of the graph. Therefore it is also scalable to large graphs in terms of space cost. 
         [0100]    Lemma 3. Space Complexity. 
         [0101]    The space complexity of Alg. 1 is O(m+n+k). 
         [0000]    
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 Comparison of different methods. Alg. 1 is the only method that 
               
               
                 leads to a near-optimal solution with liner scalability. 
               
             
          
           
               
                 Method 
                 Measure 
                 Optimality 
                 Scalability 
                 Convergence 
               
               
                   
               
               
                 ARW [42] 
                 NA 
                 NA 
                 No 
                 Yes 
               
               
                 RRW [27] 
                 Partial 
                 NA 
                 Yes 
                 NA 
               
               
                 DRAGON 
                 Yes 
                 Near-optional 
                 Yes 
                 Yes 
               
               
                   
               
             
          
         
       
     
       Experimental Evaluation 
       [0102]    In the discussion below, we provide empirical evaluations for Algorithm 1. These evaluations mainly focus on (1) the effectiveness and (2) the efficiency of Algorithm 1. 
         [0103]    Experimental Setup 
         [0104]    Data Sets. 
         [0105]    We use the DBLP publication data to construct a co-authorship network, where each node is an author and the edge weight is the number of the co-authored papers between the two corresponding persons. Overall, we have n—418,236 nodes and m=2,753,798 edges. We also construct much smaller co-authorship networks, using the authors from only one conference (e.g., KDD, SIGIR, SIGMOD, etc.). For example, KD is the co-authorship network for the authors in the ‘KDD’ conference. These smaller co-authorship networks typically have a few thousand nodes and up to a few tens of thousands edges. We also construct the co-authorship networks, using the authors from multiple conferences (e.g., KDD-SIGIR). For these graphs, we denote them as Sub(n,m), where n and m are the numbers of nodes and edges in the graph, respectively. 
         [0106]    Parameter Settings. 
         [0107]    There is a damping factor c to compute the personalized PageRank, which is set to be c=0.99. In the discussion herein, we use the power method to compute the PageRank. We adopt the same stopping criteria as [H. Tong, C. Faloutsos, and J.-Y. Pan, Fast random walk with restart and its applications. In ICDM, pages 613-622, 2006]: either the L 1  difference of the ranking vectors between two consecutive iterations is less than a pre-defined threshold (10 −9 ), or the maximum number of iteration steps (80) is reached. There are no additional parameters in Alg. 1. For the remaining parameters of those comparative methods, they are set as in their original papers, respectively. 
         [0108]    Machine Configurations. 
         [0109]    For the computational cost and scalability, we report the wall-clock time. All the experiments ran on the same machine with four 2.5 GHz AMD CPUs and 48 GB memory, running Linux (2.6 kernel). For all the quantitative results, we randomly generate a query vector p and feed it into different methods for a top-k ranking list with the same length. We repeat it 100 times and report the average. 
         [0110]    Evaluation Criteria. 
         [0111]    There does not appear to be any universally accepted measure for diversity. In [Q. Mei, J. Guo, and D. R. Radev, Divrank: the interplay of prestige and diversity in information networks. In KDD, pages 1009-1018, 2010], the authors suggested an intuitive notion based on the density of the induced subgraph from the original graph A by the subset S. The intuition is as follows: the lower the density (i.e., the less 1-step neighbors) of the induced subgraph, the more diverse the subset S. Here, we generalize this notion to the t-step graph in order to also take into account the effect of those in-direct neighbors. Let sign(.) be a binary function operated element-wise on a matrix, i.e., Y=Sign(X), where Y is a matrix of the same size as X, Y (i,j)=1 if X(i,j)&gt;0,Y(i,j)=0 otherwise. We define the t-step connectivity matrix C t  as C t =Sign(Σ i=1   t A i ). That is, C t (i,j)=1 (0) means that node i can (cannot) reach node j on the graph A within t-steps/hops. With this C t  matrix, we define the diversity of a given subset S s eq. (12). Here, the value of Div(t) is always between 0.5 and 1—higher means more diverse. If all the nodes in S are reachable from each other within t-steps, we say that the subset S is the least diverse (Div(t)=0.5). On the other extreme, if all the nodes in S cannot reach each other within t-steps, the subset S is the most diverse (Div(t)−1). 
         [0000]    
       
         
           
             
               
                 
                   
                     Div 
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     1 
                     
                       1 
                       + 
                       
                         
                           ∑ 
                           
                             i 
                             , 
                             
                               j 
                               ∈ 
                               s 
                             
                             , 
                             
                               i 
                               ≠ 
                               j 
                             
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             
                               C 
                               t 
                             
                              
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                           / 
                           
                             ( 
                             
                               
                                  
                                 S 
                                  
                               
                               · 
                               
                                 ( 
                                 
                                   
                                      
                                     S 
                                      
                                   
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
         [0112]    For the task of top-k ranking, the notion of diversity alone, though important, might not be enough for the information need. For example, if we simply randomly select k nodes as the top-k ranking list, these k nodes might not connect with each other at all given that the length of the ranking list k is usually much smaller than the number of nodes n in the graph. Therefore, it has a high diversity. However, it is unlikely that such a ranking list can well fit the user&#39;s information need since each of them might have a very low relevance score. In other words, a diversified top-k ranking list should also have high relevance. That said, we will mainly focus on evaluating how different methods balance between the diversity and the relevance. 
         [0113]    Notice that the relevance score for each individual node is often very small on large graphs (since the L 1  norm of the ranking vector is 1). To make the two quantities (diversity vs. relevance) comparable with each other, we need to normalize the relevance scores. Let Ŝ be the top-k ranking list by the original personalized PageRank, we define the normalized relevance score for a given subset S(|S|=k) s eq. (13). Since the personalized PageRank always gives the k most relevant nodes, the Rel defined in eq. (13) is always between 0 and 1—higher means more relevant. 
         [0000]    
       
         
           
             
               
                 
                   Rel 
                   = 
                   
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           s 
                         
                       
                        
                       
                           
                       
                        
                       
                         r 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           
                             s 
                             ^ 
                           
                         
                       
                        
                       
                           
                       
                        
                       
                         r 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0114]    Effectiveness: Case Studies 
         [0115]    Let us start with an illustrative example to gain some visual intuitions. In  FIG. 2 , we show a fictitious co-authorship network  20 , where each node corresponds to an author (e.g., John, Smith, etc.), and the edge weight is the number of the co-authored papers. There are three communities in this network (e.g., DM, DB and IR). From  FIG. 2 , we can see that node 1 has very strong connections to the DM community. In other words, SM might be his/her major research interest. In addition, s/he also has some connections to the IR and DB communities. Given the budget k=3, personalized PageRank returns all the three nodes (nodes 2, 3 and 5) form DM community which is consistent with the intuition since personalized PageRank solely focuses on the relevance. In contrast, Alg. 1 returns nodes 2, 6 and 10, each of which is still relevant enough to the query node 1. At the same time, they are diversified from each other, covering the whole spectrum of his/her research interest (DM, DB, and IR). 
         [0116]    We also conduct case studies on real graphs. We construct a co-authorship networks from SIGIR (the major conference on information retrieval) and ICML (the major conference on machine learning). We issue a query to find the top-10 co-authors for Prof. YY. The results are shown in Table III. 
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 Top-10 Authors for Prof. YY 
               
             
          
           
               
                   
                 using 
                 Personalized 
               
               
                   
                 algorithm 1 
                 PageRank 
               
               
                   
                   
               
               
                   
                 JZ 
                 JZ 
               
               
                   
                 RJ 
                 BK 
               
               
                   
                 BK 
                 RJ 
               
               
                   
                 J-YN 
                 TP 
               
               
                   
                 W-YM 
                 MR 
               
               
                   
                 TP 
                 TA 
               
               
                   
                 JOP 
                 AGH 
               
               
                   
                 NL 
                 JYN 
               
               
                   
                 JGC 
                 NL 
               
               
                   
                 CXZ 
                 AL 
               
               
                   
                   
               
             
          
         
       
     
         [0117]    We compare it with the original personalized PageRank. YY is a professor, and she has broad interest in information retrieval and machine learning. From  FIG. 2 , we have the following observations. Firstly, both Alg. 1 and personalized PageRank share the same authors for the top-3 returned authors, indicating that Alg. 1 also captures those highly relevant authors with respect to the querying author. Secondly, Alg. 1 returns a more diverse list of authors. For example, although ex 7 is not a co-author of YY, they share a lot of research interest in information retrieval, and have a lot of indirect connections through other IR people. In contrast, the existence of some authors in the ranking list by personalized PageRank is somehow redundant, in terms of helping the user to understand Prof. YY&#39;s whole collaboration network. For example, consider Prof. AGH. Although, he has a lot of co-authored papers with YY, they are also co-authored with RV. Therefore, given that JZ and RJ are already in the ranking list, his existence does not provide much marginal information about YY&#39;s collaboration network. As a quantitative indicator, the average degree of induced subgraph by Alg. 1 is only 2.8, which is much lower (i.e., more diverse) than that by personalized PageRank. Finally, notice that for some authors, although they show up in both lists, their positions in the ranking list are different. For example, JYN shows at the 4 th  and the 8 th  positions in the two ranking lists, respectively. This is because JYN makes the top-4 authors more diverse compared with ThP, although its individual relevance score is lower than the latter. 
         [0118]    Comparison with Alternative Methods for Diversified Ranking on Graphs 
         [0119]    We compare Alg. 1 with ARW and RRW, both of which also aim to improve the diversity of personalized PageRank. We skip the comparison with MMR for brevity since it has been shown that its performance is not as good as RRW for the graph-type data. For RRW, it has two variants based on different approximation methods it actually uses: the one based on the cumulative estimation (referred to as ‘RRW-a’) and the other one based on the pointwise estimation (referred to as ‘RRW-b’). 
         [0120]    First, let us compare how different methods balance between the relevance and the diversity.  FIG. 3  shows the results on the NIPS co-authorship network. We test with different budgets (k=10, 20, 30, 40, 50, 100). In  FIG. 3(   a ), Div(1) means that we only consider 1-step neighbors to measure the diversity (i.e., setting t=1 in eq. (12)). In  FIG. 3(   b ), Div(2) means that we consider both 1-step and 2-step neighbors (i.e., setting t=2 in eq. (12)). We only present the results by RRW-a since RRW-b gives similar results. From  FIG. 3 , we can see that all the three methods are effective to improve the diversity. The Alg. 1 achieves a better balance between the relevance and the diversity. For ARW, although it gives the highest diversity score, its (normalized) relevance score is too low—only about half of the other two methods. This is because in ARW, only the first node is selected according to the relevance; and all the remaining (k−1) are selected by diversity. As for RRW-a, both its relevance and diversity scores are lower than Alg. 1. It is interesting to notice from  FIG. 3(   b ) that the diversity of RRW-a drops a lot when it is measured by within 2-step neighbors (i.e., Div(2)). This is consistent with the intuition of RRW. In RRW (both RRW-a and RRW-b), it achieves the diversity by encouraging 1-step neighboring nodes to compete with each other. Consequently, the density of its within 1-step induced subgraph might be low (i.e., high diversity), but it is not necessarily the case for the within t-step (t≧2) induced subgraph. 
         [0121]    In order to test how the overall performance of different methods varies across different data sets, we take the average between relevance and diversity scores. The results are presented in  FIG. 4(   a )- 4 ( d ), using four different co-authorship networks (SIGMOD, NIPS, SIGIR, SIGGRAPH). For the space limitation, we omit the results when the diversity is measured by within 1-steps neighbors, which is similar as the results by within 2-steps neighbors. It can be seen that Alg. 1 consistently performs the best. 
         [0122]    Comparisons with Alternative Optimization Methods 
         [0123]    In the discussion below, we evaluate the effectiveness and the efficiency of Algorithm 1 in terms of maximizing the goodness measure f(S). We compare it with the exponential enumeration and the binary quadratic programming methods discussed above. 
         [0124]    We also compare it with two other heuristics. The first method (referred to as ‘Heuristic1’) starts with generating a candidate pool (e.g., the top 10×k most relevant nodes), picks one seed node, and then repeatedly adds the most dis-similar (measured by A) node into the ranking list from the candidate pool. The second method (referred to as Heuristic2′) also starts with generating a candidate pool, puts all the nodes from candidate pool in the list, and then repeatedly drops a most similar (measured by A) node from the list. 
         [0125]    First, let us evaluate how the different methods balance between the optimization quality (measured by f(S) and the speed (measured by wall-clock time).  FIG. 5  shows the results from the co-authorship network of NIPS and KDD conferences with the budget k=20, where f(S) is normalized by the highest one among different methods. It can be seen that Alg. 1 is the best—it leads to the highest optimization quality (i.e., highest f(S)) with the least amount of wall-clock time. Notice that the y-axis is in logarithm scale. 
         [0126]    We also conducted experiments on the co-authorship network constructed from multiple conferences.  FIGS. 6(   a ) and  6 ( b ) show the results on these data sets with the budget k=20. Here Sub(n,m) means a co-authorship network with n nodes and m edges. We stop the program if it takes more than 100,000 seconds (i.e., more than 1-days). In  FIG. 6(   a ), the results from using algorithm 1, Heuristic 1, Heuristic 2, Lin-QP and Lte-BIP are shown at  60   a ,  60   b ,  60   c ,  60   d  and  60   e  respectively. In  FIG. 6(   b ), the results from using algorithm 1, Heuristic 1, Heuristic 2, Lin-QP and Lte-BIP are shown at  62   a ,  62   b ,  62   c ,  62   d  and  62   e  respectively. It can be seen from  FIGS. 6(   a ) and  6 ( b ) that Alg. 1 is consistently best across all the different data sets—it leads to the highest optimization quality (i.e., highest f(S) for ‘Lin-QP’ is missing for Sub(24K,114K) because it fails to finish within 100,000 seconds). This indicates that it is not feasible for large graphs. For the smaller graphs, ‘Lin-QP’ leads to slightly lower f(S) than Alg. 1; but it requires 3-5 orders of magnitude wall-clock time. For all the other comparative methods, they lead to worse optimization quality with longer wall-clock time. 
         [0127]    We also evaluate the scalability of Alg. 1. When we evaluate the scalability with respect to the number of the nodes in the graph, we fix the number of edges and vice versa. The results in  FIGS. 7(   a ) and  7 ( b ) are consistent with the complexity analysis discussed above—Alg. 1 scales linearly with respect to both n and m, which means that it is suitable for large graphs. 
         [0128]    A computer-based system  100  in which embodiments of the invention may be carried out is depicted in  FIG. 8 . The computer-based system  100  includes a processing unit  110 , which houses a processor, memory and other systems components (not shown expressly in the drawing) that implement a general purpose processing system, or computer that may execute a computer program product. The computer program product may comprise media, for example a compact storage medium such as a compact disc, which may be read by the processing unit  110  through a disc drive  120 , or by any means known to the skilled artisan for providing the computer program product to the general purpose processing system for execution thereby. 
         [0129]    The computer program product may comprise all the respective features enabling the implementation of the inventive method described herein, and which—when loaded in a computer system—is able to carry out the method. Computer program, software program, program, or software, in the present context means any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly or after either or both of the following: (a) conversion to another language, code or notation; and/or (b) reproduction in a different material form. 
         [0130]    The computer program product may be stored on hard disk drives within processing unit  110 , as mentioned, or may be located on a remote system such as a server  130 , coupled to processing unit  110 , via a network interface such as an Ethernet interface. Monitor  140 , mouse  150  and keyboard  160  are coupled to the processing unit  110 , to provide user interaction. Scanner  180  and printer  170  are provided for document input and output. Printer  170  is shown coupled to the processing unit  110  via a network connection, but may be coupled directly to the processing unit. Scanner  180  is shown coupled to the processing unit  110  directly, but it should be understood that peripherals might be network coupled, or direct coupled without affecting the performance of the processing unit  110 . 
         [0131]    While it is apparent that the invention herein disclosed is well calculated to fulfill the objectives discussed above, it will be appreciated that numerous modifications and embodiments may be devised by those skilled in the art, and it is intended that the appended claims cover all such modifications and embodiments as fall within the true spirit and scope of the present invention.