Massive Algorithms: Approximate Algorithm

Showing posts with label Approximate Algorithm. Show all posts

HyperLogLog

https://en.wikipedia.org/wiki/HyperLogLog
HyperLogLog is an algorithm for the count-distinct problem, approximating the number of distinct elements in a multiset (the cardinality).

http://highscalability.com/blog/2012/4/5/big-data-counting-how-to-count-a-billion-distinct-objects-us.html?currentPage=2

One common approach to this problem is the use of bitmaps. Bitmaps can be used to quickly and accurately get the cardinality of a given input. The basic idea with a bitmap is mapping the input dataset to a bit field using a hash function where each input element uniquely maps to one of the bits in the field. This produces zero collisions, and reduces the space required to count each unique element to 1 bit. While bitmaps drastically reduce the space requirements from the naive set implementation described above they are still problematic when the cardinality is very high and/or you have a very large number of different sets to count. For example, if we want to count to one billion using a bitmap you will need one billion bits, or roughly 120 megabytes for each counter. Sparse bitmaps can be compressed in order to gain space efficiency, but that is not always helpful.

http://blog.mparticle.com/a-must-know-for-data-scientists-hyperloglog-algorithm/

Hyperloglog is a space-efficient algorithm for accurate cardinality estimations. Nowadays a lot of data products use it, including Redis, AWS Redshift, and Druid. Redis’s implementation of HLL uses at most 12Kb of memory to estimate the cardinality of practically any set.

The basic idea of HLL is as follows. Imagine you flip a coin for 100 times and count the number of consecutive heads before the first tail. Let’s call this one experiment. You perform a few experiments, and you may get the following series (H for head and T for tail):

experiment 1: HHTHTTHH….

experiment 2: HTHHHTTT….

experiment 3: TTHTHHHT….

The number of consecutive heads at the beginning of the series is 2, 1, 0, respectively, marked in red. If you only do a small number of experiments, the chance is that the max number of consecutive heads is small. However, if you have patience to perform a lot of experiments, you may get a large number of consecutive heads from at least one experiment.

HLL essentially hashes every element in a set, counts the number of consecutive leading 0’s from each hash, and estimates the cardinality based on the largest count of consecutive leading 0’s out of the hashes.

Estimate the cardinality of union of multiple sets. It is natural to combine multiple HLL’s; simply take the largest count of consecutive leading 0’s from all the HLL’s.
Estimate the overlap of two sets. Since |A ∩ B| = |A| + |B| – |A ∪ B|, the overlap of two sets can be calculated from the cardinality of each set and the cardinality of their union.

http://research.neustar.biz/2012/10/25/sketch-of-the-day-hyperloglog-cornerstone-of-a-big-data-infrastructure/

Bit-pattern observables: these are based on certain patterns of bits occurring at the beginning of the (binary) S-values. For instance, observing in the stream S at the beginning of a string a bit- pattern is more or less a likely indication that the cardinality n of S is at least $2^\rho$ .

Order statistics observables: these are based on order statistics, like the smallest (real) values, that appear in S. For instance, if X = min(S), we may legitimately hope that n is roughly of the order of 1/X…

http://opensourceconnections.com/blog/2015/02/04/its-log-its-log-its-big-its-hyper-its-good/

https://pkghosh.wordpress.com/2014/11/16/counting-unique-mobile-app-users-with-hyperloglog/

HyperLogLog is based on analyzing some bit patterns in the hashed value of an item. We look at the length of the sequence of most significant zero bits. The maximum length among such zero bit sequences from all the hashed values is indicative of the unique item count.

In reality, to improve the quality of the result, multiple independent hash functions are used and the longest sequence zero bits resulting from each hash function is used to produce the final averaged unique count value.

Libraries

Twitter's algebird

stream-lib library (stream-lib) from ClearSpring

Java code:

http://facebook.github.io/jcommon/stats/jacoco/com.facebook.stats.cardinality/HyperLogLog.java.html

http://antirez.com/news/75

Steiner Tree Problem - GeeksforGeeks

Steiner Tree Problem - GeeksforGeeks
What is Steiner Tree?
Given a graph and a subset of vertices in the graph, a steiner tree spans though the given subset. The Steiner Tree may contain some vertices which are not in given subset but are used to connect the vertices of subset.
The given set of vertices is called Terminal Vertices and other vertices that are used to construct Steiner tree are called Steiner vertices.

If given subset (or terminal) vertices is equal to set of all vertices in Steiner Tree problem, then the problem becomes Minimum Spanning Tree problem. And if the given subset contains only two vertices, then it shortest path problem between two vertices.

Shortest Path based Approximate Algorithm

1) Start with a subtree T consisting of 
   one given terminal vertex
2) While T does not span all terminals
   a) Select a terminal x not in T that is closest 
      to a vertex in T.
   b) Add to T the shortest path that connects x with T

The above algorithm is (2-2/n) approximate, i.e., it guarantees that solution produced by this algorithm is not more than this ration of optimized solution for a given graph with n vertices. There are better algorithms also that provide better ratio. Refer below reference for more details.

Read full article from Steiner Tree Problem - GeeksforGeeks

Count-Min Sketch - Approximate Algorithm

http://lkozma.net/blog/sketching-data-structures/
The Count-Min (CM) sketch is less known than the Bloom filter, but it is somewhat similar (especially to the counting variants of the Bloom filter).

The problem here is to store a numerical value associated with each element, say the number of occurrences of the element in a stream (for example when counting accesses from different IP addresses to a server). Surprisingly, this can be done using less space than the number of elements, with the trade-off that the result can be slightly off sometimes, but mostly on the small values. Again, the parameters of the data structure can be chosen such as to obtain a desired accuracy.

CM works as follows: we have k different hash functions and kdifferent tables which are indexed by the outputs of these functions (note that the Bloom filter can be implemented in this way as well). The fields in the tables are now integer values. Initially we have all fields set to 0 (all unseen elements have count 0). When we increase the count of an element, we increment all the corresponding k fields in the different tables (given by the hash values of the element). If a decrease operation is allowed (which makes things more difficult), we similarly subtract a value from all k elements.

To obtain the count of an element, we take the minimum of the kfields that correspond to that element (as given by the hashes). This makes intuitive sense. Out of the k values, probably some have been incremented on other elements also (if there were collisions on the hash values). However, if not all k fields have been returned by the hash functions on other elements, the minimum will give the correct value.

we want to notice if an IP address is responsible for a lot of traffic (to further investigate if there is a problem or some kind of attack). The CM structure allows us to do this without storing a record for each address. When we increment the fields corresponding to an address, simultaneously we check if the minimum is above some threshold and we do some costly operation if it is (which might be a false alert). On the other hand, the real count can never be larger than the reported number, so if the minimum is a small number, we don’t have to do anything (this holds for the presented simple variant that does not allow decreases). As the example shows, CM sketch is most useful for detecting “heavy hitters” in a stream.

Java code:
https://github.com/addthis/stream-lib/blob/master/src/main/java/com/clearspring/analytics/stream/frequency/CountMinSketch.java
http://www.sanfoundry.com/java-program-implement-count-min-sketch/

```
class CountMinSketch
```
```
{
```
```
    private int[] h1;
```
```
    private int[] h2;
```
```
    private int[] h3;
```
```
    private int size;
```

    private static int DEFAULT_SIZE = 11;

```
 
```
```
    /** Constructor **/
```
```
    public CountMinSketch()
```
```
    {
```
```
        size = DEFAULT_SIZE;
```
```
        h1 = new int[ size ];
```
```
        h2 = new int[ size ];
```
```
        h3 = new int[ size ];
```
```
    }
```

    /** Function to clear al counters **/

```
    public void clear()
```
```
    {
```
```
        size = DEFAULT_SIZE;
```
```
        h1 = new int[ size ];
```
```
        h2 = new int[ size ];
```
```
        h3 = new int[ size ];
```
```
    }
```
```
    /** Function to insert value **/
```
```
    public void insert(int val)
```
```
    {
```
```
        int hash1 = hashFunc1(val);
```
```
        int hash2 = hashFunc2(val);
```
```
        int hash3 = hashFunc3(val);
```
```
        /** increment counters **/
```
```
        h1[ hash1 ]++;
```
```
        h2[ hash2 ]++;
```
```
        h3[ hash3 ]++;
```
```
    }
```

    /** Function to get sketch count **/

```
    public int sketchCount(int val)
```
```
    {
```
```
        int hash1 = hashFunc1(val);
```
```
        int hash2 = hashFunc2(val);
```
```
        int hash3 = hashFunc3(val);
```

        return min( h1[ hash1 ], h2[ hash2 ], h3[ hash3 ] );

```
    }
```

    private int min(int a, int b, int c)

```
    {
```
```
        int min = a;
```
```
        if (b < min)
```
```
            min = b;
```
```
        if (c < min)
```
```
            min = c;
```
```
        return min;
```
```
    }
```
```
    /** Hash function 1 **/
```
```
    private int hashFunc1(int val)
```
```
    {
```
```
        return val % size;
```
```
    }
```
```
    /** Hash function 2 **/
```
```
    private int hashFunc2(int val)
```
```
    {
```

        return ((val * (val + 3)) % size);

```
    }
```
```
    /** Hash function 3 **/
```
```
    private int hashFunc3(int val)
```
```
    {
```
```
        return (size - 1) - val % size;
```
```
    }   
```
```
}
```

Ruminations of a Programmer: Count-Min Sketch - A Data Structure for Stream Mining Applications
The idea is quite simple and the data structure is based on probabilistic algorithms to serve various types of queries on streaming data. The data structure is parameterized by two factors - ε and δ, where the error in answering the query is within a factor of ε with probability δ. So you can tune these parameters based on the space that you can afford and accordingly amortize the accuracy of results that the data structure can serve you.

https://dzone.com/articles/count-min-sketch-data
One widely used technique for storing a subset of data is through Random Sampling, where the data stored is selected through some stochastic mechanism.

https://github.com/addthis/stream-lib/blob/master/src/main/java/com/clearspring/analytics/stream/frequency/CountMinSketch.java
Read full article from Ruminations of a Programmer: Count-Min Sketch - A Data Structure for Stream Mining Applications

HyperLogLog

Steiner Tree Problem - GeeksforGeeks

Count-Min Sketch - Approximate Algorithm

Labels

Popular Posts