基于Python识别动作/认知/状态动词及句首触发词的技术问询

Hey there! Let's tackle your questions one by one—first we'll review your action verb rule, then cover rules for cognition and stative verbs, and finally how to spot sentence-start trigger words.

一、动作动词识别规则：问题与修正 #

Looking at your current grammar rule:

grammar = r""" NBAR: {<NN.*>?<VB.*><RB.*>?} #Action verbs
AV: {<NBAR>} {<NBAR><IN><NBAR>} # Above, connected with in/of/etc... """

There are a few gaps and potential issues here:

• Missing modal verbs (MD): Phrases like should limit (from your example) include should (tagged MD), which your rule doesn't account for. This means you'll miss full action verb phrases that include modals.
• Accidental noun matches: The <NN.*>? wildcard can pull in preceding nouns (like controller in your example) that are part of the subject, not the action verb itself.
• Unfocused AV rule: The second part of your AV rule (<NBAR><IN><NBAR>) can match unrelated noun phrases (e.g., controller of the rover) instead of action verb phrases.

Here's a revised rule that fixes these issues:

grammar = r"""
AV: {<MD>?<VB.*><RB.*>?}          # Matches action verbs with optional modals/adv (e.g., should limit, run quickly)
    {<MD>?<VB.*><IN><NN.*>+}      # Matches action verbs plus prepositional phrases (e.g., limit the speed to)
"""

This focuses strictly on action verbs and their associated modifiers, so you'll capture full, meaningful action phrases instead of isolated verbs or unrelated nouns. Testing this with your example will give you should limit as a valid action verb phrase, which is more accurate than just limit.

二、认知动词与状态动词的识别规则 #

First, let's clarify the definitions to ground our rules:

• Cognition verbs: Describe mental activities like thinking, knowing, or judging (e.g., know, believe, understand).
• Stative verbs: Describe states of being, possession, or attributes (e.g., be, have, seem, like)—these usually don't work in continuous tenses (you wouldn't say "I am knowing").

认知动词识别 #

You can use a combination of POS tags, a curated word list, and WordNet semantics for robust detection:

1. Basic Rule (POS + Word List):
   Start with a list of common cognition verbs, then match verbs tagged with <MD>?<VB.*> that fall into this list:

   cognition_verbs = {"know", "believe", "understand", "think", "recognize", "remember", "forget", "realize", "doubt", "guess"}
   
   def is_cognition_verb(token, pos):
       return pos.startswith('VB') and token.lower() in cognition_verbs
   

2. Advanced Rule (WordNet Semantics):
   Use WordNet to check if a verb's synsets relate to cognition. This helps catch less common cognition verbs:

   def is_cognition_verb(word):
       synsets = wordnet.synsets(word, pos=wordnet.VERB)
       for syn in synsets:
           # Cognition-related verbs belong to lexnames like "cognition" or "thinking"
           if syn.lexname() in {"verb.cognition", "verb.thinking"}:
               return True
       return False
   

状态动词识别 #

Similarly, combine word lists and semantics to identify stative verbs:

1. Basic Rule (POS + Word List):
   Curate a list of common stative verbs, then match verbs tagged with <VB.*> in this list. Note: For words like have, you'll need context to distinguish state (e.g., "have a car") vs. action (e.g., "have a meeting"):

   stative_verbs = {"be", "have", "seem", "appear", "like", "love", "hate", "belong", "exist", "own", "possess"}
   
   def is_stative_verb(token, pos):
       return pos.startswith('VB') and token.lower() in stative_verbs
   

2. Advanced Rule (WordNet Semantics):
   Check if a verb's synsets describe states rather than actions:

   def is_stative_verb(word):
       synsets = wordnet.synsets(word, pos=wordnet.VERB)
       for syn in synsets:
           # Stative verbs often belong to lexnames like "verb.state"
           if syn.lexname() == "verb.state":
               return True
       return False
   

三、句首触发词识别 #

Identifying trigger words at the start of a sentence is straightforward—you just need to target the first token(s) of each sentence and check against your criteria:

Option 1: Match Single Trigger Words #

If your trigger words are individual terms, use this approach:

# Example trigger word list—customize this to your needs
trigger_words = {"For", "When", "If", "Should", "The"}

# Split document into sentences
sentences = nltk.sent_tokenize(document)

for sent in sentences:
    tokens = nltk.word_tokenize(sent)
    if tokens:
        first_token = tokens[0]
        if first_token in trigger_words:
            print(f"Found sentence-start trigger word: {first_token}")
        # Or check POS tags if triggers are specific parts of speech (e.g., verbs)
        first_pos = pos_tag([first_token])[0][1]
        if first_pos.startswith("VB"):
            print(f"Found sentence-start action trigger: {first_token}")

Option 2: Match Trigger Phrases #

If triggers are multi-word phrases (e.g., "For the"), check the first few tokens:

# Example trigger phrase list
trigger_phrases = {"For the", "When the", "In order to"}

for sent in sentences:
    tokens = nltk.word_tokenize(sent)
    # Check phrases of length 2 or 3 (adjust based on your needs)
    for phrase_len in [2, 3]:
        if len(tokens) >= phrase_len:
            candidate_phrase = " ".join(tokens[:phrase_len])
            if candidate_phrase in trigger_phrases:
                print(f"Found sentence-start trigger phrase: {candidate_phrase}")

内容的提问来源于stack exchange，提问作者Balive13