Approximations with Theta sketches

    Imagine you are interested in the number of visitors that watched episodes of a TV show. Let’s say you found that at a given day, 1000 unique visitors watched the first episode, and 800 visitors watched the second episode. You may want to explore further trends, for example:

    • How many visitors watched both episodes?
    • How many visitors are there that watched at least one of the episodes?
    • How many visitors watched episode 1 but not episode 2?

    There is no way to answer these questions by just looking at the aggregated numbers. You would have to go back to the detail data and scan every single row. If the data volume is high enough, this may take a very long time, meaning that an interactive data exploration is not possible.

    An additional nuisance is that unique counts don’t work well with rollups. For this example, it would be great if you could have just one row of data per 15 minute interval, show, and episode. After all, you are not interested in the individual user IDs, just the unique counts.

    Is there a way to avoid crunching the detail data every single time, and maybe even enable rollup? Enter Theta sketches.

    Use Theta sketches for fast approximation with set operations

    Use Theta sketches to obtain a fast approximate estimate for the distinct count of values used to build the sketches. Theta sketches are a probabilistic data structure to enable approximate analysis of big data with known error distributions. Druid’s implementation relies on the library.

    The following properties describe Theta sketches:

    • Similar to other sketches, Theta sketches are mergeable. This means you can work with rolled up data and merge the sketches over various time intervals. Thus, you can take advantage of Druid’s rollup feature.
    • Specific to sketches supported in Druid, Theta sketches support set operations. Given two Theta sketches over subsets of data, you can compute the union, intersection, or set difference of the two subsets. This enables you to answer questions like the number of visitors that watched a specific combination of episodes from the example.

    In this tutorial, you will learn how to do the following:

    • Create Theta sketches from your input data at ingestion time.
    • Execute distinct count and set operation queries on the Theta sketches to explore the questions presented earlier.

    For this tutorial, you should have already downloaded Druid as described in the and have it running on your local machine. It will also be helpful to have finished Tutorial: Loading a file and .

    This tutorial works with the following data:

    • date: a timestamp. In this case it’s just dates but as mentioned earlier, a finer granularity makes sense in real life.
    • uid: a user ID
    • show: name of a TV show
    • episode: episode identifier

    Ingest data using Theta sketches

    1. Navigate to the Load data wizard in the web console.
    2. Select as the data source and paste the given data:

    1. Leave the source type as inline and click Apply and Next: Parse data.
    2. Parse the data as CSV, with included headers:

    Parse raw data

    1. Accept the default values in the Parse time, Transform, and Filter stages.
    2. In the Configure schema stage, enable rollup and confirm your choice in the dialog. Then set the query granularity to day.

    1. Add the Theta sketch during this stage. Select Add metric.
    2. Define the new metric as a Theta sketch with the following details:
      • Name: theta_uid
      • Type: thetaSketch
      • Field name: uid
      • Size: Accept the default value, 16384.
      • Is input theta sketch: Accept the default value, False.

    Create Theta sketch metric

    2. You are not interested in individual user ID’s, only the unique counts. Right now, uid is still in the data model. To remove it, click on the uid column in the data model and delete it using the trashcan icon on the right:

    1. For the remaining stages of the Load data wizard, set the following options:
      • Partition: Set Segment granularity to day.
      • Tune: Leave the default options.
      • Publish: Set the datasource name to ts_tutorial.

    On the Edit spec page, your final input spec should match the following:

    1. {
    2.   "type": "index_parallel",
    3.     "ioConfig": {
    4.       "type": "index_parallel",
    5.       "inputSource": {
    6.         "type": "inline",
    7.         "data": "date,uid,show,episode\n2022-05-19,alice,Game of Thrones,S1E1\n2022-05-19,alice,Game of Thrones,S1E2\n2022-05-19,alice,Game of Thrones,S1E1\n2022-05-19,bob,Bridgerton,S1E1\n2022-05-20,alice,Game of Thrones,S1E1\n2022-05-20,carol,Bridgerton,S1E2\n2022-05-20,dan,Bridgerton,S1E1\n2022-05-21,alice,Game of Thrones,S1E1\n2022-05-21,carol,Bridgerton,S1E1\n2022-05-21,erin,Game of Thrones,S1E1\n2022-05-21,alice,Bridgerton,S1E1\n2022-05-22,bob,Game of Thrones,S1E1\n2022-05-22,bob,Bridgerton,S1E1\n2022-05-22,carol,Bridgerton,S1E2\n2022-05-22,bob,Bridgerton,S1E1\n2022-05-22,erin,Game of Thrones,S1E1\n2022-05-22,erin,Bridgerton,S1E2\n2022-05-23,erin,Game of Thrones,S1E1\n2022-05-23,alice,Game of Thrones,S1E1"
    8.       },
    9.       "inputFormat": {
    10.         "type": "csv",
    11.         "findColumnsFromHeader": true
    12.       }
    13.     },
    14.     "tuningConfig": {
    15.       "type": "index_parallel",
    16.       "partitionsSpec": {
    17.         "type": "hashed"
    18.       },
    19.       "forceGuaranteedRollup": true
    20.     },
    21.     "dataSchema": {
    22.       "dataSource": "ts_tutorial",
    24.         "column": "date",
    25.         "format": "auto"
    26.       },
    27.       "dimensionsSpec": {
    28.         "dimensions": [
    29.           "show",
    30.           "episode"
    31.         ]
    32.       },
    33.       "granularitySpec": {
    34.         "queryGranularity": "day",
    35.         "rollup": true,
    36.         "segmentGranularity": "day"
    37.       },
    38.       "metricsSpec": [
    39.         {
    40.           "name": "count",
    41.           "type": "count"
    42.         },
    43.         {
    44.           "type": "thetaSketch",
    45.           "name": "theta_uid",
    46.         }
    47.       ]
    48.     }
    49.   }
    50. }

    Notice the theta_uid object in the metricsSpec list, that defines the thetaSketch aggregator on the uid column during ingestion.

    Click Submit to start the ingestion.

    Calculating a unique count estimate from a Theta sketch column involves the following steps:

    1. Merge the Theta sketches in the column by means of the DS_THETA aggregator function in Druid SQL.
    2. Retrieve the estimate from the merged sketch with the function.

    Between steps 1 and 2, you can apply set functions as demonstrated later in Set operations.

    Let’s first see what the data looks like in Druid. Run the following SQL statement in the query editor:

    1. SELECT * FROM ts_tutorial

    View data with SELECT all query

    The Theta sketch column appears as a Base64-encoded string; behind it is a bitmap.

    The following query to compute the distinct counts of user IDs uses APPROX_COUNT_DISTINCT_DS_THETA and groups by the other dimensions:

    In the preceding query, APPROX_COUNT_DISTINCT_DS_THETA is equivalent to calling DS_THETA and THETA_SKETCH_ESIMATE as follows:

    1. SELECT __time,
    2.        "show", 
    3.        "episode",
    4.        THETA_SKETCH_ESTIMATE(DS_THETA(theta_uid)) AS users
    5. FROM   ts_tutorial
    6. GROUP  BY 1, 2, 3
    • DS_THETA: Creates a new Theta sketch from the column of Theta sketches
    • THETA_SKETCH_ESTIMATE: Calculates the distinct count estimate from the output of DS_THETA

    Druid has the capability to use . This means you can include a WHERE clause in the SELECT part of the query.

    As an example, query the total unique users that watched Bridgerton:

    1. SELECT THETA_SKETCH_ESTIMATE(
    2.          DS_THETA(theta_uid) FILTER(WHERE "show" = 'Bridgerton')
    3.        ) AS users
    4. FROM ts_tutorial

    Count distinct with Theta sketches and filters

    You can use this capability of filtering in the aggregator, together with set operations, to finally answer the questions from the introduction.

    How many users watched both episodes of Bridgerton? Use THETA_SKETCH_INTERSECT to compute the unique count of the intersection of two (or more) segments:

    Again, the set function is spliced in between the aggregator and the estimator.

    Likewise, use THETA_SKETCH_UNION to find the number of visitors that watched any of the episodes:

    1. SELECT THETA_SKETCH_ESTIMATE(
    2.          THETA_SKETCH_UNION(
    3.            DS_THETA(theta_uid) FILTER(WHERE "show" = 'Bridgerton' AND "episode" = 'S1E1'),
    4.            DS_THETA(theta_uid) FILTER(WHERE "show" = 'Bridgerton' AND "episode" = 'S1E2')
    5.          )
    6.        ) AS users
    7. FROM ts_tutorial

    Count distinct with Theta sketches, filters, and set operations

    And finally, there is THETA_SKETCH_NOT which computes the set difference of two or more segments. The result describes how many visitors watched episode 1 of Bridgerton but not episode 2.

    1. SELECT THETA_SKETCH_ESTIMATE(
    2.          THETA_SKETCH_NOT(
    3.            DS_THETA(theta_uid) FILTER(WHERE "show" = 'Bridgerton' AND "episode" = 'S1E1'),
    4.            DS_THETA(theta_uid) FILTER(WHERE "show" = 'Bridgerton' AND "episode" = 'S1E2')
    5.          )
    6.        ) AS users

    Conclusions

    • Counting distinct things for large data sets can be done with Theta sketches in Apache Druid.
    • This allows us to use rollup and discard the individual values, just retaining statistical approximations in the sketches.
    • With Theta sketch set operations, affinity analysis is easier, for example, to answer questions such as which segments correlate or overlap by how much.

    See the following topics for more information:

    • for reference on ingestion and native queries on Theta sketches in Druid.
    • Theta sketch scalar functions and for Theta sketch functions in Druid SQL queries.
    • Sketches for high cardinality columns for Druid schema design involving sketches.
    • for more information about the DataSketches extension in Druid as well as other available sketches.
    • The accuracy of queries using Theta sketches is governed by the size k of the Theta sketch and by the operations you perform. See more details in the Apache DataSketches documentation.

    Acknowledgments

    1. Why 15 minutes and not just 1 hour? Intervals of 15 minutes work better with international timezones because those are not always aligned by hour. India, for instance, is 30 minutes off, and Nepal is even 45 minutes off. With 15 minute aggregates, you can get hourly sums for any of those timezones, too! ↩