（转）OpenNLP进行中文命名实体识别（下：载入模型识别实体）

上一节介绍了使用OpenNLP训练命名实体识别模型的方法，并将模型写到磁盘上形成二进制bin文件，这一节就是将模型从磁盘上载入，然后进行命名实体识别。依然是先上代码：

 

[java]  view plain  copy

 

 

1. import java.io.File;  
2. import java.util.HashMap;  
3. import java.util.IdentityHashMap;  
4. import java.util.Map;  
5. import java.util.Map.Entry;  
6.   
7. import opennlp.tools.cmdline.namefind.TokenNameFinderModelLoader;  
8. import opennlp.tools.namefind.NameFinderME;  
9. import opennlp.tools.tokenize.SimpleTokenizer;  
10. import opennlp.tools.tokenize.Tokenizer;  
11. import opennlp.tools.util.Span;  
12.   
13. public class NameEntityFindTester {  
14.   
15.     // 默认参数  
16.     private double probThreshold = 0.6;  
17.   
18.     private String modelPath;  
19.     private String testFileDirPath;  
20.   
21.     public NameEntityFindTester() {  
22.         super();  
23.         // TODO Auto-generated constructor stub  
24.     }  
25.   
26.     public NameEntityFindTester(String modelPath, String testFileDirPath) {  
27.         super();  
28.         this.modelPath = modelPath;  
29.         this.testFileDirPath = testFileDirPath;  
30.     }  
31.   
32.     public NameEntityFindTester(double probThreshold, String modelPath,  
33.             String testFileDirPath) {  
34.         super();  
35.         this.probThreshold = probThreshold;  
36.         this.modelPath = modelPath;  
37.         this.testFileDirPath = testFileDirPath;  
38.     }  
39.   
40.     /** 
41.      * 生成NameFinder 
42.      *  
43.      * @return 
44.      */  
45.     public NameFinderME prodNameFinder() {  
46.         NameFinderME finder = new NameFinderME(  
47.                 new TokenNameFinderModelLoader().load(new File(modelPath)));  
48.   
49.         return finder;  
50.     }  
51.   
52.     /** 
53.      * 计算基本命名实体概率 
54.      *  
55.      * @param finder 
56.      *            命名实体识别模型 
57.      * @return 
58.      * @throws Exception 
59.      */  
60.     public Map<String, String> cptBasicNameProb(NameFinderME finder)  
61.             throws Exception {  
62.         Map<String, String> basicNameProbResMap = new IdentityHashMap<String, String>();  
63.         String testContent = NameEntityTextFactory.loadFileTextDir(this  
64.                 .getTestFileDirPath());  
65.   
66.         // TODO 大文本情况下，消耗内存大，需要改写成分批处理模式（把一个大文件分成多个小文件再批量处理）  
67.         Tokenizer tokenizer = SimpleTokenizer.INSTANCE;  
68.         // 待测词，测试结果，概率  
69.         String[] tokens = tokenizer.tokenize(testContent);  
70.         Span[] names = finder.find(tokens);  
71.         double[] nameSpanProbs = finder.probs(names);  
72.   
73.         System.out.println("tokens size: " + tokens.length);  
74.         System.out.println("names size: " + names.length);  
75.         System.out.println("name_span_probs size: " + nameSpanProbs.length);  
76.   
77.         for (int i = 0; i < names.length; i++) {  
78.             String testToken = "";  
79.             for (int j = names[i].getStart(); j <= names[i].getEnd() - 1; j++) {  
80.                 testToken += tokens[j];  
81.             }  
82.             String testRes = names[i].getType() + ":"  
83.                     + Double.toString(nameSpanProbs[i]);  
84.   
85.             // TODO delete print  
86.             System.out.println("find name: \"" + testToken + "\" has res: "  
87.                     + testRes);  
88.   
89.             basicNameProbResMap.put(testToken, testRes);  
90.         }  
91.   
92.         return basicNameProbResMap;  
93.     }  
94.   
95.     /** 
96.      * 过滤除去概率值过低的识别结果 
97.      *  
98.      * @param basicNameProbResMap 
99.      * @return 
100.      */  
101.     public Map<String, String> filterNameProbRes(  
102.             Map<String, String> basicNameProbResMap) {  
103.         Map<String, String> filttedNameProbResMap = new HashMap<String, String>();  
104.         for (Entry<String, String> entry : basicNameProbResMap.entrySet()) {  
105.             String token = entry.getKey();  
106.             String res = basicNameProbResMap.get(token);  
107.   
108.             if (Double.parseDouble(res.split(":")[1]) >= this  
109.                     .getProbThreshold()) {  
110.                 filttedNameProbResMap.put(token, res);  
111.             }  
112.         }  
113.   
114.         return filttedNameProbResMap;  
115.     }  
116.   
117.     /** 
118.      * 预测组件总调用方法 
119.      *  
120.      * @return 
121.      */  
122.     public Map<String, String> execNameFindTester() {  
123.         try {  
124.             NameFinderME finder = this.prodNameFinder();  
125.             Map<String, String> basicNameProbResMap = this  
126.                     .cptBasicNameProb(finder);  
127.             Map<String, String> nameProbResMap = this  
128.                     .filterNameProbRes(basicNameProbResMap);  
129.   
130.             return nameProbResMap;  
131.         } catch (Exception e) {  
132.             // TODO Auto-generated catch block  
133.             e.printStackTrace();  
134.   
135.             return null;  
136.         }  
137.     }  
138. }  

大家依然可以从详细的注释上获得很多的信息，设定的参数只有命名实体概率过滤的阈值，这个是可有可无的一个值，因为OpenNLP会自动过滤一波，但是如果有更高的要求，可以自己设定一个，我默认设定成0.6。然后再简单介绍几个重要的方法：1.prodNameFinder()是载入磁盘上的模型，直接传入模型的磁盘地址；2.cptBasicNameProb()是进行命名实体识别的核心方法，结果映射Map选用IdentityHashMap，因为考虑一个实体有可能被定为多个类别的情况，首先制作一个内嵌的基础分词器，其实这个分词器没有意义，是针对英文的，这就是我们为什么一开始要讲中文分词结果中间隔上空格重新写入文本的原因，基础分词器将文本内容按空格分开，放入一个String数组中，对finder的find()方法传入这个数组，就得到了命名实体识别的结果，用finder的prob()方法可以得到识别结果的概率。这时得到的命名实体结果并不是直接的词，而是一个二维数组，每一行代表识别出来的一个命名实体，该行的每一列存储命名实体对应的词元素在之前传入的String数组中的下标，因为懂命名实体识别的人都知道，命名实体也可以是多个词组成的词组，不只是词。返回的Map以这样的形式存放结果：

 

 

[html]  view plain  copy

 

 

1. <Name, Type:Probility>  

key是实体，后面是所属的实体类别以及概率值；3.filterNameProbRes()方法传入刚才得到的Map结果集，返回过滤后的新Map结果集。

随便用了一些很少的关于电子诈骗的语料进行测试，最终识别出来的结果是这个样子的，可以看到，识别出了1个person和10个action，基本上还都有那么点意思，还有person的训练词库本身词量就很少，导致这个结果。

同样，源代码开源在：https://github.com/Ailab403/ailab-mltk4j，test包里面对应有完整的调用demo，以及file文件夹里面的测试语料和已经训练好的模型。

转载于:https://www.cnblogs.com/mansiisnam/p/5360783.html