利用mmSeg4j分词实现网页文本倾向性分析

利用mmSeg4j分词实现网页文本倾向性分析

最近一直在做网页情感倾向性分析的工作，找了一些论文，发现基于机器学习的算法在项目中不太合适，于是自己鼓捣了一套基于中文分词和正负面词库的分析算法。

原理很简单：

文章倾向性 = ∑（出现的正面词汇 * 权重） —∑(出现的负面词汇 * 权重）。

在这个基础上对于负面新闻再加上相关性判断。

在中文分词方面选择了mmSeg4j，没别的原因，就是之前一直用这个，相对来说性能非常不错，但有些词汇需要自己添加到他的words.dic文件中。mmSeg4j下载地址：http://code.google.com/p/mmseg4j/。

在正式编码之前规划了3个文本文件：

1. neg_words: 配置负面词汇，每个词一行，格式为“太差-1”。“-”后面的数字作为负面词汇的权重。
2. pos_words:配置的正面词汇，配置方式与负面词汇类似。
3. rel_words: 相关词汇表，每行一个词即可，增加这个配置文件是为了识别出于特定内容相关的文本情感。如：仅关心近期与“万科”有关的分析。

在工程启动时将这三个文件加载到一个对象中（单例）代码如下：

1. importjava.io.BufferedReader;
2. importjava.io.FileNotFoundException;
3. importjava.io.FileReader;
4. importjava.io.IOException;
5. importjava.util.ArrayList;
6. importjava.util.HashMap;
7. importjava.util.List;
8. importjava.util.Map;
10. importorg.springframework.stereotype.Component;
12. importcom.yidatec.vis.psms.commons.PSMSConstants;
14. /**
15. *加载词汇
16. *@authorWilliamXu
17. */
19. @Component
20. publicclassTrendencyWordsLoader{
22. privateMap<String,Integer>negWordMap;
23. privateMap<String,Integer>posWordMap;
24. privateList<String>refWordList;
26. publicTrendencyWordsLoader(){
27. loadWords();
28. }
30. privatevoidloadWords(){
32. negWordMap=newHashMap<String,Integer>();
33. posWordMap=newHashMap<String,Integer>();
34. refWordList=newArrayList<String>();
36. try{
38. FileReaderfr=newFileReader(this.getClass().getClassLoader().getResource(PSMSConstants.NEG_WORDS_PATH).getFile());
39. BufferedReaderbr=newBufferedReader(fr);
41. Stringline=null;
43. while((line=br.readLine())!=null){
45. String[]words=line.split("-");
46. negWordMap.put(words[0],Integer.parseInt(words[1]));
47. }
49. fr=newFileReader(this.getClass().getClassLoader().getResource(PSMSConstants.POS_WORDS_PATH).getFile());
50. br=newBufferedReader(fr);
51. line=null;
53. while((line=br.readLine())!=null){
55. String[]words=line.split("-");
56. posWordMap.put(words[0],Integer.parseInt(words[1]));
57. }
59. fr=newFileReader(this.getClass().getClassLoader().getResource(PSMSConstants.REL_WORDS_PATH).getFile());
60. br=newBufferedReader(fr);
61. line=null;
63. while((line=br.readLine())!=null){
64. refWordList.add(line);
65. }
67. br.close();
68. fr.close();
70. }catch(FileNotFoundExceptione){
71. e.printStackTrace();
72. }catch(NumberFormatExceptione){
73. e.printStackTrace();
74. }catch(IOExceptione){
75. e.printStackTrace();
76. }
77. }
79. publicMap<String,Integer>getNegWordMap(){
80. returnnegWordMap;
81. }
83. publicMap<String,Integer>getPosWordMap(){
84. returnposWordMap;
85. }
87. publicList<String>getRefWordList(){
88. returnrefWordList;
89. }
90. }

加载词汇表后，就可以使用mmSeg4j对网页文本进行分词，并进行分析了，代码如下：

1. importjava.io.IOException;
2. importjava.io.Reader;
3. importjava.io.StringReader;
4. importjava.util.ArrayList;
5. importjava.util.HashMap;
6. importjava.util.List;
7. importjava.util.Map;
8. importjava.util.Set;
10. importorg.springframework.beans.factory.annotation.Autowired;
11. importorg.springframework.stereotype.Component;
13. importcom.chenlb.mmseg4j.ComplexSeg;
14. importcom.chenlb.mmseg4j.Dictionary;
15. importcom.chenlb.mmseg4j.MMSeg;
16. importcom.chenlb.mmseg4j.Word;
17. importcom.yidatec.vis.psms.entity.SolrQueryResult;
19. @Component
20. publicclassTrendencyAnalyser{
22. @Autowired
23. TrendencyWordsLoaderwordLoader;
25. protectedstaticfinalDictionarydic=Dictionary.getInstance();
26. protectedstaticfinalComplexSegseg=newComplexSeg(dic);
28. /**
29. *正序阈值
30. */
31. privatefinalintPS_THRESHOLD=50;
33. /**
34. *逆序阈值
35. */
36. privatefinalintNS_THRESHOLD=30;
38. /**
39. *整片文章分词Map
40. */
41. privateMap<String,List<Word>>segments=null;
42. privateList<Word>negs=null;
43. privateList<Word>poses=null;
44. privateList<Word>rels=null;
46. publicintanalyzeTrendency(Stringtitle,Stringcontent){
48. try{
50. booleanflag=isRelTitle(title);
52. if(flag){
54. inttitleTendency=getTitleTrendency();
56. if(titleTendency<0){
57. returnSolrQueryResult.NEGATIVE_NATURE;
58. }elseif(titleTendency>0){
59. returnSolrQueryResult.POSITIVE_NATURE;
60. }
61. }
63. clearAll();
65. initSegmentsMap(newStringReader(title+""+content));
67. parseNegWordsMap();
69. parsePosWordsMap();
71. intresult=analyzeContentsTrendency();
73. if(flag){//标题相关，仅判断文本倾向性
75. if(result<0){
77. returnSolrQueryResult.NEGATIVE_NATURE;
79. }elseif(result==0){
81. returnSolrQueryResult.NEUTRAL_NATURE;
83. }else{
85. returnSolrQueryResult.POSITIVE_NATURE;
87. }
89. }else{//标题无关，需要复杂的矩阵算法
91. parseRelWordsMap();
93. if(result<0){
95. if(analyzeTrendencyByMatrix()){
97. returnSolrQueryResult.NEGATIVE_NATURE;
99. }else{
101. returnSolrQueryResult.NEUTRAL_NATURE;
103. }
105. }elseif(result==0){
107. returnSolrQueryResult.NEUTRAL_NATURE;
109. }else{
111. returnSolrQueryResult.POSITIVE_NATURE;
113. }
115. }
117. }catch(IOExceptione){
118. returnSolrQueryResult.NEUTRAL_NATURE;
119. }
120. }
122. privatevoidclearAll(){
124. if(segments!=null){
125. segments.clear();
126. }
127. if(negs!=null){
128. negs.clear();
129. }
130. if(poses!=null){
131. poses.clear();
132. }
133. }
135. /**
136. *是否是倾向性相关标题
137. *
138. *@paramtitle
139. *@return
140. */
141. privatebooleanisRelTitle(Stringtitle){
143. try{
145. initTitleSegmentsMap(newStringReader(title));
147. List<String>relWords=wordLoader.getRefWordList();
149. for(Stringword:relWords){
151. if(segments.containsKey(word)){
152. returntrue;
153. }
155. }
157. }catch(IOExceptione){
158. returnfalse;
159. }
161. returnfalse;
163. }
165. /**
166. *获取标题倾向性
167. *
168. *@paramtitle
169. *@return
170. */
171. privateintgetTitleTrendency(){
173. parseNegWordsMap();
174. parsePosWordsMap();
176. returnanalyzeContentsTrendency();
178. }
180. /**
181. *判断整篇文章的倾向性
182. *
183. *@paramtitle
184. *@paramcontent
185. *@return
186. */
187. privateintanalyzeContentsTrendency(){
189. intnegScore=0;
190. intposScore=0;
192. if(negs!=null&&negs.size()>0){
194. for(Wordword:negs){
195. negScore+=wordLoader.getNegWordMap().get(word.getString());
196. }
198. }
200. if(poses!=null&&poses.size()>0){
202. for(Wordword:poses){
203. posScore+=wordLoader.getPosWordMap().get(word.getString());
204. }
205. }
207. returnposScore-negScore;
208. }
210. /**
211. *交叉矩阵判断文本倾向性
212. *
213. *@return
214. */
215. privatebooleananalyzeTrendencyByMatrix(){
217. if(rels==null||rels.size()==0){
218. returnfalse;
219. }
221. if(negs==null||negs.size()==0){
222. returnfalse;
223. }
225. for(inti=0;i<rels.size();i++){
227. for(intj=0;j<negs.size();j++){
229. WordrelWord=rels.get(i);
230. WordnegWord=negs.get(j);
232. if(relWord.getStartOffset()<negWord.getStartOffset()){
234. if(negWord.getStartOffset()-relWord.getStartOffset()
235. -relWord.getLength()<PS_THRESHOLD){
237. returntrue;
239. }
241. }else{
242. if(relWord.getStartOffset()-negWord.getStartOffset()
243. -negWord.getLength()<NS_THRESHOLD){
244. returntrue;
245. }
246. }
248. }
250. }
252. returnfalse;
254. }
256. /**
257. *先对标题进行分词
258. *
259. *@paramreader
260. *@throwsIOException
261. */
262. privatevoidinitTitleSegmentsMap(Readerreader)throwsIOException{
264. segments=newHashMap<String,List<Word>>();
266. MMSegmmSeg=newMMSeg(reader,seg);
268. Wordword=null;
270. while((word=mmSeg.next())!=null){
272. if(segments.containsKey(word.getString())){
274. segments.get(word.getString()).add(word);
275. }
277. List<Word>words=newArrayList<Word>();
279. words.add(word);
281. segments.put(word.getString(),words);
283. }
284. }
286. /**
287. *对正文进行分词
288. *
289. *@paramreader
290. *@throwsIOException
291. */
292. privatevoidinitSegmentsMap(Readerreader)throwsIOException{
294. if(segments==null){
295. segments=newHashMap<String,List<Word>>();
296. }
298. MMSegmmSeg=newMMSeg(reader,seg);
300. Wordword=null;
302. while((word=mmSeg.next())!=null){
304. if(segments.containsKey(word.getString())){
306. segments.get(word.getString()).add(word);
307. }
309. List<Word>words=newArrayList<Word>();
311. words.add(word);
313. segments.put(word.getString(),words);
315. }
317. }
319. /**
320. *解析负面词汇
321. */
322. privatevoidparseNegWordsMap(){
324. Map<String,Integer>negMap=wordLoader.getNegWordMap();
325. Set<String>negKeys=negMap.keySet();
327. for(StringnegKey:negKeys){
329. List<Word>negWords=segments.get(negKey);
331. if(negWords!=null){
333. if(negs==null){
334. negs=newArrayList<Word>();
335. }
337. negs.addAll(negWords);
339. }
341. }
343. }
345. /**
346. *解析正面词汇
347. */
348. privatevoidparsePosWordsMap(){
350. Map<String,Integer>posMap=wordLoader.getPosWordMap();
351. Set<String>posKeys=posMap.keySet();
353. for(StringposKey:posKeys){
355. List<Word>posWords=segments.get(posKey);
357. if(posWords!=null){
359. if(poses==null){
360. poses=newArrayList<Word>();
361. }
363. poses.addAll(posWords);
365. }
367. }
368. }
370. /**
371. *解析相关词汇
372. */
373. privatevoidparseRelWordsMap(){
375. List<String>refWords=wordLoader.getRefWordList();
377. for(Stringword:refWords){
379. List<Word>relWords=segments.get(word);
381. if(relWords!=null){
383. if(rels==null){
384. rels=newArrayList<Word>();
385. }
387. rels.addAll(relWords);
389. }
390. }
392. }
394. }
395. //3个文件路径
396. public class PSMSConstants { public static final String NEG_WORDS_PATH = "D:\\pdfReader\\153分钟学会R.txt"; public static final String POS_WORDS_PATH = "D:\\pdfReader\\R语言简明入门教程.txt"; public static final String REL_WORDS_PATH = "D:\\pdfReader\\R语言与统计分析.txt"; }
397. //正倾向1 负倾向-1 相关词 0
398. public class SolrQueryResult { public static final int NEGATIVE_NATURE = -1; public static final int NEUTRAL_NATURE = 0; public static final int POSITIVE_NATURE = 1; }

这里面用了一些策略：

1. 先分析标题，如果标题中出现相关词汇，仅需判断正文倾向性即可。
2. 如果标题中出现相关词汇，并且标题存在倾向，以标题倾向为准。
3. 如果上述都不成立，则合并标题与正文，一起进行分词与情感词汇识别。
4. 对于通篇识别为负面情感的文章需要进一步判断相关性。
5. 采用距离矩阵的方式判断相关性。
6. 需要设定正向最大距离阈值与反向最大距离阈值。