Significant text aggregation

The significant_text aggregation intentionally does not support the addition of child aggregations because:

The volume of candidate terms is generally very high and these are pruned heavily before the final results are returned. Supporting child aggregations would generate additional churn and be inefficient. Clients can always take the heavily-trimmed set of results from a significant_text request and make a subsequent follow-up query using a terms aggregation with an include clause and child aggregations to perform further analysis of selected keywords in a more efficient fashion.

The significant_text aggregation currently also cannot be used with text fields in nested objects, because it works with the document JSON source. This makes this feature inefficient when matching nested docs from stored JSON given a matching Lucene docID.

The counts of how many documents contain a term provided in results are based on summing the samples returned from each shard and as such may be:

Like most design decisions, this is the basis of a trade-off in which we have chosen to provide fast performance at the cost of some (typically small) inaccuracies. However, the size and shard size settings covered in the next section provide tools to help control the accuracy levels.

This aggregation supports the same scoring heuristics (JLH, mutual_information, gnd, chi_square etc) as the significant terms aggregation

The size parameter can be set to define how many term buckets should be returned out of the overall terms list. By default, the node coordinating the search process will request each shard to provide its own top term buckets and once all shards respond, it will reduce the results to the final list that will then be returned to the client. If the number of unique terms is greater than size, the returned list can be slightly off and not accurate (it could be that the term counts are slightly off and it could even be that a term that should have been in the top size buckets was not returned).

To ensure better accuracy a multiple of the final size is used as the number of terms to request from each shard (2 * (size * 1.5 + 10)). To take manual control of this setting the shard_size parameter can be used to control the volumes of candidate terms produced by each shard.

Low-frequency terms can turn out to be the most interesting ones once all results are combined so the significant_terms aggregation can produce higher-quality results when the shard_size parameter is set to values significantly higher than the size setting. This ensures that a bigger volume of promising candidate terms are given a consolidated review by the reducing node before the final selection. Obviously large candidate term lists will cause extra network traffic and RAM usage so this is quality/cost trade off that needs to be balanced. If shard_size is set to -1 (the default) then shard_size will be automatically estimated based on the number of shards and the size parameter.

It is possible to only return terms that match more than a configured number of hits using the min_doc_count option. The Default value is 3.

Terms that score highly will be collected on a shard level and merged with the terms collected from other shards in a second step. However, the shard does not have the information about the global term frequencies available. The decision if a term is added to a candidate list depends only on the score computed on the shard using local shard frequencies, not the global frequencies of the word. The min_doc_count criterion is only applied after merging local terms statistics of all shards. In a way the decision to add the term as a candidate is made without being very certain about if the term will actually reach the required min_doc_count. This might cause many (globally) high frequent terms to be missing in the final result if low frequent but high scoring terms populated the candidate lists. To avoid this, the shard_size parameter can be increased to allow more candidate terms on the shards. However, this increases memory consumption and network traffic.

The default source of statistical information for background term frequencies is the entire index and this scope can be narrowed through the use of a background_filter to focus in on significant terms within a narrower context:

resp = client.search(
    index="news",
    query={
        "match": {
            "content": "madrid"
        }
    },
    aggs={
        "tags": {
            "significant_text": {
                "field": "content",
                "background_filter": {
                    "term": {
                        "content": "spain"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'news',
  body: {
    query: {
      match: {
        content: 'madrid'
      }
    },
    aggregations: {
      tags: {
        significant_text: {
          field: 'content',
          background_filter: {
            term: {
              content: 'spain'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "news",
  query: {
    match: {
      content: "madrid",
    },
  },
  aggs: {
    tags: {
      significant_text: {
        field: "content",
        background_filter: {
          term: {
            content: "spain",
          },
        },
      },
    },
  },
});
console.log(response);

GET news/_search
{
  "query": {
    "match": {
      "content": "madrid"
    }
  },
  "aggs": {
    "tags": {
      "significant_text": {
        "field": "content",
        "background_filter": {
          "term": { "content": "spain" }
        }
      }
    }
  }
}

The above filter would help focus in on terms that were peculiar to the city of Madrid rather than revealing terms like "Spanish" that are unusual in the full index’s worldwide context but commonplace in the subset of documents containing the word "Spain".

Ordinarily the indexed field name and the original JSON field being retrieved share the same name. However with more complex field mappings using features like copy_to the source JSON field(s) and the indexed field being aggregated can differ. In these cases it is possible to list the JSON _source fields from which text will be analyzed using the source_fields parameter:

resp = client.search(
    index="news",
    query={
        "match": {
            "custom_all": "elasticsearch"
        }
    },
    aggs={
        "tags": {
            "significant_text": {
                "field": "custom_all",
                "source_fields": [
                    "content",
                    "title"
                ]
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'news',
  body: {
    query: {
      match: {
        custom_all: 'elasticsearch'
      }
    },
    aggregations: {
      tags: {
        significant_text: {
          field: 'custom_all',
          source_fields: [
            'content',
            'title'
          ]
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "news",
  query: {
    match: {
      custom_all: "elasticsearch",
    },
  },
  aggs: {
    tags: {
      significant_text: {
        field: "custom_all",
        source_fields: ["content", "title"],
      },
    },
  },
});
console.log(response);

GET news/_search
{
  "query": {
    "match": {
      "custom_all": "elasticsearch"
    }
  },
  "aggs": {
    "tags": {
      "significant_text": {
        "field": "custom_all",
        "source_fields": [ "content", "title" ]
      }
    }
  }
}

It is possible (although rarely required) to filter the values for which buckets will be created. This can be done using the include and exclude parameters which are based on a regular expression string or arrays of exact terms. This functionality mirrors the features described in the terms aggregation documentation.