Abstract:
In one embodiment, a method of monitoring a network. The method includes, at each node of a set, constructing a corresponding vector of M components based on a stream of data packets received at the node during a time period, the set including a plurality of nodes of the network, M being greater than 1; and estimating a value of a byte traffic produced by a part of the packets based on the constructed vectors, the part being the packets received by every node of the set. The constructing includes updating a component of the vector corresponding to one of the nodes in response to the one of the nodes receiving a data packet. The updating includes selecting a component of the vector to be updated by hashing a property of the received data packet.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is related to U.S. application Ser. No. ______, filed on the same date as this application as attorney docket no. Bu 12-6-6, the teachings of which are incorporated herein by reference. 
     
    
     BACKGROUND OF THE INVENTION 
       [0002]    1. Field of the Invention 
         [0003]    The present invention relates to traffic analysis in a network. 
         [0004]    2. Description of the Related Art 
         [0005]    A database is a collection of information. Relational databases are typically illustrated as one or more two-dimensional tables. Each table arranges the information in rows and columns, with each row corresponding to a record and each column corresponding to a field. In a relational database, a collection of tables can be related or joined to each other through a common field or key, which enables information in one table to be automatically cross-referenced to corresponding information in another table. 
         [0006]    A complex search may be performed on a database with a query. A query specifies a set of criteria (e.g., the quantity of parts from a particular transaction) to define identified information for a database program to retrieve from the database. An aggregate query is a query that requests information concerning a selected group of records. For example, in a database which stores sales transactions, an aggregate query may request the total quantity of an item in a particular transaction. Each aggregate query may include a set of criteria to select records (e.g., grouping of records by an item code field and a transaction code field), and an operation to perform on the group of selected records (e.g., summing the quantity fields). Typical operations for aggregate queries include counting, summing, averaging, and finding minimum and maximum values. 
         [0007]    To perform an aggregate query, a conventional database program examines every record in the database to determine whether or not the record matches any criteria and constructs a query table from the records that match the criteria. Then the program performs the required operation over the appropriate fields from each record in the query table. 
         [0008]    Massive data streams are increasingly prevalent in many real-time applications, such as web applications, Internet-traffic monitoring, telecommunication-data management, financial applications, and sensor networks. Often, the data streams in these applications are distributed across many locations, and it is important to be able to answer aggregate queries that pool information from multiple locations. Given continuous data feeds to support real-time decision making in mission-critical applications, such as fraud and anomaly detection, these queries are typically evaluated continuously, in an online fashion. For example, in a high-speed network with many nodes, packet streams arrive at and depart from the nodes on a continuous basis. A quantity that is of importance for many network-management applications, such as optimization and fault management, is a traffic matrix, which is a representation of the volume of traffic (typically in packets or bytes) that flows between origin-destination (OD) node pairs in a communication network during a measurement interval. A traffic matrix varies over time, and a sudden change may indicate an underlying anomaly. 
         [0009]    In some circumstances, such as the monitoring of network traffic that includes high-speed and/or high-volume data streams, aggregate querying, as performed by conventional database programs, may be unacceptably slow. In such circumstances, exact computation for aggregate queries can be difficult to carry out, due to large memory requirements. 
         [0010]    The term “set expression” refers to an expression that defines a set of data elements and is made up of set identifiers (i.e., names of sets) and set operations (such as complements, unions, intersections, and differences) performed on those sets. Each data element may be, e.g., an individual byte of data or a record containing multiple bytes of data. The terms “stream expression” and “data stream,” as used herein, refer to a set expression defined over multiple streams (such as streams of data passing through different nodes of a network), where each stream is considered as a set of elements. Since, in a given stream expression, elements may appear more than once, the term “stream-expression cardinality” refers to the number of distinct elements in a stream expression. 
         [0011]    For example, in the Venn diagram of  FIG. 3 , where T 1  and T 2  represent two different stream expressions, the cardinality of T 1  is 1 (i.e., T 1  contains 1 distinct element), and the cardinality of T 2  is 2 (i.e., T 2  contains 2 distinct elements). The cardinality of the stream-intersection set T 1 ∩T 2  is 0, since there are no elements common to both T 1  and T 2 , and the cardinality of the stream-union set T 1 ∪T 2  is 3. 
       SUMMARY OF THE INVENTION 
       [0012]    In one embodiment, the present invention provides a method of monitoring a network. The method includes, at each node of a set, constructing a corresponding vector of M components based on a stream of data packets received at the node during a time period, the set including a plurality of nodes of the network, M being greater than 1; and estimating a value of a byte traffic produced by a part of the packets based on the constructed vectors, the part being the packets received by every node of the set. The constructing includes updating a component of the vector corresponding to one of the nodes in response to the one of the nodes receiving a data packet. The updating includes selecting a component of the vector to be updated by hashing a property of the received data packet. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0013]      FIG. 1  is an exemplary block diagram for a portion of a network implementing a method consistent with one embodiment of the present invention; 
           [0014]      FIG. 2  is a flowchart of an exemplary method for answering an aggregate query on the number of bytes in two data streams corresponding to a pair of network nodes, by using a Quasi-Maximum Likelihood Estimation (QMLE) estimator; 
           [0015]      FIG. 3  is a Venn diagram illustrating proportions of set-expression cardinalities for a two-stream set expression; 
           [0016]      FIG. 4  is a flowchart illustrating a method for vector generation for sum queries, consistent with one embodiment of the present invention; 
           [0017]      FIG. 5  is a flowchart illustrating a method for vector generation for count queries, consistent with one embodiment of the present invention; and 
           [0018]      FIG. 6  is a flowchart illustrating a method for generating a QMLE estimate consistent with one embodiment of the present invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0019]    Embodiments of the present invention will now be discussed in further detail in the following sequence. 
         [0020]    First, a Quasi-Maximum Likelihood Estimation (QMLE) estimator of the aggregate query will be proposed, which is near-optimal in terms of statistical efficiency, without requiring any prior knowledge of the actual distribution of the attribute values to be aggregated. Such a QMLE estimator constructs and employs, for each of the two data streams, vectors of M components, where M&gt;1. The vectors are compact representations of the actual elements in the streams. The near-optimality implies that algorithms consistent with embodiments of the invention can yield highly accurate estimates given a small amount of memory. A QMLE estimator is also scale-free, in the sense that the approximation error of the estimator is independent of unknown data-stream volumes. 
         [0021]    Second, a new vector-generating algorithm for approximately answering aggregate queries over two data streams will be presented. 
         [0022]    Theoretical analysis has shown that, with the same memory requirement, this approach has superior performance to those of the prior art, and the relative error of a QMLE estimator scales linearly with the square root of the noise-to-signal ratios, while prior-art approaches scale linearly with noise-to-signal ratios. 
         [0023]    An embodiment of a QMLE scheme is a traffic-matrix estimation problem in a high-speed network, where the objective is to accurately estimate total traffic volume (e.g., in bytes) between origin and destination nodes in the network, using byte streams observed at individual nodes. This embodiment may be used in the system of  FIG. 1 . In that system, data streams travel from an origin node  101  to a destination node  102  via the Internet  103 . A first stream τ 1  consists of bytes passing through origin node  101 , and a second stream τ 2  consists of bytes passing through destination node  102 . Each of nodes  101  and  102  generates and provides a vector of M components, where M&gt;1, to server  104 , which uses the vectors to generate a QMLE estimate, i.e., an estimate of the number of bytes in these data streams. Server  104  includes a memory  105  (e.g., a hard disk or RAM device) that contains machine-readable instructions for generating the QMLE estimate. This QMLE estimate characterizes the amount of traffic between origin node  101  and destination node  102  and can be used by server  104  for various traffic-monitoring or routing purposes. For example, server  104  might send messages to one or more nodes in the network (not shown) to admit new bytes into the network at origin node  101  or to deny entrance to such new bytes, depending on the whether the amount of traffic indicated by the QMLE estimate (i.e., an unusually large amount of traffic) indicates a potential traffic anomaly, such as a denial-of-service (DoS) attack. 
         [0024]      FIG. 2  shows an embodiment of a method for answering an aggregate query on the number of bytes in two data streams corresponding to a pair of network nodes, using a QMLE estimator. First, at step  200 , the aggregate query is received. At step  210 , vectors are generated at a pair of individual nodes in the network (e.g., as shown in the flowchart of  FIG. 4 , which will be discussed in further detail below. Step  210  can be carried out, e.g., according to Algorithm 1, below. Next, at step  220 , the vectors from the pair of individual nodes in the network are all received at a single node (e.g., server  104  of  FIG. 1 ). This receiving step may be the result of one or more queries from the single node, or alternatively, the vectors may automatically be provided by the individual nodes. At step  230 , a QMLE scheme consistent with one embodiment of the invention, as will be described in further detail below, is used to estimate the number of bytes in stream expressions over the pair of individual nodes in the network, i.e., QMLE estimate is generated by applying one or more set operations to the vectors corresponding to the stream expressions. Step  230  can be carried out, e.g., by methods based on Statement 1 and Equation (11), below. Lastly, at step  240 , the QMLE estimate of the number of bytes is returned as the answer to the aggregate query. This estimate can then be used, e.g., to identify potential traffic anomalies in the network. While exact computation for aggregate queries can be difficult, an attractive alternative solution is to yield approximate answers that can provide probabilistic guarantees of approximation errors. For the solution to be viable, approximation algorithms should be designed with small memory requirements and a small per-data record-processing overhead that can achieve reasonable accuracy for approximate query-answering. 
         [0025]    For a pair of high-volume data streams, each record in the stream is composed of an identifier and value pair, (i, ν), where each identifier i is unique in each data stream, and ν has a finite variance. In practice, such a constraint on attributes (i, ν) is satisfied or approximately satisfied in many situations. For example, in the traffic-matrix estimation problem, duplicate packets constitute a very small percentage of the total traffic (typically less than 2%), and packet sizes are bounded, usually between 1 and 1500 packets. 
         [0026]    Embodiments of the present invention provide schemes for providing approximate answers to aggregate queries (e.g., sum queries, count queries, and average queries) of ν over the pair of data streams in a time interval, using the identifier i as the equi-join attribute (a value for i that is compared based only on whether or not it is equal to another value i from a different record). Such schemes are based on vectors, each vector being a compact synopsis that can be generated, for each data stream, with little processing overhead. If a sum query is being answered, and ν is always positive, then such schemes can be generalized to other situations. 
         [0027]    Each vector is a hash array of size M generated as follows. For each incoming record (i, ν) in the stream, the record is first hashed to a bucket using its identifier i as a hash key, and then a value g(i) is computed, where g(•) is a unit-exponential random-number generator using i as its seed value. Each bucket then stores the minimum value of g(i)/ν for all records hashed to the bucket. At the end of each measurement interval, the vectors for both data streams are routed to a centralized location, where an accurate estimate of the sum query is obtained using a QMLE method, as will be described in further detail below. Such algorithms are scale-free in the sense that, for a given level of approximation accuracy, M is independent of unknown data-stream volumes. 
         [0028]    A feature of certain embodiments of the present invention is the development of a likelihood-based inference, based on a new statistical model of vectors. As a result, estimates are generated that are highly efficient and scale well with high noise-to-signal ratios. Furthermore, an accurate approximation of the distribution of relative-estimation error can be derived, which provides a much more informative characterization of the error distribution than loose probability bounds. 
         [0029]    While other solutions for count-query computation over data streams have previously been proposed based on hashing and extreme values of a randomization function applied to each data stream, in embodiments of the present invention, the distribution of ν is unknown in advance, and hence, the distribution of the hash-array values for the vector-generating algorithm is not exactly known. QMLE methods consistent with embodiments of the present invention account for this uncertainty and yield near-optimal estimates in terms of statistical efficiency. 
         [0030]    The following additional notations will be used herein. The expression P(•) represents a probability function. The expressions E(•) and var(•) represent the expectation and variance of a random variable, respectively. The expressions corr(•,•) and cov(•,•) represent correlation and covariance, respectively, between two random variables, and the expression 
         [0000]    
       
         
           
             → 
             
               
                   
               
                
               d 
                
               
                   
               
             
           
         
       
     
         [0000]    represents a convergence in distribution. The expression means a definition, and the expression a≈b is equivalent to a/b≈1, where the operator represents an approximation of equality. The operators ∪, ∩, and \ represent set union, set intersection, and set difference, respectively. 
         [0031]    An introduction to the problem, including a streaming algorithm for vector generation of an individual stream, will now be provided. 
         [0032]    The expressions τ 1 , τ 2  represent two data streams, where each element is composed of an identifier and value pair (i, ν). Assuming that there is no duplicate identifier i in each of the data streams in a given time interval, and that the attribute value ν has a finite variance (the finite variance assumption is satisfied, e.g., if ν is bounded), approximate answers are sought for: 
         [0000]        V=Σ   (i,ν)ετ     1     ∩τ     2   ν(sum query), 
         [0000]        C=Σ   (i,ν)ετ     1     ∩τ     2   1(sum query), 
         [0000]        A=V/C (average query).  (1) 
         [0033]    Here, τ 1 ∩τ 2  denotes the intersection of τ 1  and τ 2 . In exemplary database language, the expressions V, C, A represent the result of aggregate queries for attribute value ν of the equi-join of two data streams τ 1 , τ 2  using identifier i. 
         [0034]    Of particular interest is a scenario in which τ 1 , τ 2  are of very high volume, e.g., containing millions or even billions of records. A highly accurate and scale-free estimate is desirable, where “scale-free” implies that the approximation errors of the underlying algorithm are independent of unknown volumes. A vector-generating algorithm consistent with embodiments of the invention is applied to each data stream to achieve this goal. A vector-generating algorithm designed to answer the sum queries will first be presented, and then the cases of the count query and average query will be discussed. 
         [0035]    Without the loss of generality, it is assumed that attribute value ν is always positive (zero values of ν can be ignored, since such values do not contribute to the sum). If one or more ν values are not positive, then the values of ν can always be divided into two groups, one for the positive values of ν, and one or the negative values of ν, and a single sum query will then be converted into two sum queries, one for the positive values of ν, and the other for the negative values of ν. 
         [0036]    As shown in the flowchart of  FIG. 4 , for each data stream τ, a vector is generated and stored in a hash array Y=(Y[1], . . . , Y[M]) T  of size M using the following method. First, at step  410 , at the start of the measurement interval, all hash-array buckets are initialized with values of ∞. At step  420 , an incoming record (i, ν) is hashed to bucket h(i) using identifier i as the hash key, where h(•) is a uniform hashing function generating values from 1 to M. Next, at step  430 , g(i) is computed, where g(•) is a unit-exponential random-number generator using i as its seed. It is noted that h(i) and g(i) can be computed in parallel. At step  440 , the current bucket then stores the minimum value of g(i)/ν for all records hashed to the bucket, i.e., an update of Y[h(i)] is performed using Y[h(i)]←min(Y[h(i)],g(i)/ν). At step  450 , a determination is made whether additional records exist, in which case the method returns to step  420 . If, at step  450 , it is determined that no additional records exist, then the method proceeds to step  460 , wherein hash array Y is returned as a result. A bucket value will remain at ∞ if no record is hashed to the bucket. The following exemplary pseudo-code (Algorithm 1) may be used to implement the foregoing algorithm, which is executed for both data streams independently, using the same functions h(•) and g(•). 
         [0000]                                      Algorithm 1: Online sketch generation for Sum Queries                                    1: Initialize a hash array Y of size M with values ∞;           2: for each incoming record (i,v) do           3:  update Y[h(i)] = min(Y[h(i)], g(i)/v)           4: Return Y at the end of each measurement interval.                        
In Algorithm 1, steps  1 ,  2 ,  3 , and  4  correspond to steps  410 ,  450 ,  440 , and  460  of  FIG. 4 , respectively, as described above.
 
         [0037]    The expression N represents the total number of records in stream τ, and λ=N/M represents the average number of records in each bucket. For the kth bucket, 1≦k≦M, if there are B k  records hashed into the bucket, i.e., (i k,l ,ν k,l ), l=1, . . . , B k , and for each record (i k,l ,ν k,l ), l=1, . . . , B k , the expression R k,l =g(i k,l ), then 
         [0000]    
       
         
           
             
               
                 
                   
                     Y 
                      
                     
                       [ 
                       k 
                       ] 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               ∞ 
                             
                             
                               
                                 
                                   
                                     if 
                                      
                                     
                                         
                                     
                                      
                                     
                                       B 
                                       k 
                                     
                                   
                                   = 
                                   0 
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 min 
                                  
                                 
                                   { 
                                   
                                     
                                       
                                         
                                           
                                             R 
                                             
                                               k 
                                               , 
                                               l 
                                             
                                           
                                           / 
                                           
                                             υ 
                                             
                                               k 
                                               , 
                                               l 
                                             
                                           
                                         
                                          
                                         
                                           : 
                                         
                                          
                                         
                                             
                                         
                                          
                                         l 
                                       
                                       = 
                                       1 
                                     
                                     , 
                                     … 
                                      
                                     
                                         
                                     
                                     , 
                                     
                                       B 
                                       k 
                                     
                                   
                                   } 
                                 
                               
                             
                             
                               
                                 
                                   if 
                                    
                                   
                                       
                                   
                                    
                                   
                                     B 
                                     k 
                                   
                                 
                                 ≥ 
                                 1. 
                               
                             
                           
                         
                          
                         
                           
 
                         
                          
                         Now 
                       
                       , 
                       if 
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       V 
                       k 
                     
                     = 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         
                           B 
                           k 
                         
                       
                        
                       
                         υ 
                         
                           k 
                           , 
                           l 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0000]    is the total sum of attribute values in bucket k, and it is assumed that attribute value ν is always positive, then it can be seen that, when B k ≧1, 
         [0000]    
       
         
           
             
               
                 min 
                  
                 
                   { 
                   
                     
                       
                         
                           
                             R 
                             
                               k 
                               , 
                               l 
                             
                           
                           
                             υ 
                             
                               k 
                               , 
                               l 
                             
                           
                         
                         : 
                         l 
                       
                       = 
                       1 
                     
                     , 
                     … 
                      
                     
                         
                     
                     , 
                     
                       B 
                       k 
                     
                   
                   } 
                 
               
                
               
                 = 
                 d 
               
                
               
                 
                   
                     R 
                     k 
                   
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         1 
                       
                       
                         B 
                         k 
                       
                     
                      
                     
                       υ 
                       
                         k 
                         , 
                         l 
                       
                     
                   
                 
                 = 
                 
                   
                     R 
                     k 
                   
                   
                     V 
                     k 
                   
                 
               
             
             , 
           
         
       
     
         [0000]    for some values of R k , which is a unit-exponential random variable. Therefore, the following equation for Y[k] can be derived: 
         [0000]    
       
         
           
             
               
                 
                   
                     Y 
                      
                     
                       [ 
                       k 
                       ] 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           ∞ 
                         
                         
                           
                             
                               
                                 if 
                                  
                                 
                                     
                                 
                                  
                                 
                                   B 
                                   k 
                                 
                               
                               = 
                               0 
                             
                             , 
                           
                         
                       
                       
                         
                           
                             
                               R 
                               k 
                             
                             / 
                             
                               V 
                               k 
                             
                           
                         
                         
                           
                             
                               
                                 if 
                                  
                                 
                                     
                                 
                                  
                                 
                                   B 
                                   k 
                                 
                               
                               ≥ 
                               1 
                             
                             , 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where R k  is a unit exponential, and V k  follows Equation (3) shown above. 
         [0038]    Since the attribute values are not stored in hash array Y[k], 1≦k≦M, the exact distribution of Y[k] is unknown. However, an approximate distribution of Y[k] when λ is large can be obtained as follows. If ν is a random variable generated from an unknown distribution F with mean ν and variance κν 2 , and κ is the ratio of variance-to-mean square, i.e., the square of the coefficient of variance, then it can be seen that B k  follows a binomial distribution Binomial(N, 1/M), which is approximately a Poisson discrete-probability distribution Poisson(λ) for large values of N, M. It can be shown that 
         [0000]      E[V k ]=λν, Var[ V   k ]=(1+κ)ν 2 .  (5) 
         [0000]    and it can be further verified that, as λ→∞, almost surely, 
         [0000]    
       
         
           
             
               
                 
                   V 
                   k 
                 
                 λ 
               
               → 
               ν 
             
             , 
           
         
       
     
         [0000]    and in distribution, 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         V 
                         k 
                       
                       - 
                       
                         λ 
                          
                         
                             
                         
                          
                         ν 
                       
                     
                     
                       λ 
                     
                   
                   → 
                   
                     
                        
                        
                       
                         ( 
                         
                           0 
                           , 
                           
                             
                               ( 
                               
                                 1 
                                 + 
                                 κ 
                               
                               ) 
                             
                              
                             
                               ν 
                               2 
                             
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Therefore, Y[k] approximates an exponential distribution with rate λν. It is further noted that the values of R k , k=1, . . . , M, are independent, and the values of B k , k=1, . . . , M, are approximately independent when N, M are large, and hence, the values of Y[k], 1≦k≦M, are approximately independent. The following Lemma 1 states a mathematical relationship characterizing the statistical properties of Y[k]:
       Lemma 1: When N, M, λ are large. Y[k], 1≦Y≦M are approximately independent exponential random variables with rate λν.
 
An improved approximation to distribution Y[k] can be obtained using a Gamma distribution, as disclosed in Johnson et al.,  Continuous Univariate Distributions, Vol.  2, Wiley Series in Probability and Statistics, 1995, which is incorporated herein by reference in its entirety, instead of using a constant as in Lemma 1, to approximate the distribution of V k  in Equation (3), i.e.,
       
 
         [0000]        V   k ≈Gamma(α,β),  (7) 
         [0000]    where α is a shape parameter and β is a scale parameter of the Gamma distribution. A sum of independent random variables V k  can be approximated using a Gamma distribution with a large shape parameter, as well as a Normal distribution. However, the Gamma distribution is positive and the Normal distribution is not, and therefore, a Gamma approximation is more desirable in practice. By equating the first and second moments of the Gamma distribution with those of V k , it can be seen that the shape and scale parameters (α,β) of the Gamma distribution approximation are 
         [0000]    
       
         
           
             
               
                 
                   
                     α 
                     = 
                     
                       λ 
                       
                         1 
                         + 
                         κ 
                       
                     
                   
                   , 
                   
                     β 
                     = 
                     
                       
                         ν 
                          
                         
                           ( 
                           
                             1 
                             + 
                             κ 
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Using the traffic-matrix estimation problem as an example in simulations, it has been shown that the Gamma distribution provides a good approximation for λ, even when λ is as small as 5. 
         [0040]    It might be assumed that V k  follows a Gamma distribution with shape α and scale β. However, since this assumption might not be exactly true, the variables P Q  and E Q  will be used to denote the probability and expectation, respectively, based on this assumed distribution for V k , which will be referred to as a “quasi-likelihood” method. Then, by using the characteristic function of the Gamma distribution, the following equation holds true: 
         [0000]        P   Q ( Y[k]≧y )= E   Q   [e   −yV     k   ]=(1 +βy ) −α . 
         [0000]    In other words, Y[k] follows a generalized-Pareto distribution Pareto(α,β). 
         [0041]    The cases of the count query and average query will now be discussed. A count query returns a cardinality, e.g., the number of records (or, in other embodiments, bytes) in a data stream. To provide an approximate answer for the count query in Equation (1), a hash array can be designed for each stream, in a manner similar to Algorithm 1, by replacing ν with a constant value of 1. This has been proposed in the prior art, wherein a Maximum-Likelihood Estimate (MLE) is derived, e.g., as described in Chen et al., “A simple and efficient estimation method for stream expression cardinalities,”  Proceedings of the  33 rd International Conference on Very Large Data Bases  ( VLDB ), 2007, which is incorporated herein by reference in its entirety. As shown in the flowchart of  FIG. 5 , for each data stream τ, a vector is generated and stored in a hash array Y=(Y[1], . . . , Y[M]) T  of size M using the following method. First, at step  510 , at the start of the measurement interval, all hash-array buckets are initialized with values of ∞. At step  520 , an incoming record (i, ν) is hashed to bucket h(i) using identifier i as the hash key, where h(•) is a uniform hashing function generating values from 1 to M. Next, at step  530 , g(i) is computed, where g(•) is a unit-exponential random-number generator using i as its seed. It is noted that h(i) and g(i) can be computed in parallel. At step  540 , the current bucket then stores the minimum value of g(i) for all records hashed to the bucket, i.e., an update of Y[h(i)] is performed using Y[h(i)] k min(Y[h(i)],g(i)). At step  550 , a determination is made whether additional records exist, in which case the method returns to step  520 . If, at step  550 , it is determined that no additional records exist, then the method proceeds to step  560 , wherein hash array Y is returned as a result. A bucket value will remain at ∞ if no record is hashed to the bucket. The following exemplary pseudo-code (Algorithm 2) may be used to implement, in a self-contained manner, the foregoing algorithm for generating a vector for the count query, which is executed for both data streams independently, using the same functions h(•) and g(•). 
         [0000]                                      Algorithm 2 Online sketch generation for Count Queries                                    1: Initialize a hash array Y of size M with value ∞.           2: for each incoming data (i,v) do           3:  update Y[h(i)] = min(Y[h(i)], g(i))           4: Return Y at the end of each measurement interval.                        
It is noted that Algorithm 2 is substantially similar to Algorithm 1 discussed above, except that an update of Y[h(i)] is performed using Y[h(i)]←k min(Y[h(i)],g(i)), instead of Y[h(i)]←min(Y[h(i)],g(i)/ν). In the scenario of Algorithm 2, the distribution of Y[k] is a truncated exponential distribution with rate λ, which also implies that Y[k] is approximately exponential with rate λ when λ is large. Thus, a new Quasi-Maximum Likelihood Estimation (QMLE) method, which will be described below, can also be applied for the count query, and its performance will be similar to that of an MLE method.
 
         [0042]    To answer the average query, two hash arrays are used for each data stream, one for computing the sum query, and the other for computing the count query. The result of the average query is simply the division of the sum query by the count query. Accurately estimating the sum aggregation will be discussed in further detail below. 
         [0043]    The details of a Quasi-Maximum Likelihood Estimation (QMLE) method for aggregation will now be discussed. Arrays (Y 1 [k], Y 2 [k]), k=1, . . . , M, are a pair of hash arrays that store the pseudo-random vectors applied to streams τ 1  and τ 2 , respectively, using Algorithm 1 with the same functions h and g. The variables Λ 1 , Λ 2 , and μ represent the mean of the total attribute sums for records in streams τ 1 , τ 2 , and τ 1 ∩τ 2 , respectively, which are hashed to an arbitrary bucket. It is noted that Λ 1  and Λ 2  can be treated as known quantities using the total sums of attribute values in the two streams divided by M. It is further noted that Mμ is the answer to the aggregate query in Equation (1). A near-optimal statistical method for estimating μ, using (Y 1 [k], Y 2 [k]), k=1, . . . , M, will be presented below. 
         [0044]    For simplicity, it is assumed that the attribute values in both streams τ 1 , τ 2  are generated from the same unknown distribution F, with mean ν and variance κν 2 . In simulation studies, it has been shown that such a simplification does not substantially alter the quality of the estimates obtained from a QMLE method. 
         [0045]    It is noted that, in general, attribute distribution F is unknown. In statistical terms, F is a nuisance parameter for estimating μ, the parameter of interest. Since F is unknown, the exact distribution of (Y 1 [k], Y 2 [k]) is also unknown. Therefore, the usual MLE method, which is well-known to be most efficient in the statistics literature, cannot be used. However, by using a Gamma approximation, as in Equation (7), a Quasi-Maximum Likelihood Estimation (QMLE) method for estimating μ can yield a near-optimal estimate in terms of statistical efficiency. 
         [0046]    The following additional notation will be used in the explanation below. In generating (Y 1 [k], Y 2 [k]), k=1, . . . , M, the expressions X[k], X 1 [k], X 2 [k], k=1, . . . , M, represent vectors corresponding to streams τ 1 ∩τ 2 , τ 1 \τ 2 , and τ 2 \τ 1 , respectively. Expressions X[k], X 1 [k], X 2 [k], k=1, . . . , M, are also obtained using Algorithm 1 but are clearly unobservable. It can be seen that 
         [0000]        Y   i   [k ]=min( X[k],X   i   [k ]), i=1, 2. 
         [0000]    The variables λ, λ 1 , λ 2  represent the average number of records hashed into each bucket, which belong to streams τ 1 ∩τ 2 , τ 1 \τ 2 , respectively. As described above, each of X[k], X 1 [k], X 2 [k] can be approximated by a generalized-Pareto distribution when λ, λ 1 , λ 2  are large. Therefore, to estimate μ, the likelihood function of (Y 1 [k], Y 2 [k]) can be derived by treating the generalized-Pareto distributions of X[k], X 1 [k], X 2 [k] as true models, i.e., 
         [0000]        X ≈Pereto(α,β),  X   i ≈Pereto(α i ,β).  (9) 
         [0047]    Then, μ is derived using the usual MLE method. Since the assumed models in Equation (9) might not be true, such a method is referred to in the statistics literature as a “Quasi-” Maximum-Likelihood Estimation (QMLE) method. Typically, there will be a bias for a QMLE estimate, which bias will be shown below to be negligible for large values of λ+λ 1 +λ 2 , and a QMLE estimate will be shown to be near-optimal in terms of statistical efficiency. 
         [0048]    The variable P Q  denotes the quasi-probability based on this Pareto-distribution assumption. The quasi-likelihood can be derived as follows. For y 1 ≧0, y 2 ≧0, the following equations are true: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       P 
                       Q 
                     
                      
                     
                       ( 
                       
                         
                           
                             Y 
                             1 
                           
                           ≥ 
                           
                             y 
                             1 
                           
                         
                         , 
                         
                           
                             Y 
                             2 
                           
                           ≥ 
                           
                             y 
                             2 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       P 
                       Q 
                     
                      
                     
                       ( 
                       
                         
                           
                             min 
                              
                             
                               ( 
                               
                                 X 
                                 , 
                                 
                                   X 
                                   1 
                                 
                               
                               ) 
                             
                           
                           ≥ 
                           
                             y 
                             1 
                           
                         
                         , 
                         
                           
                             min 
                              
                             
                               ( 
                               
                                 X 
                                 , 
                                 
                                   X 
                                   2 
                                 
                               
                               ) 
                             
                           
                           ≥ 
                           
                             y 
                             2 
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       P 
                       Q 
                     
                      
                     
                       ( 
                       
                         
                           X 
                           ≥ 
                           
                             min 
                              
                             
                               ( 
                               
                                 
                                   y 
                                   1 
                                 
                                 , 
                                 
                                   y 
                                   2 
                                 
                               
                               ) 
                             
                           
                         
                         , 
                         
                           
                             X 
                             1 
                           
                           ≥ 
                           
                             y 
                             1 
                           
                         
                         , 
                         
                           
                             X 
                             2 
                           
                           ≥ 
                           
                             y 
                             2 
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         ( 
                         
                           1 
                           + 
                           
                             β 
                              
                             
                                 
                             
                              
                             
                               min 
                                
                               
                                 ( 
                                 
                                   
                                     y 
                                     1 
                                   
                                   , 
                                   
                                     y 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ) 
                       
                       
                         - 
                         α 
                       
                     
                      
                     
                       
                         ( 
                         
                           1 
                           + 
                           
                             β 
                              
                             
                                 
                             
                              
                             
                               y 
                               1 
                             
                           
                         
                         ) 
                       
                       
                         - 
                         
                           α 
                           1 
                         
                       
                     
                      
                     
                       
                         
                           ( 
                           
                             1 
                             + 
                             
                               β 
                                
                               
                                   
                               
                                
                               
                                 y 
                                 2 
                               
                             
                           
                           ) 
                         
                         
                           - 
                           
                             α 
                             2 
                           
                         
                       
                       . 
                     
                   
                 
               
             
           
         
       
     
         [0000]    Thus, a quasi-density function, P Q (Y 1 =y 1 , Y 2 =y 2 ), can be written as 
         [0000]    
       
         
           
             
               
                 
                   { 
                   
                     
                       
                         
                           
                             Case 
                              
                             
                                 
                             
                              
                             1 
                              
                             
                               ( 
                               
                                 
                                   y 
                                   1 
                                 
                                 &lt; 
                                 
                                   y 
                                   2 
                                 
                               
                               ) 
                             
                           
                           : 
                         
                       
                       
                         
                           
                             
                               
                                 
                                   
                                     α 
                                     1 
                                   
                                    
                                   
                                     ( 
                                     
                                       α 
                                       + 
                                       
                                         α 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   
                                     
                                       β 
                                       2 
                                     
                                      
                                     
                                       ( 
                                       
                                         1 
                                         + 
                                         
                                           β 
                                            
                                           
                                               
                                           
                                            
                                           
                                             y 
                                             1 
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                   
                                     - 
                                     
                                       ( 
                                       
                                         
                                           α 
                                           1 
                                         
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     
                                       1 
                                       + 
                                       
                                         β 
                                          
                                         
                                             
                                         
                                          
                                         
                                           y 
                                           2 
                                         
                                       
                                     
                                     ) 
                                   
                                   
                                     - 
                                     
                                       ( 
                                       
                                         α 
                                         + 
                                         
                                           α 
                                           2 
                                         
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                                 ; 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             Case 
                              
                             
                                 
                             
                              
                             2 
                              
                             
                               ( 
                               
                                 
                                   y 
                                   2 
                                 
                                 &gt; 
                                 
                                   y 
                                   1 
                                 
                               
                               ) 
                             
                           
                           : 
                         
                       
                       
                         
                           
                             
                               
                                 
                                   
                                     α 
                                     1 
                                   
                                    
                                   
                                     ( 
                                     
                                       α 
                                       + 
                                       
                                         α 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   
                                     
                                       β 
                                       2 
                                     
                                      
                                     
                                       ( 
                                       
                                         1 
                                         + 
                                         
                                           β 
                                            
                                           
                                               
                                           
                                            
                                           
                                             y 
                                             1 
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                   
                                     - 
                                     
                                       ( 
                                       
                                         
                                           α 
                                           1 
                                         
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     
                                       1 
                                       + 
                                       
                                         β 
                                          
                                         
                                             
                                         
                                          
                                         
                                           y 
                                           2 
                                         
                                       
                                     
                                     ) 
                                   
                                   
                                     - 
                                     
                                       ( 
                                       
                                         α 
                                         + 
                                         
                                           α 
                                           2 
                                         
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                                 ; 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             Case 
                              
                             
                                 
                             
                              
                             3 
                              
                             
                               ( 
                               
                                 
                                   y 
                                   1 
                                 
                                 = 
                                 
                                   y 
                                   2 
                                 
                               
                               ) 
                             
                           
                           : 
                         
                       
                       
                         
                           
                             
                               αβ 
                                
                               
                                 ( 
                                 
                                   1 
                                   + 
                                   
                                     β 
                                      
                                     
                                         
                                     
                                      
                                     
                                       y 
                                       1 
                                     
                                   
                                 
                                 ) 
                               
                             
                             
                               - 
                               
                                 ( 
                                 
                                   α 
                                   + 
                                   
                                     α 
                                     1 
                                   
                                   + 
                                   
                                     α 
                                     2 
                                   
                                   + 
                                   1 
                                 
                                 ) 
                               
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0049]    The variable m i  represents the proportion of Case i, i=1, 2, 3, in the M-obtained bucket pairs, (Y 1 [k], Y 2 [k]), k=1, . . . , M. It can be observed that, for some bucket pairs, it is possible that one or even both of the values will be ∞ if no records are hashed into one or both buckets in the pair. The expression Y i * is defined as Y i *=Y i I(Y i &lt;∞), i=1, 2. From Equation (8), the relations μ=αβ and κ i =(α+α i )β, i=1, 2, can be derived. By using this transformation, the quasi-likelihood function can be expressed as a function of β, μ, Λ 1 , Λ 2 , where Λ 1 , Λ 2  can be treated as known quantities, as explained previously. The following Statement 1 provides the average quasi-log likelihood of the pair of hash arrays, (Y 1 [k], Y 2 [k]), k=1, . . . , M. 
         [0050]    Statement 1:
       The average quasi log-likelihood −(μ,β) with data {(Y 1 [k], Y 2 [k]): k=1, . . . , M} can be written as       
 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         l 
                         Q 
                       
                        
                       
                         ( 
                         
                           μ 
                           , 
                           β 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         m 
                         3 
                       
                        
                       log 
                     
                   
                    
                   
                       
                   
                    
                   
                     
                       μ 
                       + 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           2 
                         
                          
                         
                           
                             m 
                             i 
                           
                            
                           
                             log 
                              
                             
                               ( 
                               
                                 
                                   Λ 
                                   i 
                                 
                                 - 
                                 μ 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       
                         
                           μβ 
                           
                             - 
                             1 
                           
                         
                          
                         
                           
                             S 
                             3 
                           
                            
                           
                             ( 
                             β 
                             ) 
                           
                         
                       
                       - 
                       
                         
                           β 
                           
                             - 
                             1 
                           
                         
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             2 
                           
                            
                           
                             
                               Λ 
                               i 
                             
                              
                             
                               
                                 S 
                                 i 
                               
                                
                               
                                 ( 
                                 β 
                                 ) 
                               
                             
                           
                         
                       
                       + 
                       
                         
                           S 
                           0 
                         
                          
                         
                           ( 
                           β 
                           ) 
                         
                       
                       - 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           2 
                         
                          
                         
                           
                             S 
                             i 
                           
                            
                           
                             ( 
                             β 
                             ) 
                           
                         
                       
                       + 
                       const 
                     
                     , 
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
       
         
           
             where Y 3 [k]=min(Y 1 *[k], Y 2 *[k]) and for i=1, 2, 3. 
           
         
       
     
         [0000]    
       
         
           
             
               
                 
                   S 
                   i 
                 
                  
                 
                   ( 
                   β 
                   ) 
                 
               
               = 
               
                 
                   1 
                   M 
                 
                  
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       1 
                     
                     M 
                   
                    
                   
                     log 
                      
                     
                       ( 
                       
                         1 
                         + 
                         
                           β 
                            
                           
                               
                           
                            
                           
                             
                               Y 
                               1 
                               * 
                             
                              
                             
                               [ 
                               k 
                               ] 
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 
                   S 
                   0 
                 
                  
                 
                   ( 
                   β 
                   ) 
                 
               
               = 
               
                 
                   
                     1 
                     M 
                   
                    
                   
                     
                       ∑ 
                       
                         k 
                         = 
                         1 
                       
                       M 
                     
                      
                     
                       
                         log 
                          
                         
                           ( 
                           
                             1 
                             + 
                             
                               β 
                                
                               
                                   
                               
                                
                               
                                 
                                   Y 
                                   1 
                                   * 
                                 
                                  
                                 
                                   [ 
                                   k 
                                   ] 
                                 
                               
                             
                           
                           ) 
                         
                       
                        
                       
                         
                           I 
                            
                           
                             ( 
                             
                               
                                 
                                   Y 
                                   1 
                                   * 
                                 
                                  
                                 
                                   [ 
                                   k 
                                   ] 
                                 
                               
                               = 
                               
                                 
                                   Y 
                                   2 
                                   * 
                                 
                                  
                                 
                                   [ 
                                   k 
                                   ] 
                                 
                               
                             
                             ) 
                           
                         
                         . 
                         
                           
 
                         
                          
                         
                           Let 
                            
                           
                             
 
                           
                           ( 
                           
                             
                               
                                 μ 
                                 ^ 
                               
                               Q 
                             
                             , 
                             
                               
                                 β 
                                 ^ 
                               
                               Q 
                             
                           
                           ) 
                         
                       
                     
                   
                 
                 = 
                 
                   arg 
                    
                   
                       
                   
                    
                   max 
                    
                   
                       
                   
                    
                   
                     
                       
                         l 
                         Q 
                       
                        
                       
                         ( 
                         
                           μ 
                           , 
                           β 
                         
                         ) 
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
         [0000]    Therefore, as shown in  FIG. 6 , the quasi-likelihood function l Q (μ,β) is first obtained, at step  610 , using Equation (11), based on the values of β, μ, Λ 1 , Λ 2 . Next, at step  620 , to obtain {circumflex over (μ)} Q , which represents a QMLE estimate of μ, Newton-Rapson type algorithms (or other algorithms) are employed to maximize the quasi-likelihood function l Q (μ,β). 
         [0053]    Thus, a new Quasi-Maximum Likelihood Estimation (QMLE) method has been developed in response to an increased focus on probabilistic-query algorithms for large-volume data streams. Embodiments of the present invention further address the problem of aggregate queries, such as sum, count, and average, and provide new algorithms based on minimum statistics and quasi-likelihood inference. A QMLE method consistent with certain embodiments of the invention is near-optimal in terms of statistical efficiency. Both theoretical analysis and empirical studies have shown that, with the same memory requirement, a QMLE method has significantly superior performance relative to existing perturbation methods, particularly when noise-to-signal ratios are large. A method for monitoring bytes among a pair of network nodes by using a QMLE estimator, e.g., for the purpose of detecting network-traffic anomalies, has also been presented. 
         [0054]    It has been demonstrated empirically that, for a pair of high-volume data streams, estimation algorithms consistent with certain embodiments of the present invention yield more accurate estimates of the aggregate queries than existing approaches, using the same amount of memory. 
         [0055]    The terms “Quasi-Maximum Likelihood Estimation” and “QMLE” should be understood to include the particular implementations and embodiments explicitly described herein, as well as other possible implementations and embodiments. 
         [0056]    While embodiments of the invention disclosed herein use certain methods for generating statistical vectors, as shown in  FIGS. 4 and 5 , it should be understood that a QMLE estimator consistent with alternative embodiments of the invention could use other methods for generating statistical vectors. 
         [0057]    The present invention has applicability in monitoring traffic in different environments and comprising data streams of different types, including not only traditional-network (e.g., hardwired LAN) data streams, but also, e.g., wireless-network data streams, sensor-network data streams, and financial-application data streams. A QMLE scheme consistent with certain embodiments of the invention can be used to estimate both the number of bytes and the number of packets in stream expressions over a pair of individual nodes in a network. 
         [0058]    The term “random,” as used herein, should not be construed as being limited to pure random selections or number generations, but should be understood to include pseudo-random, including seed-based selections or number generations, as well as other selection or number generation methods that might simulate randomness but are not actually random, or do not even attempt to simulate randomness. 
         [0059]    The present invention may be implemented as circuit-based processes, including possible implementation as a single integrated circuit (such as an ASIC or an FPGA), a multi-chip module, a single card, or a multi-card circuit pack. As would be apparent to one skilled in the art, various functions of circuit elements may also be implemented as processing blocks in a software program. Such software may be employed in, for example, a digital signal processor, micro-controller, or general-purpose computer. 
         [0060]    The present invention can be embodied in the form of methods and apparatuses for practicing those methods. The present invention can also be embodied in the form of data-storage media, such as magnetic recording media, optical recording media, solid state memory, floppy diskettes, CD-ROMs, hard drives, or any other machine-readable data-storage medium storing machine-readable program code, wherein the program code includes a set of instructions for executing one of the inventive methods on a digital data-processing machine, such as a computer, to perform the method. The present invention can also be embodied in the form of program code, for example, whether stored in a storage medium, loaded into and/or executed by a machine, or transmitted over some transmission medium or carrier, such as over electrical wiring or cabling, through fiber optics, or via electromagnetic radiation, wherein, when the program code is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention. When implemented on a general-purpose processor, the program code segments combine with the processor to provide a unique device that operates analogously to specific logic circuits. Unless explicitly stated otherwise, each numerical value and range should be interpreted as being approximate as if the word “about” or “approximately” preceded the value of the value or range. 
         [0061]    It will be further understood that various changes in the details, materials, and arrangements of the parts which have been described and illustrated in order to explain the nature of this invention may be made by those skilled in the art without departing from the scope of the invention as expressed in the following claims. 
         [0062]    It should be understood that the steps of the exemplary methods set forth herein are not necessarily required to be performed in the order described, and the order of the steps of such methods should be understood to be merely exemplary. Likewise, additional steps may be included in such methods, and certain steps may be omitted or combined, in methods consistent with various embodiments of the present invention. 
         [0063]    Although the elements in the following method claims, if any, are recited in a particular sequence with corresponding labeling, unless the claim recitations otherwise imply a particular sequence for implementing some or all of those elements, those elements are not necessarily intended to be limited to being implemented in that particular sequence. 
         [0064]    Reference herein to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the invention. The appearances of the phrase “in one embodiment” in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments necessarily mutually exclusive of other embodiments. The same applies to the term “implementation.”