解析多个字组合的字符串的最佳方法是什么？

Question

我正在编写一个程序，试图从自然语言中派生出意义。该程序将接受一个字符串，并查看它是否包含某些单词组合。请看下面的代码片段为例：

if (phrase.contains("turn")) { // turn something on/off 
    if (phrase.contains("on") && !phrase.contains("off")) { // turn something ON 
     if (phrase.contains("pc") || phrase.contains("computer")) // turn on computer 
      turnOnComputer(); 
     else if (phrase.contains("light") || phrase.contains("lamp")) // turn on lights 
      turnOnLights(); 
     else 
      badPhrase(); 
    } 
    else if (phrase.contains("off") && !phrase.contains("on")) { // turn something OFF 
     if (phrase.contains("pc") || phrase.contains("computer")) // turn off computer 
      turnOffComputer(); 
     else if (phrase.contains("light") || phrase.contains("lamp")) // turn off lights 
      turnOffLights(); 
     else 
      badPhrase(); 
    } 
    else { 
     badPhrase(); 
    } 
} 
else { 
    badPhrase(); 
} 

正如你所看到的，这样可以迅速成为代码不可收拾的烂摊子，如果我要解释以上几个含义更多。我怎样才能更好地管理这个？

Answer 1

首先，我不确定您的方法对自然语言处理的适用性。另外，现在还没有NLP的库吗？特别是，在NLP中，我知道有时候顺序和部分话题很重要，再加上这种方法对于单词变体来说不是很强大。

但是，如果你要坚持你的方法，一个想法，使其更具可读性和更容易维护（见下文更充分的优点/缺点）是这样的：

StringFinder finder = new StringFinder(phrase); 
if  (finder.containsAll("turn", "on").andOneOf("computer", "pc").andNot("off").matches()) { 
    turnOnComputer(); 
    return; 
} else if (finder.containsAll("turn", "off").andOneOf("computer", "pc").andNot("on").matches()) { 
    turnOffComputer(); 
    return; 
} else if (finder.containsAll("turn", "on").andOneOf("light", "lamp").andNot("off").matches()) { 
    ... 
} else if (finder.containsAll("turn")) { // If we reached this point 
    badPhrase(); 
} else if (... 

的东西，如：

class StringFinder { 
    private final String phrase; 
    private final Map<String, Boolean> cache = new HashMap<String, Boolean>(); 

    public StringFinder(String phrase) { this.phrase = phrase; } 

    public StringFinder containsAll(String... strings) { 
     for (String string : strings) { 
      if (contains(string) == false) return new FailedStringFinder(phrase); 
     } 
     return this; 
    } 

    public StringFinder andOneOf(String... strings) { 
     for (String string: strings) { 
      if (contains(string)) return this; 
     } 
     return FailedStringFinder(phrase); 
    } 

    public StringFinder andNot(String... strings) { 
     for (String string : strings) { 
      if (contains(string)) return new FailedStringFinder(phrase); 
     } 
     return this; 
    } 

    public boolean matches() { return true; } 

    private boolean contains(String s) { 
     Boolean cached = cache.get(s); 
     if (cached == null) { 
      cached = phrase.contains(s); 
      cached.put(s, cached); 
     } 
     return cached; 
    } 


} 

class FailedStringFinder extends StringFinder { 
    public boolean matches() { return false; } 

    // The below are actually optional, but save on performance: 
    public StringFinder containsAll(String... strings) { return this; } 
    public StringFinder andOneOf(String... strings) { return this; } 
    public StringFinder andNot(String... strings) { return this; } 
} 

缺点：

• 重复检查： “转” 检查多次。
• 重复模式（但看到下面的优点）。

优点：

• 相对简洁代码。
• 支票被复制但被缓存，因此性能仍然很高。
• 的条件是非常接近的操作，导致非常可读代码。
• 没有嵌套条件允许更改，恕不重组代码特定操作所需的条件，导致了很多维护的代码。
• 易于更改条件和操作出现的顺序，以控制优先级。
• 嵌套的缺乏使得它在未来更容易并行化。
• 灵活的条件检查：例如，您可以将方法添加到StringFinder以匹配重复检查，例如：public StringFinder containsOnAndNotOff() { return containsAll("on").andNot("off"); }或匹配您需要的一些特殊条件，如andAtLeast3Of(String... strings) {...}。
  • 缓存还可以扩展为不仅记住单词是否出现，而且记住整个模式是否出现。
  • 您还可以添加最终条件：andMatches(Pattern p)（使用正则表达式模式） - 实际上，您可以使用正则表达式对许多其他检查进行建模。然后它可以很容易地缓存 - 而不是使用字符串作为键，使用模式。

Answer 2

使用正则表达式来实现你想要的正则表达式作为可以匹配字符串的组合。

Answer 3

关键词定位肯定是只为一个非常小的组字和/或非常有限的输入语言manageble。好吧，也许如果周围的文字并不重要。

但是对于那种自然语言解析的你需要一个更复杂的方法像第一令牌化的文本，然后试图找出字之间句法关系（与直接邻居开始，后来扩大范围）。最后，使用您发现的语法关系作为控制代码来推动您的行动决策。

正则表达式可能不是问题的答案在这里，因为他们需要一个非常严格的输入。考虑这样的句子：

请勿关闭电源，而应将其打开。

RE和你原来的方法都不会给你任何明智的结果。另外，不要忘记句法或语法错误。

Answer 4

Apache OpenNLP是自然语言文本处理的一个基于机器学习的工具包。

它包括一个句子检测器，一个标记生成器，一个份的词性（POS）标注器和树库解析器。

Manual for NLP

Download

希望它能帮助; ）

Answer 5

这是从通过@Oak

import java.util.HashMap; 
import java.util.Map; 

class StringFinder { 
    private final String phrase; 
    private final Map<String, Boolean> cache = new HashMap<String, Boolean>(); 

    public StringFinder(String phrase) { this.phrase = phrase; } 

    public StringFinder containsAll(String... strings) { 
     for (String string : strings) { 
      if (contains(string) == false) return new FailedStringFinder(phrase); 
     } 
     return this; 
    } 

    public StringFinder andOneOf(String... strings) { 
     for (String string: strings) { 
      if (contains(string)) return this; 
     } 
     return new FailedStringFinder(phrase); 
    } 

    public StringFinder andNot(String... strings) { 
     for (String string : strings) { 
      if (contains(string)) return new FailedStringFinder(phrase); 
     } 
     return this; 
    } 

    public boolean matches() { return true; } 

    private boolean contains(String s) { 
     Boolean cached = cache.get(s); 
     if (cached == null) { 
      cached = phrase.contains(s); 
      cache.put(s, cached); 
     } 
     return cached; 
    } 


} 

class FailedStringFinder extends StringFinder { 

    public FailedStringFinder(String phrase) { 
     super(phrase); 
    } 

    public boolean matches() { return false; } 

    // The below are actually optional, but save on performance: 
    public StringFinder containsAll(String... strings) { return this; } 
    public StringFinder andOneOf(String... strings) { return this; } 
    public StringFinder andNot(String... strings) { return this; } 
}