mirror of
https://github.com/explosion/spaCy.git
synced 2024-11-11 12:18:04 +03:00
282 lines
8.6 KiB
Plaintext
282 lines
8.6 KiB
Plaintext
//- 💫 DOCS > API > MATCHER
|
||
|
||
include ../_includes/_mixins
|
||
|
||
+infobox("Changed in v2.0", "⚠️")
|
||
| As of spaCy 2.0, #[code Matcher.add_pattern] and #[code Matcher.add_entity]
|
||
| are deprecated and have been replaced with a simpler
|
||
| #[+api("matcher#add") #[code Matcher.add]] that lets you add a list of
|
||
| patterns and a callback for a given match ID. #[code Matcher.get_entity]
|
||
| is now called #[+api("matcher#get") #[code matcher.get]].
|
||
| #[code Matcher.load] (not useful, as it didn't allow specifying callbacks),
|
||
| and #[code Matcher.has_entity] (now redundant) have been removed. The
|
||
| concept of "acceptor functions" has also been retired – this logic can
|
||
| now be handled in the callback functions.
|
||
|
||
+h(2, "init") Matcher.__init__
|
||
+tag method
|
||
|
||
p Create the rule-based #[code Matcher].
|
||
|
||
+aside-code("Example").
|
||
from spacy.matcher import Matcher
|
||
|
||
patterns = {'HelloWorld': [{'LOWER': 'hello'}, {'LOWER': 'world'}]}
|
||
matcher = Matcher(nlp.vocab)
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code vocab]
|
||
+cell #[code Vocab]
|
||
+cell
|
||
| The vocabulary object, which must be shared with the documents
|
||
| the matcher will operate on.
|
||
|
||
+row
|
||
+cell #[code patterns]
|
||
+cell dict
|
||
+cell Patterns to add to the matcher, keyed by ID.
|
||
|
||
+row("foot")
|
||
+cell returns
|
||
+cell #[code Matcher]
|
||
+cell The newly constructed object.
|
||
|
||
+h(2, "call") Matcher.__call__
|
||
+tag method
|
||
|
||
p Find all token sequences matching the supplied patterns on the #[code Doc].
|
||
|
||
+aside-code("Example").
|
||
from spacy.matcher import Matcher
|
||
|
||
matcher = Matcher(nlp.vocab)
|
||
pattern = [{'LOWER': "hello"}, {'LOWER': "world"}]
|
||
matcher.add("HelloWorld", None, pattern)
|
||
doc = nlp(u'hello world!')
|
||
matches = matcher(doc)
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code doc]
|
||
+cell #[code Doc]
|
||
+cell The document to match over.
|
||
|
||
+row("foot")
|
||
+cell returns
|
||
+cell list
|
||
+cell
|
||
| A list of #[code (match_id, start, end)] tuples, describing the
|
||
| matches. A match tuple describes a span #[code doc[start:end]].
|
||
| The #[code match_id] is the ID of the added match pattern.
|
||
|
||
+infobox("Important note")
|
||
| By default, the matcher #[strong does not perform any action] on matches,
|
||
| like tagging matched phrases with entity types. Instead, actions need to
|
||
| be specified when #[strong adding patterns or entities], by
|
||
| passing in a callback function as the #[code on_match] argument on
|
||
| #[+api("matcher#add") #[code add]]. This allows you to define custom
|
||
| actions per pattern within the same matcher. For example, you might only
|
||
| want to merge some entity types, and set custom flags for other matched
|
||
| patterns. For more details and examples, see the usage guide on
|
||
| #[+a("/usage/linguistic-features#rule-based-matching") rule-based matching].
|
||
|
||
+h(2, "pipe") Matcher.pipe
|
||
+tag method
|
||
|
||
p Match a stream of documents, yielding them in turn.
|
||
|
||
+aside-code("Example").
|
||
from spacy.matcher import Matcher
|
||
matcher = Matcher(nlp.vocab)
|
||
for doc in matcher.pipe(docs, batch_size=50, n_threads=4):
|
||
pass
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code docs]
|
||
+cell iterable
|
||
+cell A stream of documents.
|
||
|
||
+row
|
||
+cell #[code batch_size]
|
||
+cell int
|
||
+cell The number of documents to accumulate into a working set.
|
||
|
||
+row
|
||
+cell #[code n_threads]
|
||
+cell int
|
||
+cell
|
||
| The number of threads with which to work on the buffer in
|
||
| parallel, if the #[code Matcher] implementation supports
|
||
| multi-threading.
|
||
|
||
+row
|
||
+cell #[code return_matches]
|
||
+tag-new(2.1)
|
||
+cell bool
|
||
+cell
|
||
| Yield the match lists along with the docs, making results
|
||
| #[code (doc, matches)] tuples.
|
||
|
||
+row
|
||
+cell #[code as_tuples]
|
||
+tag-new(2.1)
|
||
+cell bool
|
||
+cell
|
||
| Interpret the input stream as #[code (doc, context)] tuples, and
|
||
| yield #[code (result, context)] tuples out. If both
|
||
| #[code return_matches] and #[code as_tuples] are #[code True],
|
||
| the output will be a sequence of
|
||
| #[code ((doc, matches), context)] tuples.
|
||
|
||
+row("foot")
|
||
+cell yields
|
||
+cell #[code Doc]
|
||
+cell Documents, in order.
|
||
|
||
+h(2, "len") Matcher.__len__
|
||
+tag method
|
||
+tag-new(2)
|
||
|
||
p
|
||
| Get the number of rules added to the matcher. Note that this only returns
|
||
| the number of rules (identical with the number of IDs), not the number
|
||
| of individual patterns.
|
||
|
||
+aside-code("Example").
|
||
matcher = Matcher(nlp.vocab)
|
||
assert len(matcher) == 0
|
||
matcher.add('Rule', None, [{'ORTH': 'test'}])
|
||
assert len(matcher) == 1
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row("foot")
|
||
+cell returns
|
||
+cell int
|
||
+cell The number of rules.
|
||
|
||
+h(2, "contains") Matcher.__contains__
|
||
+tag method
|
||
+tag-new(2)
|
||
|
||
p Check whether the matcher contains rules for a match ID.
|
||
|
||
+aside-code("Example").
|
||
matcher = Matcher(nlp.vocab)
|
||
assert 'Rule' not in matcher
|
||
matcher.add('Rule', None, [{'ORTH': 'test'}])
|
||
assert 'Rule' in matcher
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code key]
|
||
+cell unicode
|
||
+cell The match ID.
|
||
|
||
+row("foot")
|
||
+cell returns
|
||
+cell int
|
||
+cell Whether the matcher contains rules for this match ID.
|
||
|
||
+h(2, "add") Matcher.add
|
||
+tag method
|
||
+tag-new(2)
|
||
|
||
p
|
||
| Add a rule to the matcher, consisting of an ID key, one or more patterns, and
|
||
| a callback function to act on the matches. The callback function will
|
||
| receive the arguments #[code matcher], #[code doc], #[code i] and
|
||
| #[code matches]. If a pattern already exists for the given ID, the
|
||
| patterns will be extended. An #[code on_match] callback will be
|
||
| overwritten.
|
||
|
||
+aside-code("Example").
|
||
def on_match(matcher, doc, id, matches):
|
||
print('Matched!', matches)
|
||
|
||
matcher = Matcher(nlp.vocab)
|
||
matcher.add('HelloWorld', on_match, [{'LOWER': 'hello'}, {'LOWER': 'world'}])
|
||
matcher.add('GoogleMaps', on_match, [{'ORTH': 'Google'}, {'ORTH': 'Maps'}])
|
||
doc = nlp(u'HELLO WORLD on Google Maps.')
|
||
matches = matcher(doc)
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code match_id]
|
||
+cell unicode
|
||
+cell An ID for the thing you're matching.
|
||
|
||
+row
|
||
+cell #[code on_match]
|
||
+cell callable or #[code None]
|
||
+cell
|
||
| Callback function to act on matches. Takes the arguments
|
||
| #[code matcher], #[code doc], #[code i] and #[code matches].
|
||
|
||
+row
|
||
+cell #[code *patterns]
|
||
+cell list
|
||
+cell
|
||
| Match pattern. A pattern consists of a list of dicts, where each
|
||
| dict describes a token.
|
||
|
||
+infobox("Changed in v2.0", "⚠️")
|
||
| As of spaCy 2.0, #[code Matcher.add_pattern] and #[code Matcher.add_entity]
|
||
| are deprecated and have been replaced with a simpler
|
||
| #[+api("matcher#add") #[code Matcher.add]] that lets you add a list of
|
||
| patterns and a callback for a given match ID.
|
||
|
||
+code-wrapper
|
||
+code-new.
|
||
matcher.add('GoogleNow', merge_phrases, [{ORTH: 'Google'}, {ORTH: 'Now'}])
|
||
|
||
+code-old.
|
||
matcher.add_entity('GoogleNow', on_match=merge_phrases)
|
||
matcher.add_pattern('GoogleNow', [{ORTH: 'Google'}, {ORTH: 'Now'}])
|
||
|
||
+h(2, "remove") Matcher.remove
|
||
+tag method
|
||
+tag-new(2)
|
||
|
||
p
|
||
| Remove a rule from the matcher. A #[code KeyError] is raised if the match
|
||
| ID does not exist.
|
||
|
||
+aside-code("Example").
|
||
matcher.add('Rule', None, [{'ORTH': 'test'}])
|
||
assert 'Rule' in matcher
|
||
matcher.remove('Rule')
|
||
assert 'Rule' not in matcher
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code key]
|
||
+cell unicode
|
||
+cell The ID of the match rule.
|
||
|
||
+h(2, "get") Matcher.get
|
||
+tag method
|
||
+tag-new(2)
|
||
|
||
p
|
||
| Retrieve the pattern stored for a key. Returns the rule as an
|
||
| #[code (on_match, patterns)] tuple containing the callback and available
|
||
| patterns.
|
||
|
||
+aside-code("Example").
|
||
pattern = [{'ORTH': 'test'}]
|
||
matcher.add('Rule', None, pattern)
|
||
on_match, patterns = matcher.get('Rule')
|
||
|
||
+table(["Name", "Type", "Description"])
|
||
+row
|
||
+cell #[code key]
|
||
+cell unicode
|
||
+cell The ID of the match rule.
|
||
|
||
+row("foot")
|
||
+cell returns
|
||
+cell tuple
|
||
+cell The rule, as an #[code (on_match, patterns)] tuple.
|