斯坦福命名实体识别器中的多术语命名实体

Question

我正在使用斯坦福命名实体识别器http://nlp.stanford.edu/software/CRF-NER.shtml而且运行良好。这是

List<List<CoreLabel>> out = classifier.classify(text);
for (List<CoreLabel> sentence : out) {
for (CoreLabel word : sentence) {
if (!StringUtils.equals(word.get(AnswerAnnotation.class), "O")) {
namedEntities.add(word.word().trim());           
}
}
}

然而，我发现的问题是识别姓名。如果识别器遇到"Joe Smith"，则会分别返回"Joe"one_answers"Smith"。我真的希望它能把"乔·史密斯"作为一个术语。

这可以通过识别器或者通过配置来实现吗？到目前为止，我还没有在javadoc中找到任何内容。

谢谢！

Answer 1

这是因为您的内部for循环正在对单个标记(单词)进行迭代，并分别添加它们。您需要更改内容以同时添加完整的名称。

一种方法是将内部的for循环替换为内部的while循环，while循环将同一类的相邻非O事物作为单个实体添加。*

另一种方法是使用CRFClassifier方法调用：

List<Triple<String,Integer,Integer>> classifyToCharacterOffsets(String sentences)

它将为您提供完整的实体，您可以通过在原始输入上使用substring来提取的String形式。

*我们分发的模型使用一个简单的原始IO标签方案，其中事物被标记为PERSON或LOCATION，适当的做法是简单地将具有相同标签的相邻令牌合并。许多NER系统使用更复杂的标签，如IOB标签，其中B-PERS等代码指示个人实体的起点。CRFClassifier类和功能工厂支持这样的标签，但它们没有用于我们目前分发的模型(截至2012年)。

Answer 2

classityToCharacterOffsets方法的对应方法是(AFAIK)您无法访问实体的标签。

正如Christopher所提出的，这里有一个循环的例子，它组装了"相邻的非O事物"。此示例还统计出现的次数。

public HashMap<String, HashMap<String, Integer>> extractEntities(String text){
HashMap<String, HashMap<String, Integer>> entities =
new HashMap<String, HashMap<String, Integer>>();
for (List<CoreLabel> lcl : classifier.classify(text)) {
Iterator<CoreLabel> iterator = lcl.iterator();
if (!iterator.hasNext())
continue;
CoreLabel cl = iterator.next();
while (iterator.hasNext()) {
String answer =
cl.getString(CoreAnnotations.AnswerAnnotation.class);
if (answer.equals("O")) {
cl = iterator.next();
continue;
}
if (!entities.containsKey(answer))
entities.put(answer, new HashMap<String, Integer>());
String value = cl.getString(CoreAnnotations.ValueAnnotation.class);
while (iterator.hasNext()) {
cl = iterator.next();
if (answer.equals(
cl.getString(CoreAnnotations.AnswerAnnotation.class)))
value = value + " " +
cl.getString(CoreAnnotations.ValueAnnotation.class);
else {
if (!entities.get(answer).containsKey(value))
entities.get(answer).put(value, 0);
entities.get(answer).put(value,
entities.get(answer).get(value) + 1);
break;
}
}
if (!iterator.hasNext())
break;
}
}
return entities;
}

Answer 3

我也遇到了同样的问题，所以我也查了一下。Christopher Manning提出的方法是有效的，但关键是要知道如何决定哪种分离器是合适的。可以说只允许一个空格，例如"John Zorn">>一个实体。然而，我可能会找到"J.Zorn"的形式，所以我也应该允许使用某些标点符号。但是"杰克、詹姆斯和乔"呢？我可能会得到2个实体，而不是3个("Jack James"one_answers"Joe")。

通过在斯坦福大学的NER课程中挖掘，我实际上找到了这个想法的正确实现。它们使用它以单个String对象的形式导出实体。例如，在方法PlainTextDocumentReaderAndWriter.printAnswersTokenizedInlineXML中，我们有：

private void printAnswersInlineXML(List<IN> doc, PrintWriter out) {
final String background = flags.backgroundSymbol;
String prevTag = background;
for (Iterator<IN> wordIter = doc.iterator(); wordIter.hasNext();) {
IN wi = wordIter.next();
String tag = StringUtils.getNotNullString(wi.get(AnswerAnnotation.class));
String before = StringUtils.getNotNullString(wi.get(BeforeAnnotation.class));
String current = StringUtils.getNotNullString(wi.get(CoreAnnotations.OriginalTextAnnotation.class));
if (!tag.equals(prevTag)) {
if (!prevTag.equals(background) && !tag.equals(background)) {
out.print("</");
out.print(prevTag);
out.print('>');
out.print(before);
out.print('<');
out.print(tag);
out.print('>');
} else if (!prevTag.equals(background)) {
out.print("</");
out.print(prevTag);
out.print('>');
out.print(before);
} else if (!tag.equals(background)) {
out.print(before);
out.print('<');
out.print(tag);
out.print('>');
}
} else {
out.print(before);
}
out.print(current);
String afterWS = StringUtils.getNotNullString(wi.get(AfterAnnotation.class));
if (!tag.equals(background) && !wordIter.hasNext()) {
out.print("</");
out.print(tag);
out.print('>');
prevTag = background;
} else {
prevTag = tag;
}
out.print(afterWS);
}
}

他们对每个单词进行迭代，检查它是否与前一个单词具有相同的类(答案)，如前所述。为此，它们利用了被认为不是实体的表达式使用所谓的backgroundSymbol(类"O")进行标记的事实。它们还使用属性BeforeAnnotation，该属性表示将当前单词与前一个单词分隔开的字符串。最后一点可以解决我最初提出的关于选择合适分离器的问题。

Answer 4

以上代码：

<List> result = classifier.classifyToCharacterOffsets(text);
for (Triple<String, Integer, Integer> triple : result)
{
System.out.println(triple.first + " : " + text.substring(triple.second, triple.third));
}

Answer 5

List<List<CoreLabel>> out = classifier.classify(text);
for (List<CoreLabel> sentence : out) {
String s = "";
String prevLabel = null;
for (CoreLabel word : sentence) {
if(prevLabel == null  || prevLabel.equals(word.get(CoreAnnotations.AnswerAnnotation.class)) ) {
s = s + " " + word;
prevLabel = word.get(CoreAnnotations.AnswerAnnotation.class);
}
else {
if(!prevLabel.equals("O"))
System.out.println(s.trim() + '/' + prevLabel + ' ');
s = " " + word;
prevLabel = word.get(CoreAnnotations.AnswerAnnotation.class);
}
}
if(!prevLabel.equals("O"))
System.out.println(s + '/' + prevLabel + ' ');
}

我刚刚写了一个小逻辑，它运行良好。我所做的是将标签相同的单词分组，如果它们相邻的话。

Answer 6

使用已经提供给您的分类器。我相信这就是你想要的：

private static String combineNERSequence(String text) {
String serializedClassifier = "edu/stanford/nlp/models/ner/english.all.3class.distsim.crf.ser.gz";      
AbstractSequenceClassifier<CoreLabel> classifier = null;
try {
classifier = CRFClassifier
.getClassifier(serializedClassifier);
} catch (ClassCastException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(classifier.classifyWithInlineXML(text));
//  FOR TSV FORMAT  //
//System.out.print(classifier.classifyToString(text, "tsv", false));
return classifier.classifyWithInlineXML(text);
}

Answer 7

这是我的完整代码，我使用斯坦福核心NLP并编写算法来连接多术语名称。

import edu.stanford.nlp.ling.CoreAnnotations;
import edu.stanford.nlp.ling.CoreLabel;
import edu.stanford.nlp.pipeline.Annotation;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;
import edu.stanford.nlp.util.CoreMap;
import org.apache.log4j.Logger;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* Created by Chanuka on 8/28/14 AD.
*/
public class FindNameEntityTypeExecutor {
private static Logger logger = Logger.getLogger(FindNameEntityTypeExecutor.class);
private StanfordCoreNLP pipeline;
public FindNameEntityTypeExecutor() {
logger.info("Initializing Annotator pipeline ...");
Properties props = new Properties();
props.setProperty("annotators", "tokenize, ssplit, pos, lemma, ner");
pipeline = new StanfordCoreNLP(props);
logger.info("Annotator pipeline initialized");
}
List<String> findNameEntityType(String text, String entity) {
logger.info("Finding entity type matches in the " + text + " for entity type, " + entity);
// create an empty Annotation just with the given text
Annotation document = new Annotation(text);
// run all Annotators on this text
pipeline.annotate(document);
List<CoreMap> sentences = document.get(CoreAnnotations.SentencesAnnotation.class);
List<String> matches = new ArrayList<String>();
for (CoreMap sentence : sentences) {
int previousCount = 0;
int count = 0;
// traversing the words in the current sentence
// a CoreLabel is a CoreMap with additional token-specific methods
for (CoreLabel token : sentence.get(CoreAnnotations.TokensAnnotation.class)) {
String word = token.get(CoreAnnotations.TextAnnotation.class);
int previousWordIndex;
if (entity.equals(token.get(CoreAnnotations.NamedEntityTagAnnotation.class))) {
count++;
if (previousCount != 0 && (previousCount + 1) == count) {
previousWordIndex = matches.size() - 1;
String previousWord = matches.get(previousWordIndex);
matches.remove(previousWordIndex);
previousWord = previousWord.concat(" " + word);
matches.add(previousWordIndex, previousWord);
} else {
matches.add(word);
}
previousCount = count;
}
else
{
count=0;
previousCount=0;
}

}
}
return matches;
}
}

Answer 8

处理多词实体的另一种方法。如果多个标记具有相同的注释并位于一行中，则此代码会将它们组合在一起。

限制：
如果同一个令牌有两个不同的注释，最后一个将被保存。

private Document getEntities(String fullText) {
Document entitiesList = new Document();
NERClassifierCombiner nerCombClassifier = loadNERClassifiers();
if (nerCombClassifier != null) {
List<List<CoreLabel>> results = nerCombClassifier.classify(fullText);
for (List<CoreLabel> coreLabels : results) {
String prevLabel = null;
String prevToken = null;
for (CoreLabel coreLabel : coreLabels) {
String word = coreLabel.word();
String annotation = coreLabel.get(CoreAnnotations.AnswerAnnotation.class);
if (!"O".equals(annotation)) {
if (prevLabel == null) {
prevLabel = annotation;
prevToken = word;
} else {
if (prevLabel.equals(annotation)) {
prevToken += " " + word;
} else {
prevLabel = annotation;
prevToken = word;
}
}
} else {
if (prevLabel != null) {
entitiesList.put(prevToken, prevLabel);
prevLabel = null;
}
}
}
}
}
return entitiesList;
}

进口：

Document: org.bson.Document;
NERClassifierCombiner: edu.stanford.nlp.ie.NERClassifierCombiner;