3.jieba分词+es实现KBQA问答系统

深碍√TFBOYSˉ_ 2022-02-01 10:37 584阅读 0赞

**1.jieba分词**  
jieba分词号称是最好的中文分词器，目前Python版本在运维，Java版本很久没有更新了。  
jieba能实现什么功能呢？我们通过下面的TEST可以看下：  
我们实现一个例子：  
如：系统提问“拍拍贷利率是多少”

@Test
    	public void testReadJiebaDict(){
    		/**JiebaSegmenter:分词器，WordDictionary:词典*/
    		String filePath = HanlpTest.class.getClassLoader().getResource("yrz.txt").getFile();
    		/**加载用户自定义词典*/
    		WordDictionary.getInstance().loadUserDict(Paths.get(new File(filePath).getAbsolutePath()));
    		JiebaSegmenter segmenter = new JiebaSegmenter();
    		System.out.println(segmenter.process("拍拍贷利率是多少",JiebaSegmenter.SegMode.INDEX,true));
    	}

本例中加载了我们自定义的的词库yrz.txt后输出如下结果：

[[拍拍贷, 0, 3, pt], [利率, 3, 5, re], [是, 5, 6, v], [多少, 7, 9, m]]

yrz.txt我们定义了什么呢？  
内容如下：

拍拍贷 3 pt
    利率 3 re
    利息 3 re
    额度 3 at

这里只是部分词库的内容，我们可以看到，jieba安装我们的词库定义帮我们进行了分词，这就是分词器的作用。  
从结果我们还可以看到，pt,re,v,m等代号，jieba中将这些称为**词性**。由于[jieba分词器][jieba]Java版本最后一个版本还是2014年。词性识别的功能再该版本里还未实现，熟悉Python的同学可以去看下，Python中是实现了词性识别的功能。  
这里我们对源码进行稍微改造，贴出部分代码  
词性枚举类：

/**
     * @filename PartOfSpeech
     * @description 词性枚举
     * @author will
     * @date 2019/4/12 11:26
     */
    public enum PartOfSpeech {i, w, n, nr, ns, nt, nz, ng, nrt, nrfg, v, vd, vn, vi, vg, a, ad, an, ag, m, mh,
    	mb, mf, mx, mq, mg, q, r, rr, rz, rg, d, df, dg, p, c, u, ul, uv, ud, uj, uz, ug, o, e, t, tg, tq, tdq,
    	s, f, b, y, z, zg, l, g, j, jn, x, xx, xu, k, h,cy,pt,re,at;
    
    	/**
    	 * 判断枚举是否存在
    	 * @param _name
    	 * @return boolean
    	 * @author will
    	 * @date 2019/5/13 9:29
    	 */
    	public static boolean contains(String _name) {
    		PartOfSpeech[] season = values();
    		for (PartOfSpeech s : season) {
    			if (s.name().equals(_name)) {
    				return true;
    			}
    		}
    		return false;
    	}
    }

> 枚举类中定义了我们所有词性的代码。

词性识别工具类：  
这里我们通过Trie树（字典树）实现，部分代码如下：

/**
     * @filename PartOfSpeechTagging
     * @description 词性标注
     * @author will
     * @date 2019/4/12 11:26
     */
    public class PartOfSpeechTagging {
    	private final Trie<String, PartOfSpeech> wordTagTrie;
    
    	private static final String DEFAULT_TAG_FILE = "/dict.txt";
    	private static final String CUSTOM_TAG_FILE = "/yrz.txt";
    
    	private static PartOfSpeechTagging singleton;
    
    	public static PartOfSpeechTagging getInstance() {
    		if (singleton == null) {
    			synchronized (WordDictionary.class) {
    				if (singleton == null) {
    					singleton = new PartOfSpeechTagging();
    					return singleton;
    				}
    			}
    		}
    		return singleton;
    	}
    
    	private PartOfSpeechTagging() {
    		wordTagTrie = new PatriciaTrie<PartOfSpeech>();
    		try {
    			/**加载默认字典*/
    			load(DEFAULT_TAG_FILE, wordTagTrie);
    			/**加载用户自定义字典*/
    			load(CUSTOM_TAG_FILE, wordTagTrie);
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	private int load(String path, Trie<String, PartOfSpeech> trie) throws IOException {
    		int count = 0;
    		InputStream is = this.getClass().getResourceAsStream(path);
    		try {
    			BufferedReader br = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
    			while (br.ready()) {
    				String line = br.readLine();
    				if (line.startsWith("#")) {
    					continue;
    				}
    				count++;
    				/**根据空格截取用户字典*/
    				String[] attr = line.trim().split("[\t ]+");
    				if (attr.length < 1) {
    					// Ignore empty line
    					continue;
    				}
    				if (attr.length == 3 && PartOfSpeech.contains(attr[2])) {
    					trie.put(attr[0], PartOfSpeech.valueOf(attr[2]));
    				} else {
    					trie.put(attr[0], PartOfSpeech.i);
    				}
    			}
    		} catch (IOException e) {
    			throw e;
    		} finally {
    			try {
    				if (null != is)
    					is.close();
    			} catch (IOException e) {
    				throw e;
    			}
    		}
    		return count;
    	}
    
    	/**
    	 * 获取词的对应词性
    	 * @param wordText
    	 * @return com.huaban.analysis.jieba.word.PartOfSpeech
    	 * @author will
    	 * @date 2019/5/13 9:53
    	 */
    	public PartOfSpeech process(String wordText) {
    		PartOfSpeech pos = wordTagTrie.get(wordText);
    		return pos;
    	}
    }

> trie，又称前缀树或字典樹，是一种有序树，用于保存关联数组，其中的键通常是字符串。 与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。 一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。

修改源码，JiebaSegmenter（分词器类），这里我们修改process方法：

public List<SegToken> process(String paragraph, SegMode mode, boolean tagging) { 
            List<SegToken> tokens = new ArrayList<SegToken>();
            StringBuilder sb = new StringBuilder();
            int offset = 0;
            for (int i = 0; i < paragraph.length(); ++i) { 
                char ch = CharacterUtil.regularize(paragraph.charAt(i));
                if (CharacterUtil.ccFind(ch))
                    sb.append(ch);
                else { 
                    if (sb.length() > 0) { 
                        // process
                        if (mode == SegMode.SEARCH) { 
                            for (String word : sentenceProcess(sb.toString())) { 
                                if (tagging) { 
                                    tokens.add(new SegToken(word, offset, offset += word.length(), partOfSpeechTagging.process(word)));
                                } else { 
                                    tokens.add(new SegToken(word, offset, offset += word.length()));
                                }
                            }
                        } else { 
                            for (String token : sentenceProcess(sb.toString())) { 
                                if (token.length() > 2) { 
                                    String gram2;
                                    int j = 0;
                                    for (; j < token.length() - 1; ++j) { 
                                        gram2 = token.substring(j, j + 2);
                                        if (wordDict.containsWord(gram2))
                                            if (tagging) { 
                                                tokens.add(new SegToken(gram2, offset + j, offset + j + 2,
                                                        partOfSpeechTagging.process(gram2)));
                                            } else { 
                                                tokens.add(new SegToken(gram2, offset + j, offset + j + 2));
                                            }
                                    }
                                }
                                if (token.length() > 3) { 
                                    String gram3;
                                    int j = 0;
                                    for (; j < token.length() - 2; ++j) { 
                                        gram3 = token.substring(j, j + 3);
                                        if (wordDict.containsWord(gram3)) { 
                                            if (tagging) { 
                                                tokens.add(new SegToken(gram3, offset + j, offset + j + 3,
                                                        partOfSpeechTagging.process(gram3)));
                                            } else { 
                                                tokens.add(new SegToken(gram3, offset + j, offset + j + 3));
                                            }
                                        }
                                    }
                                }
                                if (tagging) { 
                                    tokens.add(new SegToken(token, offset, offset += token.length(), partOfSpeechTagging.process(token)));
                                } else { 
                                    tokens.add(new SegToken(token, offset, offset += token.length()));
                                }
                            }
                        }
                        sb = new StringBuilder();
                        offset = i;
                    }
                    if(tagging){ 
                        tokens.add(new SegToken(paragraph.substring(i, i + 1), offset, ++offset, partOfSpeechTagging.process(paragraph.substring(i, i + 1))));
                    } else { 
                        tokens.add(new SegToken(paragraph.substring(i, i + 1), offset, ++offset));
                    }
                }
            }
            if (sb.length() > 0)
                if (mode == SegMode.SEARCH) { 
                    for (String token : sentenceProcess(sb.toString())) { 
                        if(tagging){ 
                            tokens.add(new SegToken(token, offset, offset += token.length(), partOfSpeechTagging.process(token)));
                        }else { 
                            tokens.add(new SegToken(token, offset, offset += token.length()));
                        }
                    }
                } else { 
                    for (String token : sentenceProcess(sb.toString())) { 
                        if (token.length() > 2) { 
                            String gram2;
                            int j = 0;
                            for (; j < token.length() - 1; ++j) { 
                                gram2 = token.substring(j, j + 2);
                                if (wordDict.containsWord(gram2)) { 
                                    if(tagging){ 
                                        tokens.add(new SegToken(gram2, offset + j, offset + j + 2, partOfSpeechTagging.process(gram2)));
                                    }else { 
                                        tokens.add(new SegToken(gram2, offset + j, offset + j + 2));
                                    }
                                }
                            }
                        }
                        if (token.length() > 3) { 
                            String gram3;
                            int j = 0;
                            for (; j < token.length() - 2; ++j) { 
                                gram3 = token.substring(j, j + 3);
                                if (wordDict.containsWord(gram3)) { 
                                    if(tagging) { 
                                        tokens.add(new SegToken(gram3, offset + j, offset + j + 3, partOfSpeechTagging.process(gram3)));
                                    }else{ 
                                        tokens.add(new SegToken(gram3, offset + j, offset + j + 3));
                                    }
                                }
                            }
                        }
                        if(tagging){ 
                            tokens.add(new SegToken(token, offset, offset += token.length(), partOfSpeechTagging.process(token)));
                        }else { 
                            tokens.add(new SegToken(token, offset, offset += token.length()));
                        }
                    }
                }
    
            return tokens;
        }

> 主要在原有方法： tokens.add(new SegToken(word, offset, offset += word.length(), **partOfSpeechTagging.process(word)**));添加了：partOfSpeechTagging.process(word)，我们拿到词，通过调用我们自定义的process方法获取trie数中对应的词的词性。

**2.KBQA实现**  
关于KBQA的介绍网上有很多的资料，我这里只介绍一种实现方式：  
我们首先建立我们的es知识库：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ2FpaHVpbWluZw_size_16_color_FFFFFF_t_70]  
知识库中非常简单列举了公司对应的产品及产品描述，利率，额度等。  
那在es查询是如何进行推理的呢？  
1).知识库初始化到es中时我们首先会对存放到es中的数据进行分词（通过IK Analysis分词器）。

PUT http://10.168.14.40:8200/yrz
    {
      "settings" : {
        "number_of_shards" : 3,
        "number_of_replicas" : 1
      },
      "mappings":{
        "yrz_info":{
          "properties":{
            "company":{
              "type":"text",
              "analyzer": "ik_max_word"
            },
            "product":{
              "type":"text",
              "analyzer": "ik_smart"
            },
    		"synopsis":{
              "type":"text",
              "analyzer": "ik_smart"
            },
    		"amount":{
              "type":"text",
              "analyzer": "ik_smart"
            },
    		"rate":{
              "type":"text",
              "analyzer": "ik_smart"
            },
    		"content":{
              "type":"text",
              "analyzer": "ik_smart"
            }
          }
        }
      }
    }

2).在加载数据时，属性之间是没有关联的，具体关系在自己使用的时候可以来定义的（比如“利率”，我们不知道要怎么对应到知识库中的rate字段）。  
3).实现我们的jieba分词后的词性与es知识库中字段的关联，我们就要设定对应的规则(这里推荐一个Python示例：[https://github.com/keyue123/poemElasticDemo][https_github.com_keyue123_poemElasticDemo])。  
4).我们通过一个简单示例来看下：  
比如：“拍拍贷利率是多少？”，jieba分词后我们可以得到：`[[拍拍贷, 0, 3, pt], [利率, 3, 5, re], [是, 5, 6, v], [多少, 7, 9, m]]`  
此时我们设定规则(rules)，pt对应我们es中的product，re对应es中的rate，然后通过模糊查找与存放在es中的属性值进行句子相似度计算，找到最相似的属性。  
相关代码如下：

@Test
    	public void searchMutil() throws Exception { 
    		//1.TODO 完成jieba分词
    		//2.TODO 完成词性与es字段映射
    		String[] searchTerms = {  "product","rate" };
    		MultiSearchTemplateRequest multiRequest = new MultiSearchTemplateRequest();
    		for (String searchTerm : searchTerms) { 
    			SearchTemplateRequest request = new SearchTemplateRequest();
    			request.setRequest(new SearchRequest(index));
    			request.setScriptType(ScriptType.INLINE);
    			request.setScript("{\"query\": {\"bool\":{\"must\":{\"query_string\" : {\"default_field\" : \"{ {default_value}}\",\"query\" : \"{ {query_value}}\"}}}}}");
    			Map<String, Object> scriptParams = new HashMap<>();
    			scriptParams.put("default_value", searchTerm);
    			scriptParams.put("query_value", "拍拍贷利率是多少");
    			scriptParams.put("size", 5);
    			request.setScriptParams(scriptParams);
    			multiRequest.add(request);
    		}
    		MultiSearchTemplateResponse multiResponse = client.msearchTemplate(multiRequest, RequestOptions.DEFAULT);
    		//返回一组响应 ，每个请求对应一个响应
    		for (MultiSearchTemplateResponse.Item item : multiResponse.getResponses()) { 
    			if (item.isFailure()) { 
    				String error = item.getFailureMessage(); //搜索请求失败返回错误信息
    				System.out.println("error:"+error);
    			}else { 
    				SearchTemplateResponse searchTemplateResponse = item.getResponse();
    				SearchResponse response = searchTemplateResponse.getResponse();
    				SearchHits hits = response.getHits();
    				for (SearchHit hit : hits) { 
    					if (hit.getScore() >= 0.8){ 
    						System.out.println(hit.getSourceAsMap().get("product")+"--"+hit.getSourceAsMap().get("rate"));
    					}
    
    				}
    			}
    		}
    	}

[jieba]: https://github.com/huaban/jieba-analysis
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ2FpaHVpbWluZw_size_16_color_FFFFFF_t_70]: /images/20220201/1de9213d0f394fa19c6e68380364f1f3.png
[https_github.com_keyue123_poemElasticDemo]: https://github.com/keyue123/poemElasticDemo