« 反转词元过滤器 Snowball 词元过滤器 »
Elastic 文档 ›Elasticsearch 指南 [8.17] ›文本分析 ›词元过滤器参考

Shingle 词元过滤器

编辑

Shingle 词元过滤器

编辑

通过连接相邻的词元，将 shingles 或词 n-gram 添加到词元流中。默认情况下，shingle 词元过滤器输出双词 shingles 和 unigrams。

例如，许多分词器将 the lazy dog 转换为 [ the, lazy, dog ]。你可以使用 shingle 过滤器将双词 shingles 添加到此流中： [ the, the lazy, lazy, lazy dog, dog ]。

Shingles 通常用于帮助加速短语查询，例如 match_phrase。我们建议你使用相应的 text 字段上的 index-phrases 映射参数，而不是使用 shingles 过滤器创建 shingles。

此过滤器使用 Lucene 的 ShingleFilter。

示例

编辑

以下 analyze API 请求使用 shingle 过滤器将双词 shingles 添加到 quick brown fox jumps 的词元流中。

resp = client.indices.analyze(
    tokenizer="whitespace",
    filter=[
        "shingle"
    ],
    text="quick brown fox jumps",
)
print(resp)
response = client.indices.analyze(
  body: {
    tokenizer: 'whitespace',
    filter: [
      'shingle'
    ],
    text: 'quick brown fox jumps'
  }
)
puts response
const response = await client.indices.analyze({
  tokenizer: "whitespace",
  filter: ["shingle"],
  text: "quick brown fox jumps",
});
console.log(response);
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [ "shingle" ],
  "text": "quick brown fox jumps"
}

该过滤器产生以下词元

[ quick, quick brown, brown, brown fox, fox, fox jumps, jumps ]

要生成 2-3 个单词的 shingles，请将以下参数添加到 analyze API 请求中

  • min_shingle_size: 2
  • max_shingle_size: 3
resp = client.indices.analyze(
    tokenizer="whitespace",
    filter=[
        {
            "type": "shingle",
            "min_shingle_size": 2,
            "max_shingle_size": 3
        }
    ],
    text="quick brown fox jumps",
)
print(resp)
response = client.indices.analyze(
  body: {
    tokenizer: 'whitespace',
    filter: [
      {
        type: 'shingle',
        min_shingle_size: 2,
        max_shingle_size: 3
      }
    ],
    text: 'quick brown fox jumps'
  }
)
puts response
const response = await client.indices.analyze({
  tokenizer: "whitespace",
  filter: [
    {
      type: "shingle",
      min_shingle_size: 2,
      max_shingle_size: 3,
    },
  ],
  text: "quick brown fox jumps",
});
console.log(response);
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "shingle",
      "min_shingle_size": 2,
      "max_shingle_size": 3
    }
  ],
  "text": "quick brown fox jumps"
}

该过滤器产生以下词元

[ quick, quick brown, quick brown fox, brown, brown fox, brown fox jumps, fox, fox jumps, jumps ]

要仅在输出中包含 shingles，请将 output_unigrams 参数设置为 false。

resp = client.indices.analyze(
    tokenizer="whitespace",
    filter=[
        {
            "type": "shingle",
            "min_shingle_size": 2,
            "max_shingle_size": 3,
            "output_unigrams": False
        }
    ],
    text="quick brown fox jumps",
)
print(resp)
response = client.indices.analyze(
  body: {
    tokenizer: 'whitespace',
    filter: [
      {
        type: 'shingle',
        min_shingle_size: 2,
        max_shingle_size: 3,
        output_unigrams: false
      }
    ],
    text: 'quick brown fox jumps'
  }
)
puts response
const response = await client.indices.analyze({
  tokenizer: "whitespace",
  filter: [
    {
      type: "shingle",
      min_shingle_size: 2,
      max_shingle_size: 3,
      output_unigrams: false,
    },
  ],
  text: "quick brown fox jumps",
});
console.log(response);
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "shingle",
      "min_shingle_size": 2,
      "max_shingle_size": 3,
      "output_unigrams": false
    }
  ],
  "text": "quick brown fox jumps"
}

该过滤器产生以下词元

[ quick brown, quick brown fox, brown fox, brown fox jumps, fox jumps ]

添加到分析器

编辑

以下 create index API 请求使用 shingle 过滤器配置新的 自定义分析器。

resp = client.indices.create(
    index="my-index-000001",
    settings={
        "analysis": {
            "analyzer": {
                "standard_shingle": {
                    "tokenizer": "standard",
                    "filter": [
                        "shingle"
                    ]
                }
            }
        }
    },
)
print(resp)
response = client.indices.create(
  index: 'my-index-000001',
  body: {
    settings: {
      analysis: {
        analyzer: {
          standard_shingle: {
            tokenizer: 'standard',
            filter: [
              'shingle'
            ]
          }
        }
      }
    }
  }
)
puts response
const response = await client.indices.create({
  index: "my-index-000001",
  settings: {
    analysis: {
      analyzer: {
        standard_shingle: {
          tokenizer: "standard",
          filter: ["shingle"],
        },
      },
    },
  },
});
console.log(response);
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_shingle": {
          "tokenizer": "standard",
          "filter": [ "shingle" ]
        }
      }
    }
  }
}

可配置参数

编辑
max_shingle_size

(可选，整数) 创建 shingles 时要连接的最大词元数。默认为 2。

此值不能低于 min_shingle_size 参数，后者的默认值为 2。此值与 min_shingle_size 参数之间的差值不能超过 index.max_shingle_diff 索引级设置，该设置的默认值为 3。

min_shingle_size

(可选，整数) 创建 shingles 时要连接的最小词元数。默认为 2。

此值不能超过 max_shingle_size 参数，后者的默认值为 2。max_shingle_size 参数和此值之间的差值不能超过 index.max_shingle_diff 索引级设置，该设置的默认值为 3。

output_unigrams
(可选，布尔值) 如果为 true，则输出包括原始输入词元。如果为 false，则输出仅包括 shingles；原始输入词元被删除。默认为 true。
output_unigrams_if_no_shingles

如果为 true，则仅在未生成 shingles 时，输出才包括原始输入词元；如果生成了 shingles，则输出仅包括 shingles。默认为 false。

如果此参数和 output_unigrams 参数均为 true，则仅使用 output_unigrams 参数。

token_separator
(可选，字符串) 用于连接相邻词元以形成 shingle 的分隔符。默认为空格 (" ")。
filler_token

(可选，字符串) 在 shingles 中用作不包含词元的空位置的替代字符串。此填充词元仅在 shingles 中使用，而不是在原始 unigrams 中使用。默认为下划线 (_)。

某些词元过滤器（例如 stop 过滤器）会在删除位置增量大于 1 的停用词时创建空位置。

示例

在以下 analyze API 请求中，stop 过滤器从 fox jumps a lazy dog 中删除停用词 a，从而创建一个空位置。后续的 shingle 过滤器在 shingles 中将此空位置替换为加号 (+)。

resp = client.indices.analyze(
    tokenizer="whitespace",
    filter=[
        {
            "type": "stop",
            "stopwords": [
                "a"
            ]
        },
        {
            "type": "shingle",
            "filler_token": "+"
        }
    ],
    text="fox jumps a lazy dog",
)
print(resp)
response = client.indices.analyze(
  body: {
    tokenizer: 'whitespace',
    filter: [
      {
        type: 'stop',
        stopwords: [
          'a'
        ]
      },
      {
        type: 'shingle',
        filler_token: '+'
      }
    ],
    text: 'fox jumps a lazy dog'
  }
)
puts response
const response = await client.indices.analyze({
  tokenizer: "whitespace",
  filter: [
    {
      type: "stop",
      stopwords: ["a"],
    },
    {
      type: "shingle",
      filler_token: "+",
    },
  ],
  text: "fox jumps a lazy dog",
});
console.log(response);
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "stop",
      "stopwords": [ "a" ]
    },
    {
      "type": "shingle",
      "filler_token": "+"
    }
  ],
  "text": "fox jumps a lazy dog"
}

该过滤器产生以下词元

[ fox, fox jumps, jumps, jumps +, + lazy, lazy, lazy dog, dog ]

自定义

编辑

要自定义 shingle 过滤器，请复制它以创建新的自定义词元过滤器的基础。你可以使用其可配置参数修改过滤器。

例如，以下 create index API 请求使用自定义 shingle 过滤器 my_shingle_filter 配置新的 自定义分析器。

my_shingle_filter 过滤器使用 min_shingle_size 为 2 和 max_shingle_size 为 5，这意味着它会生成 2-5 个单词的 shingles。该过滤器还包含一个 output_unigrams 参数，其值为 false，这意味着输出中仅包含 shingles。

resp = client.indices.create(
    index="my-index-000001",
    settings={
        "analysis": {
            "analyzer": {
                "en": {
                    "tokenizer": "standard",
                    "filter": [
                        "my_shingle_filter"
                    ]
                }
            },
            "filter": {
                "my_shingle_filter": {
                    "type": "shingle",
                    "min_shingle_size": 2,
                    "max_shingle_size": 5,
                    "output_unigrams": False
                }
            }
        }
    },
)
print(resp)
response = client.indices.create(
  index: 'my-index-000001',
  body: {
    settings: {
      analysis: {
        analyzer: {
          en: {
            tokenizer: 'standard',
            filter: [
              'my_shingle_filter'
            ]
          }
        },
        filter: {
          my_shingle_filter: {
            type: 'shingle',
            min_shingle_size: 2,
            max_shingle_size: 5,
            output_unigrams: false
          }
        }
      }
    }
  }
)
puts response
const response = await client.indices.create({
  index: "my-index-000001",
  settings: {
    analysis: {
      analyzer: {
        en: {
          tokenizer: "standard",
          filter: ["my_shingle_filter"],
        },
      },
      filter: {
        my_shingle_filter: {
          type: "shingle",
          min_shingle_size: 2,
          max_shingle_size: 5,
          output_unigrams: false,
        },
      },
    },
  },
});
console.log(response);
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "en": {
          "tokenizer": "standard",
          "filter": [ "my_shingle_filter" ]
        }
      },
      "filter": {
        "my_shingle_filter": {
          "type": "shingle",
          "min_shingle_size": 2,
          "max_shingle_size": 5,
          "output_unigrams": false
        }
      }
    }
  }
}
« 反转词元过滤器 Snowball 词元过滤器 »