分词过滤器参考

edit

Token filters 接受来自一个 tokenizer 的 token 流,并且可以修改 tokens (例如转换为小写),删除 tokens(例如移除停用词) 或添加 tokens(例如同义词)。

Elasticsearch 有许多内置的 token 过滤器,您可以使用这些过滤器来构建 自定义分析器

撇号分词过滤器

edit

删除所有撇号后的字符,包括撇号本身。

此过滤器包含在 Elasticsearch 的内置 土耳其语分析器中。它使用 Lucene 的 ApostropheFilter,该过滤器是为土耳其语构建的。

示例

edit

以下analyze API请求展示了撇号标记过滤器的工作原理。

GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["apostrophe"],
  "text" : "Istanbul'a veya Istanbul'dan"
}

过滤器生成以下标记:

[ Istanbul, veya, Istanbul ]

添加到分析器

edit

以下创建索引 API请求使用撇号标记过滤器来配置一个新的 自定义分析器

PUT /apostrophe_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_apostrophe": {
          "tokenizer": "standard",
          "filter": [ "apostrophe" ]
        }
      }
    }
  }
}

ASCII折叠分词过滤器

edit

将不在基本拉丁 Unicode 块(前 127 个 ASCII 字符)中的字母、数字和符号字符转换为其 ASCII 等效字符(如果存在)。例如,该过滤器将 à 更改为 a

此过滤器使用 Lucene 的 ASCIIFoldingFilter

示例

edit

以下analyze API请求使用asciifolding过滤器来去除açaí à la carte中的变音符号:

GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["asciifolding"],
  "text" : "açaí à la carte"
}

过滤器生成以下标记:

[ acai, a, la, carte ]

添加到分析器

edit

以下创建索引 API请求使用asciifolding过滤器来配置一个新的自定义分析器

PUT /asciifold_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_asciifolding": {
          "tokenizer": "standard",
          "filter": [ "asciifolding" ]
        }
      }
    }
  }
}

可配置参数

edit
preserve_original
(可选, 布尔值) 如果为true,则同时输出原始标记和折叠后的标记。 默认为false

自定义

edit

要自定义 asciifolding 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建一个自定义的 asciifolding 过滤器,并将 preserve_original 设置为 true:

PUT /asciifold_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_asciifolding": {
          "tokenizer": "standard",
          "filter": [ "my_ascii_folding" ]
        }
      },
      "filter": {
        "my_ascii_folding": {
          "type": "asciifolding",
          "preserve_original": true
        }
      }
    }
  }
}

CJK 双字节分词过滤器

edit

将CJK(中文、日文和韩文)词元转换为二元组

此过滤器包含在 Elasticsearch 的内置 CJK 语言分析器中。它使用 Lucene 的 CJKBigramFilter

示例

edit

以下analyze API请求演示了CJK双字节分词过滤器的工作原理。

GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["cjk_bigram"],
  "text" : "東京都は、日本の首都であり"
}

过滤器生成以下标记:

[ 東京, 京都, 都は, 日本, 本の, の首, 首都, 都で, であ, あり ]

添加到分析器

edit

以下创建索引 API请求使用CJK bigram token过滤器来配置一个新的自定义分析器

PUT /cjk_bigram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_cjk_bigram": {
          "tokenizer": "standard",
          "filter": [ "cjk_bigram" ]
        }
      }
    }
  }
}

可配置参数

edit
ignored_scripts

(可选,字符脚本数组) 用于禁用二元语法的字符脚本数组。 可能的值:

  • han
  • hangul
  • hiragana
  • katakana

所有非中日韩输入的内容都保持不变。

output_unigrams
(可选,布尔值) 如果为true,则同时以unigram和bigram形式输出标记。如果为false,当一个CJK字符没有相邻字符时,它将以unigram形式输出。默认为false

自定义

edit

要自定义CJK双字节标记过滤器,请复制它以创建新的自定义标记过滤器的基础。您可以使用其可配置参数来修改过滤器。

PUT /cjk_bigram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "han_bigrams": {
          "tokenizer": "standard",
          "filter": [ "han_bigrams_filter" ]
        }
      },
      "filter": {
        "han_bigrams_filter": {
          "type": "cjk_bigram",
          "ignored_scripts": [
            "hangul",
            "hiragana",
            "katakana"
          ],
          "output_unigrams": true
        }
      }
    }
  }
}

CJK 宽度分词过滤器

edit

规范化中日韩(CJK)字符的宽度差异,如下所示:

  • 将全角ASCII字符变体折叠为等效的基本拉丁字符
  • 将半角片假名字符变体折叠为等效的假名字符

此过滤器包含在 Elasticsearch 的内置 CJK 语言分析器中。它使用 Lucene 的 CJKWidthFilter

此令牌过滤器可以被视为NFKC/NFKD Unicode规范化的一个子集。请参阅analysis-icu插件以获取完整的规范化支持。

示例

edit
GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["cjk_width"],
  "text" : "シーサイドライナー"
}

过滤器生成以下令牌:

シーサイドライナー

添加到分析器

edit

以下创建索引 API请求使用 CJK 宽度分词过滤器来配置一个新的 自定义分析器

PUT /cjk_width_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_cjk_width": {
          "tokenizer": "standard",
          "filter": [ "cjk_width" ]
        }
      }
    }
  }
}

经典分词过滤器

edit

对由classic tokenizer生成的术语执行可选的后处理。

此过滤器移除单词末尾的英语所有格符号('s),并移除缩略词中的点。它使用Lucene的 ClassicFilter

示例

edit

以下analyze API请求演示了经典分词过滤器的工作原理。

GET /_analyze
{
  "tokenizer" : "classic",
  "filter" : ["classic"],
  "text" : "The 2 Q.U.I.C.K. Brown-Foxes jumped over the lazy dog's bone."
}

过滤器生成以下标记:

[ The, 2, QUICK, Brown, Foxes, jumped, over, the, lazy, dog, bone ]

添加到分析器

edit

以下创建索引 API请求使用经典分词过滤器来配置一个新的 自定义分析器

PUT /classic_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "classic_analyzer": {
          "tokenizer": "classic",
          "filter": [ "classic" ]
        }
      }
    }
  }
}

常用词组分词过滤器

edit

为指定的一组常用词生成二元组

例如,您可以将 isthe 指定为常用词。此过滤器随后将标记 [the, quick, fox, is, brown] 转换为 [the, the_quick, quick, fox, fox_is, is, is_brown, brown]

当你不想完全忽略常见词时,可以使用 common_grams 过滤器来替代 停用词过滤器

此过滤器使用 Lucene 的 CommonGramsFilter

示例

edit

以下 analyze API 请求为 isthe 创建双词组:

GET /_analyze
{
  "tokenizer" : "whitespace",
  "filter" : [
    {
      "type": "common_grams",
      "common_words": ["is", "the"]
    }
  ],
  "text" : "the quick fox is brown"
}

过滤器生成以下标记:

[ the, the_quick, quick, fox, fox_is, is, is_brown, brown ]

添加到分析器

edit

以下创建索引 API请求使用common_grams过滤器来配置一个新的自定义分析器

PUT /common_grams_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "index_grams": {
          "tokenizer": "whitespace",
          "filter": [ "common_grams" ]
        }
      },
      "filter": {
        "common_grams": {
          "type": "common_grams",
          "common_words": [ "a", "is", "the" ]
        }
      }
    }
  }
}

可配置参数

edit
common_words

(必填*, 字符串数组) 一组标记。过滤器为这些标记生成二元组。

要么这个,要么common_words_path参数是必需的。

common_words_path

(必需*, 字符串) 包含令牌列表的文件路径。过滤器为这些令牌生成二元组。

此路径必须是绝对路径或相对于config位置的相对路径。文件必须使用UTF-8编码。文件中的每个令牌必须用换行符分隔。

要么这个,要么common_words参数是必需的。

ignore_case
(可选, 布尔值) 如果 true,匹配常见单词时不区分大小写。 默认为 false
query_mode

(可选, 布尔值) 如果为true,过滤器将从输出中排除以下标记:

  • 常见词的单字
  • 跟随在常见词后的词的单字

默认为 false。我们建议为 搜索分析器启用此参数。

例如,您可以启用此参数并指定 isthe 作为常用词。此过滤器将标记 [the, quick, fox, is, brown] 转换为 [the_quick, quick, fox_is, is_brown,]

自定义

edit

要自定义 common_grams 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下请求创建一个自定义的 common_grams 过滤器,并将 ignore_casequery_mode 设置为 true

PUT /common_grams_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "index_grams": {
          "tokenizer": "whitespace",
          "filter": [ "common_grams_query" ]
        }
      },
      "filter": {
        "common_grams_query": {
          "type": "common_grams",
          "common_words": [ "a", "is", "the" ],
          "ignore_case": true,
          "query_mode": true
        }
      }
    }
  }
}

条件分词过滤器

edit

将一组标记过滤器应用于与提供的谓词脚本中的条件匹配的标记。

此过滤器使用 Lucene 的 ConditionalTokenFilter

示例

edit

以下analyze API请求使用condition过滤器来匹配THE QUICK BROWN FOX中少于5个字符的标记。然后,它将lowercase过滤器应用于这些匹配的标记,将它们转换为小写。

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "condition",
      "filter": [ "lowercase" ],
      "script": {
        "source": "token.getTerm().length() < 5"
      }
    }
  ],
  "text": "THE QUICK BROWN FOX"
}

过滤器生成以下标记:

[ the, QUICK, BROWN, fox ]

可配置参数

edit
filter

(必需,token过滤器数组) token过滤器数组。如果一个token匹配script参数中的谓词脚本,这些过滤器将按照提供的顺序应用于该token。

这些过滤器可以包括在索引映射中定义的自定义标记过滤器。

script

(必需,脚本对象) 用于应用标记过滤器的谓词脚本。如果一个标记匹配此脚本,则filter参数中的过滤器将应用于该标记。

有关有效参数,请参阅如何编写脚本。仅支持内联脚本。Painless 脚本在 分析谓词上下文 中执行,并需要一个 token 属性。

自定义并添加到分析器

edit

要自定义 condition 过滤器,请复制它以创建新的自定义标记过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义condition过滤器来配置一个新的 自定义分析器。自定义condition过滤器 匹配流中的第一个标记。然后使用 reverse过滤器反转该匹配的标记。

PUT /palindrome_list
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_reverse_first_token": {
          "tokenizer": "whitespace",
          "filter": [ "reverse_first_token" ]
        }
      },
      "filter": {
        "reverse_first_token": {
          "type": "condition",
          "filter": [ "reverse" ],
          "script": {
            "source": "token.getPosition() === 0"
          }
        }
      }
    }
  }
}

十进制数字分词过滤器

edit

将Unicode Decimal_Number 通用类别中的所有数字转换为 0-9。 例如,该过滤器将孟加拉数字 更改为 3

此过滤器使用 Lucene 的 DecimalDigitFilter

示例

edit

以下analyze API请求使用decimal_digit过滤器将天城文数字转换为0-9

GET /_analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["decimal_digit"],
  "text" : "१-one two-२ ३"
}

过滤器生成以下标记:

[ 1-one, two-2, 3]

添加到分析器

edit

以下创建索引 API请求使用decimal_digit过滤器来配置一个新的自定义分析器

PUT /decimal_digit_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_decimal_digit": {
          "tokenizer": "whitespace",
          "filter": [ "decimal_digit" ]
        }
      }
    }
  }
}

分隔载荷词元过滤器

edit

旧名称 delimited_payload_filter 已弃用,不应在新索引中使用。请改用 delimited_payload

根据指定的分隔符将令牌流分离为令牌和有效载荷。

例如,您可以使用带有 | 分隔符的 delimited_payload 过滤器将 the|1 quick|2 fox|3 拆分为标记 thequickfox,并分别带有有效载荷 123

此过滤器使用 Lucene 的 DelimitedPayloadTokenFilter

有效载荷

有效载荷是与令牌位置关联的用户定义二进制数据,并存储为base64编码的字节。

Elasticsearch 默认不存储词元载荷。要存储载荷,您必须:

  • term_vector 映射参数设置为 with_positions_payloadswith_positions_offsets_payloads 以存储有效载荷的任何字段。
  • 使用包含 delimited_payload 过滤器的索引分析器

您可以使用term vectors API查看存储的有效载荷。

示例

edit

以下analyze API请求使用了默认的|分隔符的delimited_payload过滤器,将the|0 brown|10 fox|5 is|0 quick|10分割成标记和有效载荷。

GET _analyze
{
  "tokenizer": "whitespace",
  "filter": ["delimited_payload"],
  "text": "the|0 brown|10 fox|5 is|0 quick|10"
}

过滤器生成以下标记:

[ the, brown, fox, is, quick ]

请注意,analyze API 不会返回存储的有效载荷。有关包含返回有效载荷的示例,请参见 返回存储的有效载荷

添加到分析器

edit

以下创建索引 API请求使用delimited-payload过滤器来配置一个新的自定义分析器

PUT delimited_payload
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_delimited_payload": {
          "tokenizer": "whitespace",
          "filter": [ "delimited_payload" ]
        }
      }
    }
  }
}

可配置参数

edit
delimiter
(可选,字符串) 用于分隔标记和有效负载的字符。默认为 |
encoding

(可选, 字符串) 存储的有效负载的数据类型。有效值包括:

float
(默认) 浮点数
identity
字符
int
整数

自定义并添加到分析器

edit

要自定义 delimited_payload 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义的delimited_payload过滤器来配置一个新的 自定义分析器。该自定义的delimited_payload 过滤器使用+分隔符来分隔令牌和有效载荷。有效载荷 被编码为整数。

PUT delimited_payload_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_plus_delimited": {
          "tokenizer": "whitespace",
          "filter": [ "plus_delimited" ]
        }
      },
      "filter": {
        "plus_delimited": {
          "type": "delimited_payload",
          "delimiter": "+",
          "encoding": "int"
        }
      }
    }
  }
}

返回存储的有效载荷

edit

使用创建索引 API来创建一个索引,该索引:

  • 包含一个存储带有有效载荷的词向量的字段。
  • 使用一个带有delimited_payload过滤器的自定义索引分析器
PUT text_payloads
{
  "mappings": {
    "properties": {
      "text": {
        "type": "text",
        "term_vector": "with_positions_payloads",
        "analyzer": "payload_delimiter"
      }
    }
  },
  "settings": {
    "analysis": {
      "analyzer": {
        "payload_delimiter": {
          "tokenizer": "whitespace",
          "filter": [ "delimited_payload" ]
        }
      }
    }
  }
}

向索引中添加包含有效负载的文档。

POST text_payloads/_doc/1
{
  "text": "the|0 brown|3 fox|4 is|0 quick|10"
}

使用term vectors API来返回文档的词元和base64编码的有效载荷。

GET text_payloads/_termvectors/1
{
  "fields": [ "text" ],
  "payloads": true
}

API返回以下响应:

{
  "_index": "text_payloads",
  "_id": "1",
  "_version": 1,
  "found": true,
  "took": 8,
  "term_vectors": {
    "text": {
      "field_statistics": {
        "sum_doc_freq": 5,
        "doc_count": 1,
        "sum_ttf": 5
      },
      "terms": {
        "brown": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 1,
              "payload": "QEAAAA=="
            }
          ]
        },
        "fox": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 2,
              "payload": "QIAAAA=="
            }
          ]
        },
        "is": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 3,
              "payload": "AAAAAA=="
            }
          ]
        },
        "quick": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 4,
              "payload": "QSAAAA=="
            }
          ]
        },
        "the": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 0,
              "payload": "AAAAAA=="
            }
          ]
        }
      }
    }
  }
}

字典分解词元过滤器

edit

在大多数情况下,我们建议使用更快的 hyphenation_decompounder 分词过滤器 来替代此过滤器。然而,您可以使用 dictionary_decompounder 过滤器来检查单词列表的质量,然后再将其应用于 hyphenation_decompounder 过滤器中。

使用指定的单词列表和暴力破解方法来查找复合词中的子词。如果找到,这些子词将包含在分词输出中。

此过滤器使用 Lucene 的 DictionaryCompoundWordTokenFilter, 该过滤器是为日耳曼语系构建的。

示例

edit

以下分析API请求使用dictionary_decompounder过滤器在Donaudampfschiff中查找子词。然后,过滤器会根据指定的单词列表检查这些子词:Donaudampfmeerschiff

GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "dictionary_decompounder",
      "word_list": ["Donau", "dampf", "meer", "schiff"]
    }
  ],
  "text": "Donaudampfschiff"
}

过滤器生成以下标记:

[ Donaudampfschiff, Donau, dampf, schiff ]

可配置参数

edit
word_list

(必填*, 字符串数组) 在标记流中查找的子词列表。如果找到,子词将包含在标记输出中。

必须指定此参数或word_list_path

word_list_path

(必需*, 字符串) 包含要在标记流中查找的子词列表的文件路径。如果找到,该子词将包含在标记输出中。

此路径必须是绝对路径或相对于 config 位置的相对路径,并且文件必须使用 UTF-8 编码。文件中的每个令牌必须用换行符分隔。

必须指定此参数或word_list

max_subword_size
(可选, 整数) 最大子词字符长度。超过此长度的子词标记将从输出中排除。默认为 15
min_subword_size
(可选, 整数) 最小子词字符长度。较短的子词标记将从输出中排除。默认为 2
min_word_size
(可选, 整数) 最小单词字符长度。短于该长度的单词标记将被排除在输出之外。默认为 5
only_longest_match
(可选,布尔值) 如果为true,则仅包含最长的匹配子词。默认为false

自定义并添加到分析器

edit

要自定义 dictionary_decompounder 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义的dictionary_decompounder过滤器来配置一个新的 自定义分析器

自定义的 dictionary_decompounder 过滤器在 analysis/example_word_list.txt 文件中查找子词。长度超过22个字符的子词将从分词输出中排除。

PUT dictionary_decompound_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_dictionary_decompound": {
          "tokenizer": "standard",
          "filter": [ "22_char_dictionary_decompound" ]
        }
      },
      "filter": {
        "22_char_dictionary_decompound": {
          "type": "dictionary_decompounder",
          "word_list_path": "analysis/example_word_list.txt",
          "max_subword_size": 22
        }
      }
    }
  }
}

边缘n-gram分词过滤器

edit

从标记的开头形成指定长度的 n-gram

例如,您可以使用 edge_ngram 分词过滤器将 quick 转换为 qu

当未自定义时,过滤器默认创建1个字符的边缘n-grams。

此过滤器使用 Lucene 的 EdgeNGramTokenFilter

edge_ngram 过滤器类似于 ngram 分词过滤器。然而,edge_ngram 仅输出从词的开头开始的 n-gram。这些边缘 n-gram 对于 即搜即得 查询非常有用。

示例

edit

以下 analyze API 请求使用 edge_ngram 过滤器将 the quick brown fox jumps 转换为 1 个字符和 2 个字符的边缘 n-grams:

GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    { "type": "edge_ngram",
      "min_gram": 1,
      "max_gram": 2
    }
  ],
  "text": "the quick brown fox jumps"
}

过滤器生成以下标记:

[ t, th, q, qu, b, br, f, fo, j, ju ]

添加到分析器

edit

以下创建索引 API请求使用edge_ngram过滤器来配置一个新的自定义分析器

PUT edge_ngram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_edge_ngram": {
          "tokenizer": "standard",
          "filter": [ "edge_ngram" ]
        }
      }
    }
  }
}

可配置参数

edit
max_gram

(可选, 整数) 最大字符长度。对于自定义分词过滤器,默认为 2。 对于内置的 edge_ngram 过滤器,默认为 1

请参阅max_gram参数的限制

min_gram
(可选,整数) n-gram 的最小字符长度。默认为 1
preserve_original
(可选, 布尔值) 当设置为true时,发出原始标记。默认为false
side

(可选, 字符串) [8.16.0] 在8.16.0中已弃用。使用 < . 指示是否从截断令牌。默认为

自定义

edit

要自定义 edge_ngram 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下请求创建一个自定义的 edge_ngram 过滤器,该过滤器形成3-5个字符的n-grams。

PUT edge_ngram_custom_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "3_5_edgegrams" ]
        }
      },
      "filter": {
        "3_5_edgegrams": {
          "type": "edge_ngram",
          "min_gram": 3,
          "max_gram": 5
        }
      }
    }
  }
}

max_gram参数的限制

edit

The edge_ngram 过滤器的 max_gram 值限制了标记的字符长度。当 edge_ngram 过滤器与索引分析器一起使用时,这意味着搜索词的长度超过 max_gram 长度可能不会匹配任何索引的词条。

例如,如果 max_gram3,搜索 apple 将不会匹配索引项 app

为了解决这个问题,你可以使用 truncate 过滤器与搜索分析器 来将搜索词缩短到 max_gram 字符长度。然而,这可能会 返回不相关的结果。

例如,如果 max_gram3 并且搜索词被截断为三个字符,搜索词 apple 被缩短为 app。这意味着搜索 apple 会返回任何匹配 app 的索引词,例如 applysnappedapple

我们建议测试这两种方法,以了解哪种最适合您的用例和所需的搜索体验。

省略词标记过滤器

edit

移除指定省略从词的开头。例如,您可以使用此过滤器将l'avion更改为avion

当未自定义时,过滤器默认会移除以下法语省略部分:

l', m', t', qu', n', s', j', d', c', jusqu', quoiqu', lorsqu', puisqu'

此过滤器的定制版本包含在 Elasticsearch 的多个内置 语言分析器中:

此过滤器使用 Lucene 的 ElisionFilter

示例

edit

以下analyze API请求使用elision过滤器从j’examine près du wharf中移除j'

GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["elision"],
  "text" : "j’examine près du wharf"
}

过滤器生成以下标记:

[ examine, près, du, wharf ]

添加到分析器

edit

以下创建索引 API请求使用省略过滤器来配置一个新的自定义分析器

PUT /elision_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_elision": {
          "tokenizer": "whitespace",
          "filter": [ "elision" ]
        }
      }
    }
  }
}

可配置参数

edit
articles

(必需*, 字符串数组) 要移除的省略列表。

要删除省略号,省略号必须位于标记的开头,并且紧跟在撇号之后。省略号和撇号都会被删除。

对于自定义的 elision 过滤器,必须指定此参数或 articles_path

articles_path

(必需*, 字符串) 包含要删除的省略列表的文件路径。

此路径必须是绝对路径或相对于config位置的相对路径,并且文件必须使用UTF-8编码。文件中的每个省略项必须用换行符分隔。

要删除省略号,省略号必须位于标记的开头,并且紧跟在撇号之后。省略号和撇号都会被删除。

对于自定义的 elision 过滤器,必须指定此参数或 articles

articles_case
(可选, 布尔值) 如果 true,省略匹配不区分大小写。如果 false,省略匹配区分大小写。默认为 false

自定义

edit

要自定义 elision 过滤器,请复制它以创建新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下请求创建一个自定义的不区分大小写的elision过滤器,移除l'm't'qu'n's'j'省略号:

PUT /elision_case_insensitive_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "elision_case_insensitive" ]
        }
      },
      "filter": {
        "elision_case_insensitive": {
          "type": "elision",
          "articles": [ "l", "m", "t", "qu", "n", "s", "j" ],
          "articles_case": true
        }
      }
    }
  }
}

指纹分词过滤器

edit

对令牌流进行排序并去除重复的令牌,然后将流连接成单个输出令牌。

例如,这个过滤器将 [ the, fox, was, very, very, quick ] 标记流更改为如下所示:

  1. 将标记按字母顺序排序为 [ fox, quick, the, very, very, was ]
  2. 移除重复的 very 标记实例。
  3. 将标记流连接为一个输出标记:[fox quick the very was ]

此过滤器生成的输出标记对于指纹识别和聚类文本非常有用,如OpenRefine项目中所述。

此过滤器使用 Lucene 的 FingerprintFilter

示例

edit

以下 analyze API 请求使用 fingerprint 过滤器为文本 zebra jumps over resting resting dog 创建一个输出标记:

GET _analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["fingerprint"],
  "text" : "zebra jumps over resting resting dog"
}

过滤器生成以下令牌:

[ dog jumps over resting zebra ]

添加到分析器

edit

以下创建索引 API请求使用fingerprint过滤器来配置一个新的自定义分析器

PUT fingerprint_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_fingerprint": {
          "tokenizer": "whitespace",
          "filter": [ "fingerprint" ]
        }
      }
    }
  }
}

可配置参数

edit
max_output_size
(可选, 整数) 输出标记的最大字符长度,包括空白字符。默认为 255。连接后的标记如果超过此长度将不会输出任何标记。
separator
(可选, 字符串) 用于连接标记流输入的字符。默认为空格。

自定义

edit

要自定义 fingerprint 过滤器,请复制它以创建新的自定义令牌过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建一个使用 + 连接标记流的定制 fingerprint 过滤器。该过滤器还将输出标记限制为 100 个字符或更少。

PUT custom_fingerprint_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_": {
          "tokenizer": "whitespace",
          "filter": [ "fingerprint_plus_concat" ]
        }
      },
      "filter": {
        "fingerprint_plus_concat": {
          "type": "fingerprint",
          "max_output_size": 100,
          "separator": "+"
        }
      }
    }
  }
}

扁平图标记过滤器

edit

展平由图令牌过滤器(如令牌图)生成的synonym_graphword_delimiter_graph)。

展平包含 多位置标记的标记图,使得该图适合于索引。否则,索引不支持包含多位置标记的标记图。

展平图表是一个有损的过程。

如果可能,避免使用flatten_graph过滤器。相反,仅在搜索分析器中使用图令牌过滤器。这样可以消除对flatten_graph过滤器的需求。

The flatten_graph filter uses Lucene’s FlattenGraphFilter

示例

edit

要查看 flatten_graph 过滤器的工作原理,您首先需要生成一个包含多位置标记的标记图。

以下 analyze API 请求使用 synonym_graph 过滤器将 dns 作为 domain name system 的多位置同义词添加到文本 domain name system is fragile 中:

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "synonym_graph",
      "synonyms": [ "dns, domain name system" ]
    }
  ],
  "text": "domain name system is fragile"
}

该过滤器生成以下令牌图,其中 dns 作为多位置令牌。

token graph dns synonym ex

索引不支持包含多位置标记的标记图。为了使这个标记图适合索引,它需要被展平。

要展平标记图,请在之前的分析 API 请求中,在 synonym_graph 过滤器之后添加 flatten_graph 过滤器。

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "synonym_graph",
      "synonyms": [ "dns, domain name system" ]
    },
    "flatten_graph"
  ],
  "text": "domain name system is fragile"
}

该过滤器生成以下扁平化的标记图,适合用于索引。

token graph dns invalid ex

添加到分析器

edit

以下创建索引 API请求使用flatten_graph 标记过滤器来配置一个新的自定义分析器

在这个分析器中,自定义的 word_delimiter_graph 过滤器生成包含连接的、多位置标记的标记图。flatten_graph 过滤器将这些标记图展平,使其适合索引。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_custom_index_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "my_custom_word_delimiter_graph_filter",
            "flatten_graph"
          ]
        }
      },
      "filter": {
        "my_custom_word_delimiter_graph_filter": {
          "type": "word_delimiter_graph",
          "catenate_all": true
        }
      }
    }
  }
}

Hunspell 分词过滤器

edit

基于提供的字典词干提取,使用Hunspell字典hunspell过滤器需要配置一个或多个特定语言的Hunspell字典。

此过滤器使用 Lucene 的 HunspellStemFilter

如果可用,我们建议在尝试使用 hunspell 分词过滤器之前,先尝试使用您语言的算法词干提取器。实际上,算法词干提取器通常优于字典词干提取器。请参阅 字典词干提取器

配置Hunspell词典

edit

Hunspell词典存储并检测在文件系统上的专用hunspell目录中:<$ES_PATH_CONF>/hunspell。每个词典都应有自己的目录,以其关联的语言和区域设置命名(例如,pt_BRen_GB)。此词典目录应包含一个.aff文件和一个或多个.dic文件,所有这些文件都将自动被识别。例如,以下目录布局将定义en_US词典:

- config
    |-- hunspell
    |    |-- en_US
    |    |    |-- en_US.dic
    |    |    |-- en_US.aff

每个字典都可以配置一个设置:

ignore_case

(静态, 布尔值) 如果为真,字典匹配将不区分大小写。默认为 false

此设置可以在 elasticsearch.yml 中全局配置,使用 indices.analysis.hunspell.dictionary.ignore_case

要为特定区域设置配置设置,请使用indices.analysis.hunspell.dictionary..ignore_case设置(例如,对于en_US(美式英语)区域设置,设置为indices.analysis.hunspell.dictionary.en_US.ignore_case)。

您还可以在字典目录下添加一个settings.yml文件,该文件保存这些设置。这将覆盖在elasticsearch.yml中定义的任何其他ignore_case设置。

示例

edit

以下 analyze API 请求使用 hunspell 过滤器将 the foxes jumping quickly 词干化为 the fox jump quick

请求指定了en_US区域设置,这意味着在<$ES_PATH_CONF>/hunspell/en_US目录中的.aff.dic文件被用于Hunspell词典。

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "hunspell",
      "locale": "en_US"
    }
  ],
  "text": "the foxes jumping quickly"
}

过滤器生成以下标记:

[ the, fox, jump, quick ]

可配置参数

edit
dictionary

(可选,字符串或字符串数组) 一个或多个 .dic 文件(例如,en_US.dic, my_custom.dic)用于Hunspell词典。

默认情况下,hunspell 过滤器使用在指定 langlanguagelocale 参数的 <$ES_PATH_CONF>/hunspell/ 目录中的所有 .dic 文件。

dedup
(可选,布尔值) 如果为true,则从过滤器的输出中移除重复的标记。默认为 true
lang

(必需*, 字符串) locale 参数的别名。

如果未指定此参数,则需要指定languagelocale参数。

language

(必需*, 字符串) locale 参数的别名。

如果未指定此参数,则需要 langlocale 参数。

locale

(必需*, 字符串) 用于指定Hunspell词典的.aff.dic文件的本地化目录。参见配置Hunspell词典

如果未指定此参数,则需要 langlanguage 参数。

longest_only
(可选, 布尔值) 如果true,则仅在输出中包含每个标记的最长词干版本。如果false,则包含标记的所有词干版本。默认为false

自定义并添加到分析器

edit

要自定义 hunspell 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义的 hunspell 过滤器,my_en_US_dict_stemmer,来配置一个新的 自定义分析器

The my_en_US_dict_stemmer filter uses a locale of en_US, 这意味着在 <$ES_PATH_CONF>/hunspell/en_US 目录中的 .aff.dic 文件被使用。该过滤器还包括一个 dedup 参数为 false,这意味着从字典中添加的重复标记不会从过滤器的输出中删除。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "en": {
          "tokenizer": "standard",
          "filter": [ "my_en_US_dict_stemmer" ]
        }
      },
      "filter": {
        "my_en_US_dict_stemmer": {
          "type": "hunspell",
          "locale": "en_US",
          "dedup": false
        }
      }
    }
  }
}

设置

edit

除了ignore_case设置外,您还可以使用elasticsearch.ymlhunspell过滤器配置以下全局设置:

indices.analysis.hunspell.dictionary.lazy
(静态, 布尔值) 如果 true,Hunspell 字典的加载会被推迟,直到使用某个字典时才进行。如果 false,节点启动时会检查字典目录中的字典,并自动加载任何字典。默认为 false

连字分解词元过滤器

edit

使用基于XML的连字模式在复合词中找到潜在的子词。然后,这些子词会与指定的词表进行比对。不在列表中的子词将从分词输出中排除。

此过滤器使用 Lucene 的 HyphenationCompoundWordTokenFilter, 该过滤器是为日耳曼语系构建的。

示例

edit

以下分析API请求使用hyphenation_decompounder过滤器基于analysis/hyphenation_patterns.xml文件中的德语连字模式在Kaffeetasse中查找子词。然后,过滤器检查这些子词是否与指定单词列表中的单词匹配:kaffeezuckertasse

GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "hyphenation_decompounder",
      "hyphenation_patterns_path": "analysis/hyphenation_patterns.xml",
      "word_list": ["Kaffee", "zucker", "tasse"]
    }
  ],
  "text": "Kaffeetasse"
}

过滤器生成以下标记:

[ Kaffeetasse, Kaffee, tasse ]

可配置参数

edit
hyphenation_patterns_path

(必需,字符串) 指向一个Apache FOP(格式化对象处理器)XML连字模式文件的路径。

此路径必须是绝对路径或相对于config位置的相对路径。仅支持与FOP v1.2兼容的文件。

例如,关于FOP XML连字模式文件,请参考:

word_list

(必需*, 字符串数组) 一个子词列表。使用连字符模式找到但未在此列表中的子词将从标记输出中排除。

您可以使用dictionary_decompounder 过滤器来测试词表的质量,然后再实施它们。

必须指定此参数或word_list_path

word_list_path

(必需*, 字符串) 包含子词列表的文件路径。使用连字符模式找到但未在此列表中的子词将从标记输出中排除。

此路径必须是绝对路径或相对于 config 位置的相对路径,并且文件必须使用 UTF-8 编码。文件中的每个令牌必须用换行符分隔。

您可以使用dictionary_decompounder 过滤器来测试词表的质量,然后再实施它们。

必须指定此参数或word_list

max_subword_size
(可选, 整数) 最大子词字符长度。超过此长度的子词标记将从输出中排除。默认为 15
min_subword_size
(可选, 整数) 最小子词字符长度。较短的子词标记将从输出中排除。默认为 2
min_word_size
(可选, 整数) 最小单词字符长度。短于该长度的单词标记将被排除在输出之外。默认为 5
only_longest_match
(可选,布尔值) 如果为true,则仅包含最长的匹配子词。默认为false

自定义并添加到分析器

edit

要自定义 hyphenation_decompounder 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义的 hyphenation_decompounder 过滤器来配置一个新的 自定义分析器

自定义的 hyphenation_decompounder 过滤器基于 analysis/hyphenation_patterns.xml 文件中的连字符模式查找子词。然后,过滤器会检查这些子词是否在 analysis/example_word_list.txt 文件中指定的单词列表中。长度超过22个字符的子词将从标记输出中排除。

PUT hyphenation_decompound_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_hyphenation_decompound": {
          "tokenizer": "standard",
          "filter": [ "22_char_hyphenation_decompound" ]
        }
      },
      "filter": {
        "22_char_hyphenation_decompound": {
          "type": "hyphenation_decompounder",
          "word_list_path": "analysis/example_word_list.txt",
          "hyphenation_patterns_path": "analysis/hyphenation_patterns.xml",
          "max_subword_size": 22
        }
      }
    }
  }
}

保留类型分词过滤器

edit

保留或删除特定类型的标记。例如,您可以使用此过滤器将3 quick foxes更改为quick foxes,仅保留(字母数字)标记。

令牌类型

标记类型由分词器在将字符转换为标记时设置。标记类型在不同的分词器之间可能会有所不同。

例如,standard 分词器可以生成多种词元类型,包括 。更简单的分析器,如 lowercase 分词器,只生成 word 词元类型。

某些分词过滤器也可以添加分词类型。例如,同义词过滤器可以添加<同义词>分词类型。

一些分词器不支持此标记过滤器,例如 keyword、simple_pattern 和 simple_pattern_split 分词器,因为它们不支持设置标记类型属性。

此过滤器使用 Lucene 的 TypeTokenFilter

包含示例

edit

以下analyze API请求使用keep_types过滤器仅保留(数字)标记从1 quick fox 2 lazy dogs

GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "keep_types",
      "types": [ "<NUM>" ]
    }
  ],
  "text": "1 quick fox 2 lazy dogs"
}

过滤器生成以下标记:

[ 1, 2 ]

排除示例

edit

以下analyze API请求使用keep_types过滤器从1 quick fox 2 lazy dogs中移除标记。注意mode参数设置为exclude

GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "keep_types",
      "types": [ "<NUM>" ],
      "mode": "exclude"
    }
  ],
  "text": "1 quick fox 2 lazy dogs"
}

过滤器生成以下标记:

[ quick, fox, lazy, dogs ]

可配置参数

edit
types
(必需,字符串数组) 要保留或移除的标记类型列表。
mode

(可选, 字符串) 指示是否保留或删除指定的标记类型。 有效值为:

include
(默认) 仅保留指定的标记类型。
exclude
删除指定的标记类型。

自定义并添加到分析器

edit

要自定义 keep_types 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义keep_types过滤器来配置一个新的 自定义分析器。该自定义keep_types过滤器 仅保留(字母数字)标记。

PUT keep_types_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [ "extract_alpha" ]
        }
      },
      "filter": {
        "extract_alpha": {
          "type": "keep_types",
          "types": [ "<ALPHANUM>" ]
        }
      }
    }
  }
}

保留词元过滤器

edit

仅保留包含在指定词表中的标记。

此过滤器使用 Lucene 的 KeepWordFilter

要从词元流中移除一个词列表,请使用 stop 过滤器。

示例

edit

以下analyze API请求使用keep过滤器,仅保留foxdog标记,从the quick fox jumps over the lazy dog中。

GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "keep",
      "keep_words": [ "dog", "elephant", "fox" ]
    }
  ],
  "text": "the quick fox jumps over the lazy dog"
}

过滤器生成以下标记:

[ fox, dog ]

可配置参数

edit
keep_words

(必需*, 字符串数组) 保留的词汇列表。只有与该列表中的词汇匹配的标记才会包含在输出中。

必须指定此参数或keep_words_path

keep_words_path

(必需*, 字符串数组) 包含要保留的单词列表的文件路径。只有与该列表中的单词匹配的标记才会包含在输出中。

此路径必须是绝对路径或相对于config位置的相对路径,并且文件必须使用UTF-8编码。文件中的每个单词必须用换行符分隔。

必须指定此参数或keep_words

keep_words_case
(可选, 布尔值) 如果为true,将所有保留字转换为小写。默认为false

自定义并添加到分析器

edit

要自定义 keep 过滤器,请复制它以创建新自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义keep过滤器来配置两个新的 自定义分析器

  • standard_keep_word_array,使用自定义的keep过滤器和内联的保留词数组
  • standard_keep_word_file,使用自定义的keep过滤器和保留词文件
PUT keep_words_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_keep_word_array": {
          "tokenizer": "standard",
          "filter": [ "keep_word_array" ]
        },
        "standard_keep_word_file": {
          "tokenizer": "standard",
          "filter": [ "keep_word_file" ]
        }
      },
      "filter": {
        "keep_word_array": {
          "type": "keep",
          "keep_words": [ "one", "two", "three" ]
        },
        "keep_word_file": {
          "type": "keep",
          "keep_words_path": "analysis/example_word_list.txt"
        }
      }
    }
  }
}

关键词标记分词过滤器

edit

将指定的标记标记为关键词,这些关键词不会被词干化。

The keyword_marker 过滤器将指定的标记分配一个 keyword 属性为 true。词干化标记过滤器,例如 stemmerporter_stem,会跳过具有 keyword 属性为 true 的标记。

为了正常工作,keyword_marker 过滤器必须列在任何词干提取器标记过滤器之前,位于分析器配置中。

The keyword_marker filter uses Lucene’s KeywordMarkerFilter

示例

edit

要查看 keyword_marker 过滤器的工作原理,您首先需要生成一个包含词干化标记的标记流。

以下analyze API请求使用了 stemmer过滤器来为 fox running and jumping创建词干化标记。

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [ "stemmer" ],
  "text": "fox running and jumping"
}

该请求生成以下词元。请注意,running 被词干化为 run,而 jumping 被词干化为 jump

[ fox, run, and, jump ]

为了防止 jumping 被词干化,请在之前的 analyze API 请求中,在 stemmer 过滤器之前添加 keyword_marker 过滤器。在 keyword_marker 过滤器的 keywords 参数中指定 jumping

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "keyword_marker",
      "keywords": [ "jumping" ]
    },
    "stemmer"
  ],
  "text": "fox running and jumping"
}

请求产生以下词条。running 仍然被词干提取为 run,但 jumping 没有被词干提取。

[ fox, run, and, jumping ]

要查看这些标记的 keyword 属性,请将以下参数添加到 analyze API 请求中:

  • explain: true
  • attributes: keyword
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "keyword_marker",
      "keywords": [ "jumping" ]
    },
    "stemmer"
  ],
  "text": "fox running and jumping",
  "explain": true,
  "attributes": "keyword"
}

API返回以下响应。请注意,jumping 标记具有 keyword 属性,其值为 true

{
  "detail": {
    "custom_analyzer": true,
    "charfilters": [],
    "tokenizer": {
      "name": "whitespace",
      "tokens": [
        {
          "token": "fox",
          "start_offset": 0,
          "end_offset": 3,
          "type": "word",
          "position": 0
        },
        {
          "token": "running",
          "start_offset": 4,
          "end_offset": 11,
          "type": "word",
          "position": 1
        },
        {
          "token": "and",
          "start_offset": 12,
          "end_offset": 15,
          "type": "word",
          "position": 2
        },
        {
          "token": "jumping",
          "start_offset": 16,
          "end_offset": 23,
          "type": "word",
          "position": 3
        }
      ]
    },
    "tokenfilters": [
      {
        "name": "__anonymous__keyword_marker",
        "tokens": [
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": false
          },
          {
            "token": "running",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": false
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": false
          },
          {
            "token": "jumping",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": true
          }
        ]
      },
      {
        "name": "stemmer",
        "tokens": [
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": false
          },
          {
            "token": "run",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": false
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": false
          },
          {
            "token": "jumping",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": true
          }
        ]
      }
    ]
  }
}

可配置参数

edit
ignore_case
(可选, 布尔值) 如果为true,则匹配keywordskeywords_path参数时忽略字母大小写。默认为false
keywords

(必填*, 字符串数组) 关键字数组。匹配这些关键字的词元不会被词干化。

必须指定此参数,keywords_path,或 keywords_pattern。 您不能同时指定此参数和 keywords_pattern

keywords_path

(必需*, 字符串) 包含关键字列表的文件路径。匹配这些关键字的词元不会被词干化。

此路径必须是绝对路径或相对于config位置的相对路径,并且文件必须使用UTF-8编码。文件中的每个单词必须用换行符分隔。

必须指定此参数,keywordskeywords_pattern。 您不能同时指定此参数和 keywords_pattern

keywords_pattern

(必需*, 字符串) Java 正则表达式用于匹配标记。匹配此表达式的标记将被标记为关键词且不会被词干化。

必须指定此参数,keywordskeywords_path。您不能同时指定此参数和 keywordskeywords_pattern

编写不当的正则表达式可能导致Elasticsearch运行缓慢或导致栈溢出错误,从而使运行中的节点突然退出。

自定义并添加到分析器

edit

要自定义 keyword_marker 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义的keyword_marker过滤器和porter_stem 过滤器来配置一个新的自定义分析器

自定义的 keyword_marker 过滤器将 analysis/example_word_list.txt 文件中指定的标记标记为关键词。porter_stem 过滤器不会对这些标记进行词干提取。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_custom_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "my_custom_keyword_marker_filter",
            "porter_stem"
          ]
        }
      },
      "filter": {
        "my_custom_keyword_marker_filter": {
          "type": "keyword_marker",
          "keywords_path": "analysis/example_word_list.txt"
        }
      }
    }
  }
}

关键词重复分词过滤器

edit

输出流中每个标记的关键字版本。这些关键字标记不会被词干化。

The keyword_repeat filter assigns keyword tokens a keyword attribute of true. Stemmer token filters, such as stemmer or porter_stem, skip tokens with a keyword attribute of true.

您可以使用 keyword_repeat 过滤器与词干提取器分词过滤器一起,在流中输出每个词元的词干形式和非词干形式。

为了正常工作,keyword_repeat 过滤器必须列在 分析器配置中的任何词干提取器标记过滤器之前。

词干提取不会影响所有词元。这意味着流中在同一位置可能包含重复的词元,即使在词干提取之后也是如此。

要删除这些重复的标记,请在分析器配置中的词干过滤器之后添加remove_duplicates过滤器。

The keyword_repeat filter uses Lucene’s KeywordRepeatFilter

示例

edit

以下analyze API请求使用了keyword_repeat过滤器,以输出每个标记在fox running and jumping中的关键词和非关键词版本。

要返回这些标记的 keyword 属性,analyze API 请求还包括以下参数:

  • explain: true
  • attributes: keyword
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    "keyword_repeat"
  ],
  "text": "fox running and jumping",
  "explain": true,
  "attributes": "keyword"
}

API返回以下响应。请注意,每个令牌的一个版本具有keyword属性为true

响应
{
  "detail": {
    "custom_analyzer": true,
    "charfilters": [],
    "tokenizer": ...,
    "tokenfilters": [
      {
        "name": "keyword_repeat",
        "tokens": [
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": true
          },
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": false
          },
          {
            "token": "running",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": true
          },
          {
            "token": "running",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": false
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": true
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": false
          },
          {
            "token": "jumping",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": true
          },
          {
            "token": "jumping",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": false
          }
        ]
      }
    ]
  }
}

要处理非关键词标记,请在之前的分析API请求中,在keyword_repeat过滤器之后添加stemmer过滤器。

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    "keyword_repeat",
    "stemmer"
  ],
  "text": "fox running and jumping",
  "explain": true,
  "attributes": "keyword"
}

API返回以下响应。请注意以下更改:

  • The non-keyword version of running was stemmed to run.
  • The non-keyword version of jumping was stemmed to jump.
响应
{
  "detail": {
    "custom_analyzer": true,
    "charfilters": [],
    "tokenizer": ...,
    "tokenfilters": [
      {
        "name": "keyword_repeat",
        "tokens": ...
      },
      {
        "name": "stemmer",
        "tokens": [
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": true
          },
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": false
          },
          {
            "token": "running",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": true
          },
          {
            "token": "run",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": false
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": true
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": false
          },
          {
            "token": "jumping",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": true
          },
          {
            "token": "jump",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": false
          }
        ]
      }
    ]
  }
}

然而,foxand 的关键字和非关键字版本是相同的,并且在各自的位置上。

要删除这些重复的标记,请在分析API请求中的stemmer之后添加remove_duplicates过滤器。

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    "keyword_repeat",
    "stemmer",
    "remove_duplicates"
  ],
  "text": "fox running and jumping",
  "explain": true,
  "attributes": "keyword"
}

API返回以下响应。请注意,已删除foxand的重复标记。

响应
{
  "detail": {
    "custom_analyzer": true,
    "charfilters": [],
    "tokenizer": ...,
    "tokenfilters": [
      {
        "name": "keyword_repeat",
        "tokens": ...
      },
      {
        "name": "stemmer",
        "tokens": ...
      },
      {
        "name": "remove_duplicates",
        "tokens": [
          {
            "token": "fox",
            "start_offset": 0,
            "end_offset": 3,
            "type": "word",
            "position": 0,
            "keyword": true
          },
          {
            "token": "running",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": true
          },
          {
            "token": "run",
            "start_offset": 4,
            "end_offset": 11,
            "type": "word",
            "position": 1,
            "keyword": false
          },
          {
            "token": "and",
            "start_offset": 12,
            "end_offset": 15,
            "type": "word",
            "position": 2,
            "keyword": true
          },
          {
            "token": "jumping",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": true
          },
          {
            "token": "jump",
            "start_offset": 16,
            "end_offset": 23,
            "type": "word",
            "position": 3,
            "keyword": false
          }
        ]
      }
    ]
  }
}

添加到分析器

edit

以下创建索引 API请求使用keyword_repeat过滤器来配置一个新的自定义分析器

这个自定义分析器使用 keyword_repeatporter_stem 过滤器来创建流中每个词元的词干化和非词干化版本。然后,remove_duplicates 过滤器从流中移除任何重复的词元。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_custom_analyzer": {
          "tokenizer": "standard",
          "filter": [
            "keyword_repeat",
            "porter_stem",
            "remove_duplicates"
          ]
        }
      }
    }
  }
}

KStem 分词过滤器

edit

为英语语言提供基于KStem的词干提取。kstem过滤器结合了算法词干提取与内置的词典

The kstem filter tends to stem less aggressively than other English stemmer filters, such as the porter_stem filter.

The kstem filter 等同于 stemmer filter 的 light_english 变体。

此过滤器使用 Lucene 的 KStemFilter

示例

edit

以下 analyze API 请求使用 kstem 过滤器将 the foxes jumping quickly 词干化为 the fox jump quick

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "kstem" ],
  "text": "the foxes jumping quickly"
}

过滤器生成以下标记:

[ the, fox, jump, quick ]

添加到分析器

edit

以下创建索引 API请求使用kstem过滤器来配置一个新的自定义分析器

为了正常工作,kstem 过滤器需要小写的词元。为了确保词元是小写的,请在分析器配置中在 kstem 过滤器之前添加 lowercase 过滤器。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "whitespace",
          "filter": [
            "lowercase",
            "kstem"
          ]
        }
      }
    }
  }
}

长度词元过滤器

edit

移除短于或长于指定字符长度的词元。 例如,您可以使用 length 过滤器来排除短于2个字符和长于5个字符的词元。

此过滤器使用 Lucene 的 LengthFilter

The length filter 移除整个词元。如果你希望将词元缩短到特定长度,请使用 truncate filter。

示例

edit

以下analyze API请求使用length过滤器来移除长度超过4个字符的标记:

GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "length",
      "min": 0,
      "max": 4
    }
  ],
  "text": "the quick brown fox jumps over the lazy dog"
}

过滤器生成以下标记:

[ the, fox, over, the, lazy, dog ]

添加到分析器

edit

以下创建索引 API请求使用length过滤器来配置一个新的自定义分析器

PUT length_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_length": {
          "tokenizer": "standard",
          "filter": [ "length" ]
        }
      }
    }
  }
}

可配置参数

edit
min
(可选,整数) 标记的最小字符长度。短于该长度的标记将被排除在输出之外。默认为 0
max
(可选, 整数) 标记的最大字符长度。超过此长度的标记将不会包含在输出中。 默认为 Integer.MAX_VALUE,即 2^31-12147483647

自定义

edit

要自定义 length 过滤器,请复制它以创建新自定义标记过滤器的基础。您可以使用其可配置参数修改过滤器。

例如,以下请求创建了一个自定义的 length 过滤器,用于移除长度小于2个字符和长度大于10个字符的词元:

PUT length_custom_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_length_2_to_10_char": {
          "tokenizer": "whitespace",
          "filter": [ "length_2_to_10_char" ]
        }
      },
      "filter": {
        "length_2_to_10_char": {
          "type": "length",
          "min": 2,
          "max": 10
        }
      }
    }
  }
}

限制词元计数词元过滤器

edit

限制输出标记的数量。limit 过滤器通常用于根据标记计数限制文档字段值的大小。

默认情况下,limit 过滤器仅保留流中的第一个标记。例如,该过滤器可以将标记流 [ one, two, three ] 更改为 [ one ]

此过滤器使用 Lucene 的 LimitTokenCountFilter

 If you want to limit the size of field values based on
_character length_, use the <<ignore-above,`ignore_above`>> mapping parameter.

可配置参数

edit
max_token_count
(可选, 整数) 保留的最大token数量。一旦达到此限制,任何剩余的token都将从输出中排除。默认为1
consume_all_tokens
(可选, 布尔值) 如果为true,则limit过滤器会耗尽令牌流,即使已经达到max_token_count。默认为false

示例

edit

以下 analyze API 请求使用 limit 过滤器来保留 quick fox jumps over lazy dog 中的前两个词元:

GET _analyze
{
  "tokenizer": "standard",
    "filter": [
    {
      "type": "limit",
      "max_token_count": 2
    }
  ],
  "text": "quick fox jumps over lazy dog"
}

过滤器生成以下标记:

[ quick, fox ]

添加到分析器

edit

以下创建索引 API请求使用limit过滤器来配置一个新的自定义分析器

PUT limit_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_one_token_limit": {
          "tokenizer": "standard",
          "filter": [ "limit" ]
        }
      }
    }
  }
}

自定义

edit

要自定义 limit 过滤器,请复制它以创建新的自定义令牌过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建一个自定义的 limit 过滤器,仅保留流中的前五个标记:

PUT custom_limit_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_five_token_limit": {
          "tokenizer": "whitespace",
          "filter": [ "five_token_limit" ]
        }
      },
      "filter": {
        "five_token_limit": {
          "type": "limit",
          "max_token_count": 5
        }
      }
    }
  }
}

小写标记过滤器

edit

将标记文本转换为小写。例如,您可以使用 lowercase 过滤器将 THE Lazy DoG 转换为 the lazy dog

除了默认的过滤器外,lowercase 标记过滤器还提供了对 Lucene 的特定语言(如希腊语、爱尔兰语和土耳其语)的小写过滤器的访问。

示例

edit

以下analyze API请求使用默认的lowercase过滤器将THE Quick FoX JUMPs转换为小写:

GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["lowercase"],
  "text" : "THE Quick FoX JUMPs"
}

过滤器生成以下标记:

[ the, quick, fox, jumps ]

添加到分析器

edit

以下创建索引 API请求使用lowercase过滤器来配置一个新的自定义分析器

PUT lowercase_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_lowercase": {
          "tokenizer": "whitespace",
          "filter": [ "lowercase" ]
        }
      }
    }
  }
}

可配置参数

edit
language

(可选,字符串) 特定语言的小写标记过滤器。有效值包括:

greek
使用Lucene的 GreekLowerCaseFilter
irish
使用Lucene的 IrishLowerCaseFilter
turkish
使用Lucene的 TurkishLowerCaseFilter

如果未指定,默认为Lucene的 LowerCaseFilter

自定义

edit

要自定义 lowercase 过滤器,请复制它以创建一个新的自定义词元过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求为希腊语创建一个自定义的 lowercase 过滤器:

PUT custom_lowercase_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "greek_lowercase_example": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["greek_lowercase"]
        }
      },
      "filter": {
        "greek_lowercase": {
          "type": "lowercase",
          "language": "greek"
        }
      }
    }
  }
}

MinHash 分词过滤器

edit

使用MinHash技术为令牌流生成签名。您可以使用MinHash签名来估计文档的相似性。请参阅使用min_hash令牌过滤器进行相似性搜索

The min_hash 过滤器按顺序对令牌流执行以下操作:

  1. 对流中的每个标记进行哈希处理。
  2. 将哈希值分配到桶中,只保留每个桶的最小哈希值。
  3. 将每个桶的最小哈希值作为标记流输出。

此过滤器使用 Lucene 的 MinHashFilter

可配置参数

edit
bucket_count
(可选, 整数) 分配哈希的桶的数量。默认为 512
hash_count
(可选, 整数) 在流中对每个标记进行哈希处理的次数。默认为 1
hash_set_size

(可选, 整数) 每个桶中保留的哈希数。默认为 1

哈希值按升序保留,首先从桶中最小的哈希值开始。

with_rotation
(可选, 布尔值) 如果为true,过滤器会用其循环右侧的第一个非空桶的值填充空桶,前提是hash_set_size1。如果bucket_count参数大于1,此参数默认为true。否则,此参数默认为false

配置min_hash过滤器的提示

edit
  • min_hash 过滤器的输入标记通常应该是从 shingle token filter 生成的 k-words 短语。您应该选择足够大的 k,以使任何给定的短语在文档中出现的概率较低。同时,由于内部每个短语都被哈希为 128 位哈希值,您应该选择足够小的 k,以使所有可能的不同 k-words 短语都能以最小的碰撞被哈希为 128 位哈希值。
  • 我们建议您测试不同的参数值,包括 hash_countbucket_counthash_set_size

    • 为了提高精度,增加 bucket_counthash_set_size 参数。较高的 bucket_counthash_set_size 值增加了不同标记被索引到不同桶中的可能性。
    • 为了提高召回率,增加 hash_count 参数的值。例如,将 hash_count 设置为 2 会以两种不同的方式对每个标记进行哈希处理,从而增加搜索的潜在候选数量。
  • 默认情况下,min_hash 过滤器为每个文档生成 512 个标记。每个标记的大小为 16 字节。这意味着每个文档的大小将增加约 8Kb。
  • min_hash 过滤器用于 Jaccard 相似度。这意味着文档包含某个标记的次数并不重要,重要的是它是否包含该标记。

使用min_hash token filter进行相似性搜索

edit

The min_hash token filter 允许你对文档进行哈希处理以进行相似性搜索。 相似性搜索,或最近邻搜索是一个复杂的问题。 一个简单的解决方案需要对查询文档和索引中的每个文档进行穷举的成对比较。如果索引很大,这是一个禁止性的操作。 已经开发了许多近似的最近邻搜索解决方案,以使相似性搜索更加实用和计算上可行。其中一种解决方案涉及对文档进行哈希处理。

文档通过一种方式进行哈希处理,使得相似的文档更有可能产生相同的哈希码并被放入相同的哈希桶中,而不同的文档则更有可能被哈希到不同的哈希桶中。这种类型的哈希被称为局部敏感哈希(LSH)。

根据构成文档之间相似性的不同因素, 已经提出了各种LSH函数 have been proposed。 对于Jaccard相似性,一个流行的 LSH函数是MinHash。 MinHash生成文档签名的基本思路 是通过对整个索引词汇表应用随机排列(词汇表的随机编号),并记录该排列下文档的最小值(文档中存在的词汇表单词的最小编号)。 排列会运行多次; 将所有排列的最小值组合起来将构成文档的签名。

在实践中,不是使用随机排列,而是选择多个哈希函数。哈希函数为文档的每个标记计算一个哈希码,并选择其中最小的哈希码。所有哈希函数的最小哈希码组合起来形成文档的签名。

自定义并添加到分析器

edit

要自定义 min_hash 过滤器,请复制它以创建新自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下创建索引 API请求 使用以下自定义分词过滤器来配置一个新的 自定义分析器

  • my_shingle_filter,一个自定义的shingle 过滤器my_shingle_filter 仅输出五个词的shingles。
  • my_minhash_filter,一个自定义的min_hash过滤器。my_minhash_filter对每个五个词的shingle进行一次哈希处理。然后它将这些哈希值分配到512个桶中,每个桶只保留最小的哈希值。

该请求还将自定义分析器分配给 fingerprint 字段映射。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "filter": {
        "my_shingle_filter": {      
          "type": "shingle",
          "min_shingle_size": 5,
          "max_shingle_size": 5,
          "output_unigrams": false
        },
        "my_minhash_filter": {
          "type": "min_hash",
          "hash_count": 1,          
          "bucket_count": 512,      
          "hash_set_size": 1,       
          "with_rotation": true     
        }
      },
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [
            "my_shingle_filter",
            "my_minhash_filter"
          ]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "fingerprint": {
        "type": "text",
        "analyzer": "my_analyzer"
      }
    }
  }
}

配置一个自定义的shingle过滤器,以仅输出五个词的shingle。

流中的每个五字片断都被哈希一次。

哈希值被分配到512个桶中。

每个桶中仅保留最小的哈希值。

该过滤器用相邻桶的值填充空桶。

多路复用器分词过滤器

edit

类型为 multiplexer 的令牌过滤器将在同一位置发出多个令牌,每个版本的令牌都已通过不同的过滤器处理。在同一位置的相同输出令牌将被移除。

如果传入的令牌流中存在重复的令牌,那么这些重复的令牌也会被多路复用器移除

选项

edit

过滤器

应用于传入令牌的令牌过滤器列表。这些可以是索引映射中其他地方定义的任何令牌过滤器。过滤器可以使用逗号分隔的字符串进行链式调用,例如 "lowercase, porter_stem" 将对单个令牌应用 lowercase 过滤器,然后应用 porter_stem 过滤器。

Shingle 或 多词同义词 token filters 在 filters 数组中声明时将无法正常工作,因为它们内部会提前读取,而这是 multiplexer 不支持的

preserve_original
如果 true(默认值),则在过滤后的标记之外还会发出原始标记

设置示例

edit

您可以像这样设置它:

PUT /multiplexer_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [ "my_multiplexer" ]
        }
      },
      "filter": {
        "my_multiplexer": {
          "type": "multiplexer",
          "filters": [ "lowercase", "lowercase, porter_stem" ]
        }
      }
    }
  }
}

并像这样测试它:

POST /multiplexer_example/_analyze
{
  "analyzer" : "my_analyzer",
  "text" : "Going HOME"
}

它会回应:

{
  "tokens": [
    {
      "token": "Going",
      "start_offset": 0,
      "end_offset": 5,
      "type": "<ALPHANUM>",
      "position": 0
    },
    {
      "token": "going",
      "start_offset": 0,
      "end_offset": 5,
      "type": "<ALPHANUM>",
      "position": 0
    },
    {
      "token": "go",
      "start_offset": 0,
      "end_offset": 5,
      "type": "<ALPHANUM>",
      "position": 0
    },
    {
      "token": "HOME",
      "start_offset": 6,
      "end_offset": 10,
      "type": "<ALPHANUM>",
      "position": 1
    },
    {
      "token": "home",          
      "start_offset": 6,
      "end_offset": 10,
      "type": "<ALPHANUM>",
      "position": 1
    }
  ]
}

词干提取器也在位置1处生成了一个标记 home,但由于它是该标记的重复项,因此已从标记流中移除

同义词和同义词图过滤器使用其前面的分析链来解析和分析同义词列表,如果该链包含在同一位置生成多个标记的标记过滤器,则会抛出异常。 如果您想将同义词应用于包含多路复用器的标记流,则应将同义词过滤器附加到每个相关的多路复用器过滤器列表中,而不是将其放置在主标记链定义中的多路复用器之后。

N-gram 分词过滤器

edit

从令牌中生成指定长度的 n-grams

例如,您可以使用 ngram 分词过滤器将 fox 转换为 [ f, fo, o, ox, x ]

此过滤器使用 Lucene 的 NGramTokenFilter

The ngram filter is similar to the edge_ngram token filter. 然而, edge_ngram 只输出从词的开头开始的n-gram。

示例

edit

以下 analyze API 请求使用 ngram 过滤器将 Quick fox 转换为1个字符和2个字符的n-gram:

GET _analyze
{
  "tokenizer": "standard",
  "filter": [ "ngram" ],
  "text": "Quick fox"
}

过滤器生成以下标记:

[ Q, Qu, u, ui, i, ic, c, ck, k, f, fo, o, ox, x ]

添加到分析器

edit

以下创建索引 API请求使用ngram过滤器来配置一个新的自定义分析器

PUT ngram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_ngram": {
          "tokenizer": "standard",
          "filter": [ "ngram" ]
        }
      }
    }
  }
}

可配置参数

edit
max_gram
(可选, 整数) n-gram 的最大字符长度。默认为 2
min_gram
(Optional, integer) Minimum length of characters in a gram. Defaults to 1.
preserve_original
(可选, 布尔值) 当设置为true时,发出原始标记。默认为false

您可以使用 index.max_ngram_diff 索引级别设置来控制 max_grammin_gram 值之间的最大允许差异。

自定义

edit

要自定义 ngram 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建了一个自定义的 ngram 过滤器,该过滤器生成3到5个字符的n-grams。该请求还将 index.max_ngram_diff 设置增加到 2

PUT ngram_custom_example
{
  "settings": {
    "index": {
      "max_ngram_diff": 2
    },
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "3_5_grams" ]
        }
      },
      "filter": {
        "3_5_grams": {
          "type": "ngram",
          "min_gram": 3,
          "max_gram": 5
        }
      }
    }
  }
}

规范化分词过滤器

edit

有几种标记过滤器可用于尝试规范化某种语言的特殊字符。

模式捕获分词过滤器

edit

pattern 分词器不同,pattern_capture 分词过滤器会为正则表达式中的每个捕获组发出一个词元。模式不会锚定到字符串的开头和结尾,因此每个模式可以匹配多次,并且允许匹配重叠。

当心病态的正则表达式

模式捕获令牌过滤器使用 Java 正则表达式

一个编写糟糕的正则表达式可能会运行得非常缓慢,甚至抛出StackOverflowError,并导致运行它的节点突然退出。

了解更多关于病态正则表达式及其避免方法

例如,一个模式如下:

"(([a-z]+)(\d*))"

当匹配时:

"abc123def456"

将生成以下标记:[ abc123, abc, 123, def456, def, 456 ]

如果 preserve_original 设置为 true(默认值),那么它还会发出原始标记:abc123def456

这对于索引类似驼峰式的代码特别有用,例如 stripHTML,用户可能会搜索 "strip html""striphtml"

PUT test
{
   "settings" : {
      "analysis" : {
         "filter" : {
            "code" : {
               "type" : "pattern_capture",
               "preserve_original" : true,
               "patterns" : [
                  "(\\p{Ll}+|\\p{Lu}\\p{Ll}+|\\p{Lu}+)",
                  "(\\d+)"
               ]
            }
         },
         "analyzer" : {
            "code" : {
               "tokenizer" : "pattern",
               "filter" : [ "code", "lowercase" ]
            }
         }
      }
   }
}

当用于分析文本时

import static org.apache.commons.lang.StringEscapeUtils.escapeHtml

这会生成标记:[ import, static, org, apache, commons, lang, stringescapeutils, string, escape, utils, escapehtml, escape, html ]

另一个例子是分析电子邮件地址:

PUT test
{
   "settings" : {
      "analysis" : {
         "filter" : {
            "email" : {
               "type" : "pattern_capture",
               "preserve_original" : true,
               "patterns" : [
                  "([^@]+)",
                  "(\\p{L}+)",
                  "(\\d+)",
                  "@(.+)"
               ]
            }
         },
         "analyzer" : {
            "email" : {
               "tokenizer" : "uax_url_email",
               "filter" : [ "email", "lowercase",  "unique" ]
            }
         }
      }
   }
}

当上述分析器用于类似以下的电子邮件地址时:

john-smith_123@foo-bar.com

它将生成以下标记:

john-smith_123@foo-bar.com, john-smith_123,
john, smith, 123, foo-bar.com, foo, bar, com

需要多个模式来允许重叠捕获,但也意味着模式密度较低,更容易理解。

注意:所有标记都在相同的位置发出,并且具有相同的字符偏移量。这意味着,例如,对于使用此分析器的john-smith_123@foo-bar.commatch查询将返回包含这些标记中任意一个的文档,即使在and操作符的情况下也是如此。此外,当与高亮显示结合使用时,整个原始标记将被高亮显示,而不仅仅是匹配的子集。例如,在上面的电子邮件地址中查询"smith"将高亮显示:

  <em>john-smith_123@foo-bar.com</em>

非:

  john-<em>smith</em>_123@foo-bar.com

模式替换分词过滤器

edit

使用正则表达式匹配并替换标记子字符串。

pattern_replace 过滤器使用 Java的正则表达式语法。默认情况下,该过滤器将匹配的子字符串替换为空字符串("")。替换子字符串可以使用Java的 $g 语法 来引用原始令牌文本中的捕获组。

一个编写不佳的正则表达式可能会运行缓慢或返回StackOverflowError,导致运行该表达式的节点突然退出。

了解更多关于 病态正则表达式及其避免方法

此过滤器使用 Lucene 的 PatternReplaceFilter

示例

edit

以下分析API请求使用pattern_replace过滤器在foxes jump lazy dogs中的子字符串dog前加上watch

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "pattern_replace",
      "pattern": "(dog)",
      "replacement": "watch$1"
    }
  ],
  "text": "foxes jump lazy dogs"
}

该过滤器生成以下标记。

[ foxes, jump, lazy, watchdogs ]

可配置参数

edit
all
(可选, 布尔值) 如果为true,所有匹配pattern参数的正则表达式的子字符串都会被替换。如果为false,过滤器仅替换每个标记中第一个匹配的子字符串。默认为true
pattern
(必需,字符串) 正则表达式,使用 Java的正则表达式语法。该过滤器将匹配此模式的标记子字符串替换为replacement参数中的子字符串。
replacement
(可选,字符串) 替换子字符串。默认为空子字符串 ("")。

自定义并添加到分析器

edit

要自定义 pattern_replace 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置的参数来修改过滤器。

以下创建索引 API请求配置了一个新的自定义分析器,使用了一个自定义的pattern_replace过滤器,my_pattern_replace_filter

The my_pattern_replace_filter filter uses the regular expression [£|€] to match and remove the currency symbols £ and . The filter’s all parameter is false, meaning only the first matching symbol in each token is removed.

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "keyword",
          "filter": [
            "my_pattern_replace_filter"
          ]
        }
      },
      "filter": {
        "my_pattern_replace_filter": {
          "type": "pattern_replace",
          "pattern": "[£|€]",
          "replacement": "",
          "all": false
        }
      }
    }
  }
}

音标分词过滤器

edit

The phonetic token filter 是由 analysis-phonetic 插件提供的。

波特词干分析器

edit

为英语语言提供基于Porter词干提取算法算法词干提取

此过滤器往往比其他英语词干提取过滤器(如kstem过滤器)更具侵略性。

The porter_stem filter 等同于 stemmer filter 的 english 变体。

The porter_stem filter uses Lucene’s PorterStemFilter

示例

edit

以下 analyze API 请求使用 porter_stem 过滤器将 the foxes jumping quickly 词干化为 the fox jump quickli

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "porter_stem" ],
  "text": "the foxes jumping quickly"
}

过滤器生成以下标记:

[ the, fox, jump, quickli ]

添加到分析器

edit

以下创建索引 API请求使用porter_stem过滤器来配置一个新的自定义分析器

为了正常工作,porter_stem 过滤器需要小写的词元。为了确保词元是小写的,请在分析器配置中在 porter_stem 过滤器之前添加 lowercase 过滤器。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "whitespace",
          "filter": [
            "lowercase",
            "porter_stem"
          ]
        }
      }
    }
  }
}

谓词脚本令牌过滤器

edit

移除不匹配所提供谓词脚本的标记。该过滤器仅支持内联的 Painless 脚本。脚本在 分析谓词上下文 中进行评估。

示例

edit

以下分析API请求使用predicate_token_filter过滤器,仅输出长度超过三个字符的标记,来自the fox jumps the lazy dog

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "predicate_token_filter",
      "script": {
        "source": """
          token.term.length() > 3
        """
      }
    }
  ],
  "text": "the fox jumps the lazy dog"
}

该过滤器生成以下标记。

[ jumps, lazy ]

API 响应包含每个输出标记的位置和偏移量。请注意,predicate_token_filter 过滤器不会改变标记的原始位置或偏移量。

响应
{
  "tokens" : [
    {
      "token" : "jumps",
      "start_offset" : 8,
      "end_offset" : 13,
      "type" : "word",
      "position" : 2
    },
    {
      "token" : "lazy",
      "start_offset" : 18,
      "end_offset" : 22,
      "type" : "word",
      "position" : 4
    }
  ]
}

可配置参数

edit
script

(必需的, 脚本对象) 包含用于过滤传入令牌的条件的脚本。只有匹配此脚本的令牌才会包含在输出中。

此参数仅支持内联 Painless 脚本。脚本在 分析谓词上下文中进行评估。

自定义并添加到分析器

edit

要自定义 predicate_token_filter 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

以下创建索引 API请求配置了一个新的自定义分析器,使用了一个自定义的predicate_token_filter过滤器,my_script_filter

The my_script_filter 过滤器会移除除 ALPHANUM 类型以外的任何类型的标记。

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [
            "my_script_filter"
          ]
        }
      },
      "filter": {
        "my_script_filter": {
          "type": "predicate_token_filter",
          "script": {
            "source": """
              token.type.contains("ALPHANUM")
            """
          }
        }
      }
    }
  }
}

去除重复词元过滤器

edit

移除同一位置的重复标记。

The remove_duplicates filter uses Lucene’s RemoveDuplicatesTokenFilter(去重过滤器使用Lucene的RemoveDuplicatesTokenFilter)。

示例

edit

要查看 remove_duplicates 过滤器的工作原理,您首先需要生成一个在同一位置包含重复标记的标记流。

以下分析API请求使用了 keyword_repeatstemmer过滤器为jumping dog创建了词干化和非词干化的词元。

GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    "keyword_repeat",
    "stemmer"
  ],
  "text": "jumping dog"
}

API返回以下响应。请注意,位置1中的dog标记是重复的。

{
  "tokens": [
    {
      "token": "jumping",
      "start_offset": 0,
      "end_offset": 7,
      "type": "word",
      "position": 0
    },
    {
      "token": "jump",
      "start_offset": 0,
      "end_offset": 7,
      "type": "word",
      "position": 0
    },
    {
      "token": "dog",
      "start_offset": 8,
      "end_offset": 11,
      "type": "word",
      "position": 1
    },
    {
      "token": "dog",
      "start_offset": 8,
      "end_offset": 11,
      "type": "word",
      "position": 1
    }
  ]
}

要删除其中一个重复的 dog 标记,请将 remove_duplicates 过滤器添加到之前的分析 API 请求中。

GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    "keyword_repeat",
    "stemmer",
    "remove_duplicates"
  ],
  "text": "jumping dog"
}

API返回以下响应。现在位置1中只有一个dog标记。

{
  "tokens": [
    {
      "token": "jumping",
      "start_offset": 0,
      "end_offset": 7,
      "type": "word",
      "position": 0
    },
    {
      "token": "jump",
      "start_offset": 0,
      "end_offset": 7,
      "type": "word",
      "position": 0
    },
    {
      "token": "dog",
      "start_offset": 8,
      "end_offset": 11,
      "type": "word",
      "position": 1
    }
  ]
}

添加到分析器

edit

以下创建索引 API请求使用remove_duplicates过滤器来配置一个新的自定义分析器

这个自定义分析器使用 keyword_repeatstemmer 过滤器来创建一个词干化和非词干化的每个标记的版本。然后,remove_duplicates 过滤器会删除同一位置的任何重复标记。

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_custom_analyzer": {
          "tokenizer": "standard",
          "filter": [
            "keyword_repeat",
            "stemmer",
            "remove_duplicates"
          ]
        }
      }
    }
  }
}

反转分词过滤器

edit

反转流中的每个标记。例如,您可以使用 reverse 过滤器将 cat 更改为 tac

反转的标记对于基于后缀的搜索非常有用, 例如查找以-ion结尾的单词或通过文件扩展名搜索文件名。

此过滤器使用 Lucene 的 ReverseStringFilter

示例

edit

以下analyze API请求使用reverse过滤器来反转quick fox jumps中的每个词元:

GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["reverse"],
  "text" : "quick fox jumps"
}

过滤器生成以下标记:

[ kciuq, xof, spmuj ]

添加到分析器

edit

以下创建索引 API请求使用reverse过滤器来配置一个新的自定义分析器

PUT reverse_example
{
  "settings" : {
    "analysis" : {
      "analyzer" : {
        "whitespace_reverse" : {
          "tokenizer" : "whitespace",
          "filter" : ["reverse"]
        }
      }
    }
  }
}

Shingle 分词过滤器

edit

添加 shingles,或单词 n-grams,通过连接相邻的 tokens 到 token 流中。默认情况下,shingle token filter 输出双词 shingles 和 unigrams。

例如,许多分词器将 the lazy dog 转换为 [ the, lazy, dog ]。您可以使用 shingle 过滤器向此流添加双词组:[ the, the lazy, lazy, lazy dog, dog ]

Shingles 通常用于帮助加速短语查询,例如 match_phrase。我们建议您使用 index-phrases 映射参数在适当的 文本字段上,而不是使用 shingles 过滤器来创建 shingles。

此过滤器使用 Lucene 的 ShingleFilter

示例

edit

以下analyze API请求使用shingle过滤器为quick brown fox jumps的词元流添加两词的词块:

GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [ "shingle" ],
  "text": "quick brown fox jumps"
}

过滤器生成以下标记:

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

要生成2-3个词的短语,请在analyze API请求中添加以下参数:

  • min_shingle_size: 2
  • max_shingle_size: 3
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

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 ]

添加到分析器

edit

以下创建索引 API请求使用shingle过滤器来配置一个新的自定义分析器

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_shingle": {
          "tokenizer": "standard",
          "filter": [ "shingle" ]
        }
      }
    }
  }
}

可配置参数

edit
max_shingle_size

(可选, 整数) 在创建shingles时连接的最大token数量。默认为 2

此值不能低于 min_shingle_size 参数,其默认值为 2。此值与 min_shingle_size 参数之间的差异不能超过 index.max_shingle_diff 索引级别设置,其默认值为 3

min_shingle_size

(可选, 整数) 创建shingles时连接的最小token数量。默认为 2

此值不能超过 max_shingle_size 参数,其默认值为 2max_shingle_size 参数与此值之间的差异不能超过 index.max_shingle_diff 索引级别设置,其默认值为 3

output_unigrams
(可选, 布尔值) 如果 true,输出将包含原始输入的标记。如果 false,输出仅包含短语;原始输入的标记将被移除。默认为 true
output_unigrams_if_no_shingles

如果为true,则输出仅在未生成shingles时包含原始输入标记;如果生成了shingles,则输出仅包含shingles。默认为false

如果这个参数和output_unigrams参数都为true,则只使用output_unigrams参数。

token_separator
(可选,字符串) 用于连接相邻标记以形成拼贴的分隔符。默认为一个空格 (" ")。
filler_token

(可选,字符串) 用于在shingles中替换不包含标记的空位置的字符串。此填充标记仅在shingles中使用,不在原始unigrams中使用。默认值为下划线(_)。

一些标记过滤器,例如 stop 过滤器,在移除位置增量大于一的停用词时会创建空位置。

示例

在以下analyze API请求中,stop过滤器从fox jumps a lazy dog中移除了停用词a,创建了一个空位置。随后的shingle过滤器用加号(+)替换了该空位置。

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 ]

自定义

edit

要自定义 shingle 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下创建索引 API请求 使用自定义的shingle过滤器,my_shingle_filter,来配置一个新的 自定义分析器

The my_shingle_filter filter uses a min_shingle_size of 2 and a max_shingle_size of 5, 这意味着它生成2-5个词的词块。 该过滤器还包括一个output_unigrams参数为false,这意味着 只有词块包含在输出中。

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 分词过滤器

edit

一个使用Snowball生成的词干提取器的过滤器。language参数控制词干提取器,以下是可用的值:阿拉伯语亚美尼亚语巴斯克语加泰罗尼亚语丹麦语荷兰语英语爱沙尼亚语芬兰语法语德语德语2匈牙利语意大利语爱尔兰语Kp立陶宛语Lovins挪威语Porter葡萄牙语罗马尼亚语俄语塞尔维亚语西班牙语瑞典语土耳其语

[8.16.0] 在8.16.0中已弃用。KpLovins 支持将在未来的版本中移除

例如:

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [ "lowercase", "my_snow" ]
        }
      },
      "filter": {
        "my_snow": {
          "type": "snowball",
          "language": "English"
        }
      }
    }
  }
}

词干提取器分词过滤器

edit

为多种语言提供算法词干提取, 其中一些语言有额外的变体。有关支持的语言列表,请参阅 language参数。

当未自定义时,过滤器使用Porter词干提取算法进行英文处理。

示例

edit

以下 analyze API 请求使用 stemmer 过滤器的默认 porter 词干提取算法将 the foxes jumping quickly 提取为 the fox jump quickli

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "stemmer" ],
  "text": "the foxes jumping quickly"
}

过滤器生成以下标记:

[ the, fox, jump, quickli ]

添加到分析器

edit

以下创建索引 API请求使用stemmer过滤器来配置一个新的自定义分析器

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "whitespace",
          "filter": [ "stemmer" ]
        }
      }
    }
  }
}

可配置参数

edit
language

(可选,字符串) 用于词干提取的语言依赖算法。如果同时指定了此参数和name参数,则使用language参数的值。

Valid values for language

有效值按语言排序。默认值为 english。 推荐算法为加粗

阿拉伯语
arabic
亚美尼亚语
armenian
巴斯克语
basque
孟加拉语
bengali
巴西葡萄牙语
brazilian
保加利亚语
bulgarian
加泰罗尼亚语
catalan
捷克语
czech
丹麦语
danish
荷兰语
dutch, dutch_kp [8.16.0] 在8.16.0中已弃用。dutch_kp将在未来版本中移除
英语
english, light_english, lovins [8.16.0] 在8.16.0中已弃用。lovins将在未来版本中移除 , minimal_english, porter2, possessive_english
爱沙尼亚语
estonian
芬兰语
finnish, light_finnish
法语
light_french, french, minimal_french
加利西亚语
galician, minimal_galician (仅复数步骤)
德语
light_german, german, german2, minimal_german
希腊语
greek
印地语
hindi
匈牙利语
hungarian, light_hungarian
印度尼西亚语
indonesian
爱尔兰语
irish
意大利语
light_italian, italian
库尔德语 (索拉尼)
sorani
拉脱维亚语
latvian
立陶宛语
lithuanian
挪威语 (书面挪威语)
norwegian, light_norwegian, minimal_norwegian
挪威语 (尼诺斯克)
light_nynorsk, minimal_nynorsk
波斯语
<
name
language 参数的别名。如果同时指定了此参数和language参数,则使用language参数的值。

自定义

edit

要自定义 stemmer 过滤器,请复制它以创建一个新的自定义词干过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建一个自定义的 stemmer 过滤器,该过滤器使用 light_german 算法对单词进行词干提取:

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "my_stemmer"
          ]
        }
      },
      "filter": {
        "my_stemmer": {
          "type": "stemmer",
          "language": "light_german"
        }
      }
    }
  }
}

词干覆盖标记过滤器

edit

通过应用自定义映射来覆盖词干提取算法,然后保护这些术语不被词干提取器修改。必须放置在任何词干提取过滤器之前。

规则是以 token1[, ..., tokenN] => override 形式进行的映射。

Setting Description

规则

使用的映射规则列表。

rules_path

路径(相对于config位置,或绝对路径)到一个映射列表。

这是一个例子:

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [ "lowercase", "custom_stems", "porter_stem" ]
        }
      },
      "filter": {
        "custom_stems": {
          "type": "stemmer_override",
          "rules_path": "analysis/stemmer_override.txt"
        }
      }
    }
  }
}

文件内容如下:

running, runs => run

stemmer => stemmer

您也可以内联定义覆盖规则:

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [ "lowercase", "custom_stems", "porter_stem" ]
        }
      },
      "filter": {
        "custom_stems": {
          "type": "stemmer_override",
          "rules": [
            "running, runs => run",
            "stemmer => stemmer"
          ]
        }
      }
    }
  }
}

停止词标记过滤器

edit

从标记流中移除停用词

当未自定义时,过滤器默认会移除以下英语停用词:

a, an, and, are, as, at, be, but, by, for, if, in, into, is, it, no, not, of, on, or, such, that, the, their, then, there, these, they, this, to, was, will, with

除了英语外,stop 过滤器还支持预定义的 多种语言的停用词列表。您还可以将您自己的停用词指定为数组或文件。

The stop 过滤器使用 Lucene 的 StopFilter

示例

edit

以下 analyze API 请求使用 stop 过滤器从 a quick fox jumps over the lazy dog 中移除停用词 athe

GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "stop" ],
  "text": "a quick fox jumps over the lazy dog"
}

过滤器生成以下标记:

[ quick, fox, jumps, over, lazy, dog ]

添加到分析器

edit

以下创建索引 API请求使用stop过滤器来配置一个新的自定义分析器

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "whitespace",
          "filter": [ "stop" ]
        }
      }
    }
  }
}

可配置参数

edit
stopwords

(可选,字符串或字符串数组) 语言值,例如 _arabic__thai_。默认为 _english_

每种语言值对应于Lucene中预定义的停用词列表。 请参阅按语言停用词以获取支持的语言值及其停用词。

也接受一个停用词数组。

对于空的停用词列表,使用 _none_

stopwords_path

(可选, 字符串) 指向包含要移除的停用词列表的文件路径。

此路径必须是绝对路径或相对于config位置的相对路径,并且文件必须使用UTF-8编码。文件中的每个停用词必须用换行符分隔。

ignore_case
(可选, 布尔值) 如果为true,则停用词匹配不区分大小写。例如,如果为true,停用词the将匹配并删除TheTHEthe。默认为false
remove_trailing

(可选, 布尔值) 如果true,流中的最后一个标记如果是停用词则会被移除。默认为true

使用带有completion suggester的过滤器时,此参数应为false。这将确保类似green a的查询匹配并建议green apple,同时仍然移除其他停用词。

自定义

edit

要自定义 stop 过滤器,请复制它以创建一个新的自定义词元过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建一个自定义的不区分大小写的 stop 过滤器,该过滤器从 _english_ 停用词列表中删除停用词:

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "my_custom_stop_words_filter" ]
        }
      },
      "filter": {
        "my_custom_stop_words_filter": {
          "type": "stop",
          "ignore_case": true
        }
      }
    }
  }
}

您还可以指定自己的停用词列表。例如,以下请求创建了一个自定义的不区分大小写的stop过滤器,该过滤器仅删除停用词andisthe

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "my_custom_stop_words_filter" ]
        }
      },
      "filter": {
        "my_custom_stop_words_filter": {
          "type": "stop",
          "ignore_case": true,
          "stopwords": [ "and", "is", "the" ]
        }
      }
    }
  }
}

按语言停用词

edit

以下列表包含stopwords参数支持的语言值及其在Lucene中预定义的停用词链接。

_brazilian_ (Brazilian Portuguese)
巴西葡萄牙语停用词
_bulgarian_
保加利亚停用词
_cjk_ (Chinese, Japanese, and Korean)
CJK 停用词
_english_
English stop words
_finnish_
芬兰语停用词
_french_
法语停用词
_german_
德语停用词
_greek_
希腊停用词
_hungarian_
匈牙利停用词
_indonesian_
Indonesian stop words
_italian_
意大利停用词
_lithuanian_
立陶宛语停用词
_norwegian_
挪威语停用词
_persian_
波斯语停用词
_portuguese_
葡萄牙语停用词
_russian_
俄语停用词
_spanish_
西班牙停用词
_swedish_
瑞典停用词
_turkish_
土耳其停用词

同义词分词过滤器

edit

The synonym token filter 允许在分析过程中轻松处理同义词

定义同义词集

edit

同义词集中的同义词是使用同义词规则定义的。 每条同义词规则包含互为同义词的词语。

您可以使用两种格式来定义同义词规则:Solr 和 WordNet。

Solr 格式
edit

此格式使用两种不同的定义:

  • 等效同义词:定义一组等效的词语。词语之间用逗号分隔。例如:

    ipod, i-pod, i pod
    computer, pc, laptop
  • 显式同义词:将一组单词匹配到其他单词。规则定义左侧的单词会扩展为右侧描述的所有可能性。示例:

    personal computer => pc
    sea biscuit, sea biscit => seabiscuit
WordNet 格式
edit

WordNet 定义了跨多行的同义词集。每行包含以下信息:

  • 同义词集的数字标识符
  • 同义词集中的同义词序号
  • 同义词单词
  • 词性标识符:名词 (n),动词 (v),形容词 (a) 或副词 (b)。
  • 同义词网络中单词的深度

以下示例为单词“come”、“advance”和“approach”定义了一个同义词集:

s(100000002,1,'come',v,1,0).
s(100000002,2,'advance',v,1,0).
s(100000002,3,'approach',v,1,0).""";

配置同义词集

edit

同义词可以通过使用同义词API同义词文件或直接在令牌过滤器配置中内联进行配置。 有关每个选项的更多详细信息,请参阅存储您的同义词集

使用 synonyms_set 配置选项来提供通过同义词管理API创建的同义词集:

  "filter": {
    "synonyms_filter": {
      "type": "synonym",
      "synonyms_set": "my-synonym-set",
      "updateable": true
    }
  }

同义词集必须在添加到索引之前存在。 如果创建的索引引用了不存在的同义词集,索引将保持部分创建且无法操作的状态。 从这种情况恢复的唯一方法是确保同义词集存在,然后删除并重新创建索引,或者关闭并重新打开索引。

使用 synonyms_path 提供同义词文件:

  "filter": {
    "synonyms_filter": {
      "type": "synonym",
      "synonyms_path": "analysis/synonym-set.txt"
    }
  }

上述配置了一个 synonym 过滤器,路径为 analysis/synonym-set.txt(相对于 config 位置)。

使用 synonyms 来定义内联同义词:

  "filter": {
    "synonyms_filter": {
      "type": "synonym",
      "synonyms": ["pc => personal computer", "computer, pc, laptop"]
    }
  }

附加设置包括:

  • updateable(默认为false)。如果为true,允许 重新加载搜索分析器以获取对同义词文件的更改。仅用于搜索分析器。
  • expand(默认为true)。 扩展等效同义词规则的定义。 参见扩展等效同义词规则
  • lenient(默认为updateable设置的值)。 如果为true,则在解析同义词规则时忽略错误。 需要注意的是,只有那些无法解析的同义词规则会被忽略。 参见同义词和停止词过滤器以了解无效同义词规则的lenient行为示例。
扩展 等价同义词规则
edit

参数 expand 控制是否扩展等效的同义词规则。 考虑如下定义的同义词:

foo, bar, baz

使用 expand: true,同义词规则将被扩展为:

foo => foo
foo => bar
foo => baz
bar => foo
bar => bar
bar => baz
baz => foo
baz => bar
baz => baz

expand 设置为 false 时,同义词规则不会扩展,并且第一个同义词被视为规范表示。该同义词将等同于:

foo => foo
bar => foo
baz => foo

The expand parameter 不影响显式同义词规则,如 foo, bar => baz

tokenizerignore_case 已弃用
edit

参数 tokenizer 控制用于分词的同义词分词器,此参数用于向后兼容在6.0之前创建的索引。 参数 ignore_case 仅与参数 tokenizer 一起使用。

配置带有同义词令牌过滤器的分析器

edit

要应用同义词,您需要将同义词标记过滤器包含到分析器中:

      "analyzer": {
        "my_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["stemmer", "synonym"]
        }
      }
Token过滤器顺序
edit

对于您的令牌过滤器,顺序很重要。 文本将首先通过同义词过滤器之前的过滤器进行处理,然后再由同义词过滤器进行处理。

Elasticsearch 还会使用分词器链中同义词过滤器之前的分词过滤器来解析同义词文件或同义词集中的条目。 在上面的例子中,同义词分词过滤器放置在一个词干提取器之后。词干提取器也将应用于同义词条目。

由于同义词映射中的条目不能具有堆叠位置,某些分词过滤器可能会导致问题。 产生多个版本的令牌的分词过滤器在解析同义词时可能会选择要发出的令牌版本。 例如,asciifolding 只会产生折叠版本的令牌。 其他如 multiplexerword_delimiter_graphngram 将会抛出错误。

如果你需要构建包含多词过滤器和同义词过滤器的分析器,可以考虑使用multiplexer过滤器,将多词过滤器放在一个分支中,同义词过滤器放在另一个分支中。

同义词和停用词过滤器
edit

同义词和停止词过滤器以以下方式相互作用:

停用词标记过滤器 同义词标记过滤器之前
edit

停用词将从同义词规则定义中移除。 这可能会导致同义词规则出错。

如果宽松设置为,无效的同义词规则在应用分析器更改时可能会导致错误。 对于可重新加载的分析器,这会阻止重新加载和应用更改。 您必须纠正同义词规则中的错误并重新加载分析器。

宽松设置为时,具有无效同义词规则的索引无法重新打开,使其在以下情况下无法操作:

  • 包含索引的节点启动
  • 从关闭状态打开索引
  • 发生节点重启(重新打开分配给该节点的分片)

对于像 foo, bar => baz 这样的 显式同义词规则,并且使用了一个移除 bar 的停止过滤器:

  • 如果lenient设置为false,将会引发错误,因为bar将从同义词规则的左侧移除。
  • 如果lenient设置为true,规则foo => baz将被添加,而bar => baz将被忽略。

如果停用过滤器移除了baz

  • 如果lenient设置为false,将会引发错误,因为baz将从同义词规则的右侧移除。
  • 如果lenient设置为true,同义词将不会生效,因为目标词已被移除。

对于等价同义词规则,如foo, bar, bazexpand: true, 使用一个移除 `bar` 的停止过滤器

  • If lenient is set to false, an error will be raised as bar would be removed from the synonym rule.
  • If lenient is set to true, the synonyms added would be equivalent to the following synonym rules, which do not contain the removed word:
foo => foo
foo => baz
baz => foo
baz => baz
停用词标记过滤器 同义词标记过滤器之后
edit

停止过滤器将从同义词扩展结果中移除这些词条。

例如,一个同义词规则如 foo, bar => baz 和一个移除 baz 的停止过滤器将不会匹配 foobar,因为两者都会被扩展为 baz,而 baz 会被停止过滤器移除。

如果停用词过滤器移除了foo,那么搜索foo将会扩展为baz,而停用词过滤器不会移除baz,因此可能会为baz提供匹配结果。

同义词图标记过滤器

edit

The synonym_graph token filter 允许在分析过程中轻松处理同义词,包括在分析过程中正确处理多词同义词。

为了正确处理多词同义词,此分词过滤器在处理过程中创建了一个图结构的分词流。有关此主题及其各种复杂性的更多信息,请阅读Lucene的TokenStreams实际上是图结构博客文章。

此令牌过滤器旨在仅作为搜索分析器的一部分使用。如果您希望在索引期间应用同义词,请使用标准的同义词令牌过滤器

定义同义词集

edit

同义词集中的同义词是使用同义词规则定义的。 每条同义词规则包含互为同义词的词语。

您可以使用两种格式来定义同义词规则:Solr 和 WordNet。

Solr 格式
edit

此格式使用两种不同的定义:

  • 等效同义词:定义一组等效的词语。词语之间用逗号分隔。例如:

    ipod, i-pod, i pod
    computer, pc, laptop
  • 显式同义词:将一组单词匹配到其他单词。规则定义左侧的单词会扩展为右侧描述的所有可能性。示例:

    personal computer => pc
    sea biscuit, sea biscit => seabiscuit
WordNet 格式
edit

WordNet 定义了跨多行的同义词集。每行包含以下信息:

  • 同义词集的数字标识符
  • 同义词集中的同义词序号
  • 同义词单词
  • 词性标识符:名词 (n),动词 (v),形容词 (a) 或副词 (b)。
  • 同义词网络中单词的深度

以下示例为单词“come”、“advance”和“approach”定义了一个同义词集:

s(100000002,1,'come',v,1,0).
s(100000002,2,'advance',v,1,0).
s(100000002,3,'approach',v,1,0).""";

配置同义词集

edit

同义词可以通过使用同义词API同义词文件或直接在令牌过滤器配置中内联进行配置。 有关每个选项的更多详细信息,请参阅存储您的同义词集

使用 synonyms_set 配置选项来提供通过同义词管理API创建的同义词集:

  "filter": {
    "synonyms_filter": {
      "type": "synonym_graph",
      "synonyms_set": "my-synonym-set",
      "updateable": true
    }
  }

同义词集必须在添加到索引之前存在。 如果创建的索引引用了不存在的同义词集,索引将保持部分创建且无法操作的状态。 从这种情况恢复的唯一方法是确保同义词集存在,然后删除并重新创建索引,或者关闭并重新打开索引。

使用 synonyms_path 提供同义词文件:

  "filter": {
    "synonyms_filter": {
      "type": "synonym_graph",
      "synonyms_path": "analysis/synonym-set.txt"
    }
  }

上述配置了一个 synonym 过滤器,路径为 analysis/synonym-set.txt(相对于 config 位置)。

使用 synonyms 来定义内联同义词:

  "filter": {
    "synonyms_filter": {
      "type": "synonym_graph",
      "synonyms": ["pc => personal computer", "computer, pc, laptop"]
    }
  }

附加设置包括:

  • updateable(默认为false)。如果为true,允许 重新加载搜索分析器以获取对同义词文件的更改。仅用于搜索分析器。
  • expand(默认为true)。 扩展等效同义词规则的定义。 参见扩展等效同义词规则
  • lenient(默认为updateable设置的值)。 如果为true,则在解析同义词规则时忽略错误。 需要注意的是,只有那些无法解析的同义词规则会被忽略。 参见同义词和停止词过滤器中关于无效同义词规则的lenient行为的示例。
expand 等价同义词规则
edit

参数 expand 控制是否扩展等效的同义词规则。 考虑如下定义的同义词:

foo, bar, baz

使用 expand: true,同义词规则将被扩展为:

foo => foo
foo => bar
foo => baz
bar => foo
bar => bar
bar => baz
baz => foo
baz => bar
baz => baz

expand 设置为 false 时,同义词规则不会扩展,并且第一个同义词被视为规范表示。该同义词将等同于:

foo => foo
bar => foo
baz => foo

The expand parameter 不影响显式同义词规则,如 foo, bar => baz

tokenizerignore_case 已弃用
edit

参数 tokenizer 控制用于分词的同义词分词器,此参数用于向后兼容在6.0之前创建的索引。 参数 ignore_case 仅与参数 tokenizer 一起使用。

使用同义词图令牌过滤器配置分析器

edit

要应用同义词,您需要将同义词图标记过滤器包含到分析器中:

      "analyzer": {
        "my_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["stemmer", "synonym_graph"]
        }
      }
Token过滤器顺序
edit

对于您的令牌过滤器,顺序很重要。 文本将首先通过同义词过滤器之前的过滤器进行处理,然后再由同义词过滤器进行处理。

Elasticsearch 还会使用分词器链中同义词过滤器之前的分词过滤器来解析同义词文件或同义词集中的条目。 在上面的例子中,同义词图过滤器放置在词干提取器之后。词干提取器也将应用于同义词条目。

由于同义词映射中的条目不能具有堆叠位置,某些分词过滤器可能会导致问题。 产生多个版本的令牌的分词过滤器在解析同义词时可能会选择要发出的令牌版本。 例如,asciifolding 只会产生折叠版本的令牌。 其他如 multiplexerword_delimiter_graphngram 将会抛出错误。

如果你需要构建包含多词过滤器和同义词过滤器的分析器,可以考虑使用multiplexer过滤器,将多词过滤器放在一个分支中,同义词过滤器放在另一个分支中。

同义词和停用词过滤器
edit

同义词和停止词过滤器以以下方式相互作用:

停用词标记过滤器 同义词标记过滤器之前
edit

停用词将从同义词规则定义中移除。 这可能会导致同义词规则出错。

如果宽松设置为,无效的同义词规则在应用分析器更改时可能会导致错误。 对于可重新加载的分析器,这会阻止重新加载和应用更改。 您必须纠正同义词规则中的错误并重新加载分析器。

宽松设置为时,具有无效同义词规则的索引无法重新打开,使其在以下情况下无法操作:

  • 包含索引的节点启动
  • 从关闭状态打开索引
  • 发生节点重启(重新打开分配给该节点的分片)

对于像 foo, bar => baz 这样的 显式同义词规则,并且使用了一个移除 bar 的停止过滤器:

  • 如果lenient设置为false,将会引发错误,因为bar将从同义词规则的左侧移除。
  • 如果lenient设置为true,规则foo => baz将被添加,而bar => baz将被忽略。

如果停用过滤器移除了baz

  • 如果lenient设置为false,将会引发错误,因为baz将从同义词规则的右侧移除。
  • 如果lenient设置为true,同义词将不会生效,因为目标词已被移除。

对于等价同义词规则,如foo, bar, bazexpand: true, 使用一个移除 `bar` 的停止过滤器

  • 如果 lenient 设置为 false,将会引发错误,因为 bar 将从同义词规则中移除。
  • 如果 lenient 设置为 true,添加的同义词将等同于以下不包含已移除单词的同义词规则:
foo => foo
foo => baz
baz => foo
baz => baz
停用词标记过滤器 同义词标记过滤器之后
edit

停止过滤器将从同义词扩展结果中移除这些词条。

例如,一个同义词规则如 foo, bar => baz 和一个移除 baz 的停止过滤器将不会匹配 foobar,因为两者都会被扩展为 baz,而 baz 会被停止过滤器移除。

如果停用词过滤器移除了foo,那么搜索foo将被扩展为baz,由于停用词过滤器没有移除baz,因此可能会匹配到baz

修剪词元过滤器

edit

移除流中每个标记的前导和尾随空白。虽然这可以改变标记的长度,但trim过滤器不会改变标记的偏移量。

The trim filter uses Lucene’s TrimFilter.

许多常用的分词器,例如 standardwhitespace 分词器,默认会去除空白字符。使用这些分词器时,您不需要添加单独的 trim 过滤器。

示例

edit

要查看 trim 过滤器的工作原理,您首先需要生成一个包含空格的标记。

以下分析API请求使用关键词分词器来生成一个" fox "的词元。

GET _analyze
{
  "tokenizer" : "keyword",
  "text" : " fox "
}

API返回以下响应。请注意," fox " 标记包含了原始文本中的空白字符。请注意,尽管标记的长度发生了变化,但 start_offsetend_offset 保持不变。

{
  "tokens": [
    {
      "token": " fox ",
      "start_offset": 0,
      "end_offset": 5,
      "type": "word",
      "position": 0
    }
  ]
}

要去除空白,请在之前的分析API请求中添加trim过滤器。

GET _analyze
{
  "tokenizer" : "keyword",
  "filter" : ["trim"],
  "text" : " fox "
}

API返回以下响应。返回的fox令牌不包含任何前导或尾随空白。

{
  "tokens": [
    {
      "token": "fox",
      "start_offset": 0,
      "end_offset": 5,
      "type": "word",
      "position": 0
    }
  ]
}

添加到分析器

edit

以下创建索引 API请求使用trim过滤器来配置一个新的自定义分析器

PUT trim_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "keyword_trim": {
          "tokenizer": "keyword",
          "filter": [ "trim" ]
        }
      }
    }
  }
}

截断词元过滤器

edit

截断超过指定字符限制的标记。此限制默认为10,但可以使用length参数进行自定义。

例如,您可以使用 truncate 过滤器将所有标记缩短为 3 个字符或更少,将 jumping fox 更改为 jum fox

此过滤器使用 Lucene 的 TruncateTokenFilter

示例

edit

以下analyze API请求使用了truncate过滤器 来缩短超过10个字符的标记 在the quinquennial extravaganza carried on中:

GET _analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["truncate"],
  "text" : "the quinquennial extravaganza carried on"
}

过滤器生成以下标记:

[ the, quinquenni, extravagan, carried, on ]

添加到分析器

edit

以下创建索引 API请求使用truncate过滤器来配置一个新的自定义分析器

PUT custom_truncate_example
{
  "settings" : {
    "analysis" : {
      "analyzer" : {
        "standard_truncate" : {
        "tokenizer" : "standard",
        "filter" : ["truncate"]
        }
      }
    }
  }
}

可配置参数

edit
length
(可选, 整数) 每个标记的字符限制。超过此限制的标记将被截断。 默认为 10

自定义

edit

要自定义 truncate 过滤器,请复制它以创建新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下请求创建一个自定义的 truncate 过滤器,5_char_trunc,它将标记缩短为 length5 或更少的字符:

PUT 5_char_words_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "lowercase_5_char": {
          "tokenizer": "lowercase",
          "filter": [ "5_char_trunc" ]
        }
      },
      "filter": {
        "5_char_trunc": {
          "type": "truncate",
          "length": 5
        }
      }
    }
  }
}

唯一标记过滤器

edit

从流中移除重复的标记。例如,您可以使用 unique 过滤器将 the lazy lazy dog 更改为 the lazy dog

如果将 only_on_same_position 参数设置为 true,则 unique 过滤器仅删除 在相同位置 的重复标记。

only_on_same_positiontrue 时,unique 过滤器的工作方式与 remove_duplicates 过滤器相同。

示例

edit

以下analyze API请求使用unique过滤器 从the quick fox jumps the lazy fox中移除重复的标记:

GET _analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["unique"],
  "text" : "the quick fox jumps the lazy fox"
}

该过滤器移除了重复的标记 thefox,生成了以下输出:

[ the, quick, fox, jumps, lazy ]

添加到分析器

edit

以下创建索引 API请求使用unique过滤器来配置一个新的自定义分析器

PUT custom_unique_example
{
  "settings" : {
    "analysis" : {
      "analyzer" : {
        "standard_truncate" : {
        "tokenizer" : "standard",
        "filter" : ["unique"]
        }
      }
    }
  }
}

可配置参数

edit
only_on_same_position
(可选,布尔值) 如果为true,则仅在相同位置移除重复的标记。 默认为false

自定义

edit

要自定义 unique 过滤器,请复制它以创建新的自定义令牌过滤器的基础。您可以使用其可配置的参数来修改过滤器。

例如,以下请求创建一个自定义的 unique 过滤器,并将 only_on_same_position 设置为 true

PUT letter_unique_pos_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "letter_unique_pos": {
          "tokenizer": "letter",
          "filter": [ "unique_pos" ]
        }
      },
      "filter": {
        "unique_pos": {
          "type": "unique",
          "only_on_same_position": true
        }
      }
    }
  }
}

大写分词过滤器

edit

将标记文本转换为大写。例如,您可以使用 uppercase 过滤器 将 the Lazy DoG 转换为 THE LAZY DOG

此过滤器使用 Lucene 的 UpperCaseFilter

根据语言的不同,一个大写字符可能会映射到多个小写字符。使用uppercase过滤器可能会导致小写字符信息的丢失。

为了避免这种损失但仍然保持一致的字母大小写,请使用lowercase过滤器。

示例

edit

以下 analyze API 请求使用默认的 uppercase 过滤器将 the Quick FoX JUMPs 转换为大写:

GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["uppercase"],
  "text" : "the Quick FoX JUMPs"
}

过滤器生成以下标记:

[ THE, QUICK, FOX, JUMPS ]

添加到分析器

edit

以下创建索引 API请求使用uppercase过滤器来配置一个新的自定义分析器

PUT uppercase_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_uppercase": {
          "tokenizer": "whitespace",
          "filter": [ "uppercase" ]
        }
      }
    }
  }
}

单词分隔符分词过滤器

edit

我们建议使用 word_delimiter_graph 而不是 word_delimiter 过滤器。

The word_delimiter 过滤器可能会生成无效的词元图。请参阅 word_delimiter_graphword_delimiter 之间的差异

The word_delimiter 过滤器也使用了Lucene的 WordDelimiterFilter, 该过滤器已被标记为弃用。

在非字母数字字符处拆分标记。word_delimiter 过滤器还基于一组规则执行可选的标记规范化。默认情况下,过滤器使用以下规则:

  • 在非字母数字字符处分割标记。 过滤器使用这些字符作为分隔符。 例如:Super-DuperSuper, Duper
  • 移除每个标记的前导或尾随分隔符。 例如:XL---42+'Autocoder'XL, 42, Autocoder
  • 在字母大小写转换处分割标记。 例如:PowerShotPower, Shot
  • 在字母数字转换处分割标记。 例如:XL500XL, 500
  • 移除每个标记末尾的英语所有格 ('s)。 例如:Neil'sNeil

The word_delimiter 过滤器旨在从复杂的标识符(如产品ID或零件编号)中去除标点符号。对于这些用例,我们建议使用 word_delimiter 过滤器与 keyword 分词器。

避免使用 word_delimiter 过滤器来分割连字符连接的单词,例如 wi-fi。因为用户通常会同时搜索带有和不带连字符的这些单词,我们建议使用 synonym_graph 过滤器来代替。

示例

edit

以下分析API请求使用word_delimiter过滤器将Neil's-Super-Duper-XL500--42+AutoCoder拆分为使用过滤器默认规则的标准化标记:

GET /_analyze
{
  "tokenizer": "keyword",
  "filter": [ "word_delimiter" ],
  "text": "Neil's-Super-Duper-XL500--42+AutoCoder"
}

过滤器生成以下标记:

[ Neil, Super, Duper, XL, 500, 42, Auto, Coder ]

添加到分析器

edit

以下创建索引 API请求使用word_delimiter过滤器来配置一个新的自定义分析器

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "keyword",
          "filter": [ "word_delimiter" ]
        }
      }
    }
  }
}

避免在使用移除标点符号的分词器(如standard分词器)时使用word_delimiter过滤器。这可能会阻止word_delimiter过滤器正确地分割词元。它还可能干扰过滤器的可配置参数,例如catenate_allpreserve_original。我们建议使用keywordwhitespace分词器。

可配置参数

edit
catenate_all

(可选, 布尔值) 如果true,过滤器会为通过非字母字符分隔的字母数字字符链生成连接的标记。例如: super-duper-xl-500 → [ super, superduperxl500, duper, xl, 500 ]. 默认为false

当用于搜索分析时,连接的标记可能会对依赖于标记位置进行匹配的match_phrase查询和其他查询造成问题。如果你计划使用这些查询,请避免将此参数设置为true

catenate_numbers

(可选, 布尔值) 如果为true,过滤器会为通过非字母数字分隔符分隔的数字字符链生成连接的标记。例如:01-02-03 → [ 01, 010203, 02, 03 ]。默认为false

当用于搜索分析时,连接的标记可能会对依赖于标记位置进行匹配的match_phrase查询和其他查询造成问题。如果你计划使用这些查询,请避免将此参数设置为true

catenate_words

(可选, 布尔值) 如果为true,过滤器会为字母字符链生成连接的标记,这些字母字符链由非字母字符分隔。例如:super-duper-xl → [ super, superduperxl, duper, xl ]。默认为false

当用于搜索分析时,连接的标记可能会导致match_phrase查询和其他依赖于标记位置进行匹配的查询出现问题。如果你计划使用这些查询,请避免将此参数设置为true

generate_number_parts
(可选, 布尔值) 如果 true,过滤器将包含仅由数字字符组成的标记在输出中。如果 false,过滤器将排除这些标记从输出中。 默认为 true
generate_word_parts
(可选, 布尔值) 如果true,过滤器将包含仅由字母字符组成的标记在输出中。如果false,过滤器将排除这些标记在输出中。 默认为true
preserve_original
(可选, 布尔值) 如果true,过滤器将在输出中包含任何拆分标记的原始版本。这个原始版本包括非字母数字分隔符。例如: super-duper-xl-500 → [ super-duper-xl-500, super, duper, xl, 500 ]。默认为false
protected_words
(可选,字符串数组) 过滤器不会拆分的标记数组。
protected_words_path

(可选,字符串) 包含过滤器不会拆分的令牌列表的文件路径。

此路径必须是绝对路径或相对于config位置的相对路径,并且文件必须使用UTF-8编码。文件中的每个标记必须用换行符分隔。

split_on_case_change
(可选, 布尔值) 如果为true,过滤器会在字母大小写转换处拆分标记。例如: camelCase → [ camel, Case ]。默认为true
split_on_numerics
(可选, 布尔值) 如果为true,过滤器会在字母和数字的过渡处拆分标记。例如: j2se → [ j, 2, se ]。默认为true
stem_english_possessive
(可选, 布尔值) 如果为true,过滤器将移除每个词末尾的英语所有格符号('s)。例如:O'Neil's → [ O, Neil ]。默认为true
type_table

(可选, 字符串数组) 自定义字符类型映射的数组。这允许你将非字母数字字符映射为数字或字母数字,以避免在这些字符上进行分割。

例如,以下数组将加号(+)和减号(-)字符映射为字母数字,这意味着它们不会被视为分隔符:

[ "+ => ALPHA", "- => ALPHA" ]

支持的类型包括:

  • ALPHA (字母)
  • ALPHANUM (字母数字)
  • DIGIT (数字)
  • LOWER (小写字母)
  • SUBWORD_DELIM (非字母数字分隔符)
  • UPPER (大写字母)
type_table_path

(可选, 字符串) 包含自定义字符类型映射的文件路径。这允许你将非字母数字字符映射为数字或字母数字,以避免在这些字符上进行分割。

例如,此文件的内容可能包含以下内容:

# 将 $, %, '.', 和 ',' 字符映射为 DIGIT
# 这对于财务数据可能很有用。
$ => DIGIT
% => DIGIT
. => DIGIT
\\u002C => DIGIT

# 在某些情况下,你可能不希望在 ZWJ 上进行分割
# 这也测试了我们是否需要更大的 byte[]
# 参见 https://en.wikipedia.org/wiki/Zero-width_joiner
\\u200D => ALPHANUM

支持的类型包括:

  • ALPHA (字母)
  • ALPHANUM (字母数字)
  • DIGIT (数字)
  • LOWER (小写字母)
  • SUBWORD_DELIM (非字母数字分隔符)
  • UPPER (大写字母)

此文件路径必须是绝对路径或相对于 config 位置的相对路径,并且文件必须使用 UTF-8 编码。文件中的每个映射必须用换行符分隔。

自定义

edit

要自定义 word_delimiter 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下请求创建了一个 word_delimiter 过滤器,该过滤器使用以下规则:

  • 在非字母数字字符处拆分标记,除了连字符(-)字符。
  • 从每个标记中移除前导或尾随的分隔符。
  • 不要在字母大小写转换处拆分标记。
  • 不要在字母与数字转换处拆分标记。
  • 从每个标记的末尾移除英语所有格('s)。
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "keyword",
          "filter": [ "my_custom_word_delimiter_filter" ]
        }
      },
      "filter": {
        "my_custom_word_delimiter_filter": {
          "type": "word_delimiter",
          "type_table": [ "- => ALPHA" ],
          "split_on_case_change": false,
          "split_on_numerics": false,
          "stem_english_possessive": true
        }
      }
    }
  }
}

单词分隔符图令牌过滤器

edit

在非字母数字字符处拆分标记。word_delimiter_graph 过滤器还会根据一组规则执行可选的标记规范化。默认情况下,过滤器使用以下规则:

  • 在非字母数字字符处拆分标记。 过滤器使用这些字符作为分隔符。 例如:Super-DuperSuper, Duper
  • 移除每个标记的前导或尾随分隔符。 例如:XL---42+'Autocoder'XL, 42, Autocoder
  • 在字母大小写转换处拆分标记。 例如:PowerShotPower, Shot
  • 在字母数字转换处拆分标记。 例如:XL500XL, 500
  • 移除每个标记末尾的英语所有格 ('s)。 例如:Neil'sNeil

The word_delimiter_graph filter uses Lucene’s WordDelimiterGraphFilter

The word_delimiter_graph 过滤器旨在去除复杂标识符(如产品ID或零件编号)中的标点符号。对于这些用例,我们建议使用 word_delimiter_graph 过滤器与 keyword 分词器。

避免使用 word_delimiter_graph 过滤器来拆分连字符连接的单词,例如 wi-fi。因为用户通常会同时搜索带有和不带连字符的这些单词,我们建议使用 synonym_graph 过滤器。

示例

edit

以下分析API请求使用word_delimiter_graph过滤器将Neil's-Super-Duper-XL500--42+AutoCoder拆分为使用过滤器默认规则的规范化标记:

GET /_analyze
{
  "tokenizer": "keyword",
  "filter": [ "word_delimiter_graph" ],
  "text": "Neil's-Super-Duper-XL500--42+AutoCoder"
}

过滤器生成以下标记:

[ Neil, Super, Duper, XL, 500, 42, Auto, Coder ]

添加到分析器

edit

以下创建索引 API请求使用word_delimiter_graph过滤器来配置一个新的自定义分析器

PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "keyword",
          "filter": [ "word_delimiter_graph" ]
        }
      }
    }
  }
}

避免在使用移除标点的分词器(如standard分词器)时使用word_delimiter_graph过滤器。这可能会阻止word_delimiter_graph过滤器正确地分割标记。它还可能干扰过滤器的可配置参数,例如catenate_allpreserve_original。我们建议使用keywordwhitespace分词器代替。

可配置参数

edit
adjust_offsets

(可选, 布尔值) 如果true,过滤器会调整分割或连接的标记的偏移量,以更好地反映它们在标记流中的实际位置。默认为true

如果你的分析器使用了过滤器,例如trim过滤器,这些过滤器在不改变偏移量的情况下改变了词元的长度,请将adjust_offsets设置为false。否则,word_delimiter_graph过滤器可能会生成具有非法偏移量的词元。

catenate_all

(可选, 布尔值) 如果 true,过滤器会为通过非字母字符分隔的字母数字字符链生成连接的标记。例如: super-duper-xl-500 → [ superduperxl500, super, duper, xl, 500 ]。 默认为 false

将此参数设置为 true 会生成多位置标记,这些标记不受索引支持。

如果此参数为true,请避免在索引分析器中使用此过滤器,或者在此过滤器之后使用flatten_graph过滤器,以使令牌流适合索引。

当用于搜索分析时,连接的标记可能会导致match_phrase查询和其他依赖于标记位置进行匹配的查询出现问题。如果你计划使用这些查询,请避免将此参数设置为true

catenate_numbers

(可选, 布尔值) 如果为true,过滤器会对由非字母数字分隔符分隔的数字字符链生成连接的标记。例如:01-02-03 → [ 010203, 01, 02, 03 ]。默认为false

将此参数设置为 true 会生成多位置标记,这些标记不受索引支持。

如果此参数为true,请避免在索引分析器中使用此过滤器,或者在此过滤器之后使用flatten_graph过滤器,以使令牌流适合索引。

当用于搜索分析时,连接的标记可能会对依赖于标记位置进行匹配的match_phrase查询和其他查询造成问题。如果你计划使用这些查询,请避免将此参数设置为true

catenate_words

(可选, 布尔值) 如果为true,过滤器会为字母字符链生成连接的标记,这些字母字符链由非字母字符分隔。例如:super-duper-xl → [ superduperxl, super, duper, xl ]。默认为false

将此参数设置为 true 会生成多位置标记,这些标记不受索引支持。

如果此参数为true,请避免在索引分析器中使用此过滤器,或者在此过滤器之后使用flatten_graph过滤器,以使令牌流适合索引。

当用于搜索分析时,连接的标记可能会对依赖于标记位置进行匹配的match_phrase查询和其他查询造成问题。如果你计划使用这些查询,请避免将此参数设置为true

generate_number_parts
(可选, 布尔值) 如果 true,过滤器将包含仅由数字字符组成的标记在输出中。如果 false,过滤器将排除这些标记从输出中。 默认为 true
generate_word_parts
(可选, 布尔值) 如果true,过滤器将包含仅由字母字符组成的标记在输出中。如果false,过滤器将排除这些标记在输出中。 默认为true
ignore_keywords
(可选, 布尔值) 如果为true,过滤器将跳过具有keyword属性为true的标记。 默认为false
preserve_original

(可选, 布尔值) 如果true,过滤器会在输出中包含任何拆分标记的原始版本。这个原始版本包括非字母数字的分隔符。例如: super-duper-xl-500 → [ super-duper-xl-500, super, duper, xl, 500 ]。默认为false

将此参数设置为 true 会生成多位置标记,这些标记不受索引支持。

如果此参数为true,请避免在索引分析器中使用此过滤器,或者在此过滤器之后使用flatten_graph过滤器,以使令牌流适合索引。

protected_words
(可选, 字符串数组) 过滤器不会拆分的标记数组。
protected_words_path

(可选,字符串) 包含过滤器不会拆分的令牌列表的文件路径。

此路径必须是绝对路径或相对于config位置的相对路径,并且文件必须使用UTF-8编码。文件中的每个令牌必须用换行符分隔。

split_on_case_change
(可选, 布尔值) 如果为true,过滤器会在字母大小写转换处拆分标记。例如: camelCase → [ camel, Case ]。默认为true
split_on_numerics
(可选, 布尔值) 如果为true,过滤器会在字母和数字的过渡处拆分标记。例如: j2se → [ j, 2, se ]。默认为true
stem_english_possessive
(可选, 布尔值) 如果为true,过滤器将移除每个词末尾的英语所有格符号('s)。例如:O'Neil's → [ O, Neil ]。默认为true
type_table

(可选, 字符串数组) 自定义字符类型映射的数组。这允许你将非字母数字字符映射为数字或字母数字,以避免在这些字符上进行分割。

例如,以下数组将加号(+)和连字符(-)字符映射为字母数字,这意味着它们不会被视为分隔符:

[ "+ => ALPHA", "- => ALPHA" ]

支持的类型包括:

  • ALPHA (字母)
  • ALPHANUM (字母数字)
  • DIGIT (数字)
  • LOWER (小写字母)
  • SUBWORD_DELIM (非字母数字分隔符)
  • UPPER (大写字母)
type_table_path

(可选, 字符串) 包含自定义字符类型映射的文件路径。这允许你将非字母数字字符映射为数字或字母数字,以避免在这些字符上进行分割。

例如,此文件的内容可能包含以下内容:

# 将 $, %, '.', 和 ',' 字符映射为 DIGIT
# 这对于财务数据可能很有用。
$ => DIGIT
% => DIGIT
. => DIGIT
\\u002C => DIGIT

# 在某些情况下,你可能不希望在 ZWJ 上进行分割
# 这也测试了我们是否需要更大的 byte[]
# 参见 https://en.wikipedia.org/wiki/Zero-width_joiner
\\u200D => ALPHANUM

支持的类型包括:

  • ALPHA (字母)
  • ALPHANUM (字母数字)
  • DIGIT (数字)
  • LOWER (小写字母)
  • SUBWORD_DELIM (非字母数字分隔符)
  • UPPER (大写字母)

此文件路径必须是绝对路径或相对于 config 位置的相对路径,并且文件必须使用 UTF-8 编码。文件中的每个映射必须用换行符分隔。

自定义

edit

要自定义 word_delimiter_graph 过滤器,请复制它以创建一个新的自定义分词过滤器的基础。您可以使用其可配置参数来修改过滤器。

例如,以下请求创建了一个 word_delimiter_graph 过滤器,该过滤器使用以下规则:

  • 在非字母数字字符处拆分标记,除了连字符(-)字符。
  • 从每个标记中移除前导或尾随的分隔符。
  • 不要在字母大小写转换处拆分标记。
  • 不要在字母数字转换处拆分标记。
  • 从每个标记的末尾移除英语所有格('s)。
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "keyword",
          "filter": [ "my_custom_word_delimiter_graph_filter" ]
        }
      },
      "filter": {
        "my_custom_word_delimiter_graph_filter": {
          "type": "word_delimiter_graph",
          "type_table": [ "- => ALPHA" ],
          "split_on_case_change": false,
          "split_on_numerics": false,
          "stem_english_possessive": true
        }
      }
    }
  }
}

word_delimiter_graphword_delimiter 之间的区别

edit

无论是 word_delimiter_graph 还是 word_delimiter 过滤器,当以下任一参数为 true 时,都会生成跨越多个位置的标记:

然而,只有 word_delimiter_graph 过滤器为多位置标记分配了一个 positionLength 属性,该属性指示标记跨越的位置数。这确保了 word_delimiter_graph 过滤器始终生成有效的 token graphs

The word_delimiter filter 不会为多位置的token分配一个 positionLength 属性。这意味着它为包含这些token的流生成了无效的图。

虽然索引不支持包含多位置标记的标记图,但诸如match_phrase查询之类的查询可以使用这些图从单个查询字符串生成多个子查询。

要查看由 word_delimiterword_delimiter_graph 过滤器生成的标记图有何不同,请查看以下示例。

示例

基本词元图

当以下参数为false时,word_delimiterword_delimiter_graph 都会为 PowerShot2000 生成以下词元图:

此图不包含多位置标记。所有标记仅跨越一个位置。

token graph basic

word_delimiter_graph 图与多位置标记

catenate_wordstrue 时,word_delimiter_graph 过滤器为 PowerShot2000 生成以下词元图。

此图正确地指示了连接的 PowerShot 标记跨越了两个位置。

token graph wdg

word_delimiter 图与多位置标记

catenate_wordstrue 时,word_delimiter 过滤器为 PowerShot2000 生成以下词元图。

请注意,连接的 PowerShot 标记应跨越两个位置,但在标记图中仅跨越一个位置,使其无效。

token graph wd