minhash算法检索相似文本_基于检索的问答系统

超、凢脫俗 2023-01-02 02:23 131阅读 0赞

![7dbf04cca19e0622097b54b6a021b905.png][]

## 1. 概述 ##

本篇文章是对基于检索的问答系统的总结梳理，整体的实现结构如下：

![b929f19bdeab8be715dc6b4dbaa83f82.png][]

实现架构

主要流程：

1.  建语料库：首先建立一个语料库，即问题和答案的集合，一个问题对应一个答案
2.  文本预处理：对输入的问题进行分词，拼写纠错，词过滤word-filter，去停用词stopwords
3.  文本表示成向量：词向量技术word2vec，TF-IDF
4.  文本相似度计算：余弦相似度，欧式距离
5.  文本高效检索：倒排表排序
6.  返回结果：把相似度最高的问题所对应的答案返回给用户

## 2. 每一步用到的技术详解 ##

**part1: 文本预处理**

*  对给定的语料库进行读取，提取出问题和答案分别存到列表里，保证问题和对应的答案下标位置保持一致，方便后面检索

def read_corpus(filePath):
        """
        读取给定的语料库，并把问题列表和答案列表分别写入到 qlist, alist 里面
        qlist = ["问题1"， “问题2”， “问题3” ....]
        alist = ["答案1", "答案2", "答案3" ....]
        务必要让每一个问题和答案对应起来（下标位置一致）
        """
        qlist = []
        alist = []
        
        with open(filePath) as file:
            json_text = file.read()
            json_dict = json.loads(json_text)
            
        for data in json_dict["data"]:
                for paragraphs in data["paragraphs"]:
                    for qas in paragraphs["qas"]:
                        qlist.append(qas['question'])
                        alist.append(qas["answers"])
                       
        assert len(qlist) == len(alist)  # 确保长度一样
        return qlist, alist

*  对问题和答案的列表进行分词操作

# 统计一下在qlist 总共出现了多少个单词？
    # 做简单的分词，对于英文我们根据空格来分词即可
    def word_count(qlist):
        questions = []#分词后列表
        set_que = []
        word_total = 0
        print(len(qlist))
        for index in range(len(qlist)):
            questions.append(qlist[index].split())
        for index in range(len(questions)):
            word_total += len(questions[index])
        print(word_total)
        return word_total, questions

*  分词之后需要对每个词进行词性还原，本文使用自然语言工具包nltk库，对大小写进行操作，并对标点符号进行处理，对出现频率较低的词进行停用词过滤

stopWords = stopwords.words("english")
    #预处理 数据清洗 停用词 小写 去标点
    def clean_words(strWords):
        wordList = nltk.word_tokenize(strWords)
        lemmatizer = WordNetLemmatizer()
        filteredWords = [lemmatizer.lemmatize(word.lower()) for word in wordList if word.isalpha() and word.lower() not in stopWords]
        return filteredWords

**part2: 文本的向量表示**

对于TF-IDF算法，其训练出来的句子向量具有高维、稀疏的缺点，故在计算的时候比较慢，本文针对这个问题对其进行了优化，在一定程度上降低了时间复杂度。

相反，对于word2vec算法，其训练出来的向量具有低维、稠密的优点，计算速度快，但词向量的训练需要大量的语料才能达到好的效果。在进行word2vec词向量的训练时，需要根据具体的问题，使用合适的语料，这样才能更好的表示句子之间的相似度。

def tfidf(qlist):
        # 每一个问题字符串转换成tf-idf向量
        vectorizer = TfidfVectorizer(smooth_idf=False, lowercase=True, stop_words=stopWords)
        # 得到的是csr_matrix型矩阵（压缩后的稀疏矩阵）
        vectorizer.fit_transform(qlist)
        # 获取词列表
        keywordList = vectorizer.get_feature_names()
        return keywordList

**part3: 文本相似度计算**

本文采用余弦夹角来计算向量之间的相似度，相似问题一般包含更多相同的特征词，两个问句的主题是否接近，取决于它们的特征向量“长得像不像”。是用户提问的问句向量，得到和后，它们所对应的两个问句之间的相似度就可以利用和这两个向量之间夹角的余弦值来表示。。 余弦相似度的定义虽然简单，但是在利用公式计算两个向量的夹角时，计算量为，当用户提出一个问题时，需计算次(为语料库中问句的数量，)，如果语料库很大，则将答案返回给用户需要很长的时间，所有后续先采用倒排列表进行处理，降低余弦相似度匹配的语料库数量。

# 两个问题之间的相似度(余弦相似度计算)
    def cosine_similarity(input_q, que_dict):
        simi_dict = {}
        vectorizer = TfidfVectorizer(smooth_idf=False, lowercase=True, stop_words=stopWords)
        for index, question in que_dict.items():
            tfidf = vectorizer.fit_transform([input_q, question])
            simi_value = ((tfidf * tfidf.T).A)[0, 1]
            if simi_value > 0:
                simi_dict[index] = simi_value
        return simi_dict

**part4: 文本高效检索**

上面的算法，一个最大的缺点是每一个用户问题都需要跟库里的所有的问题都计算相似度。假设我们库里的问题非常多，这将是效率非常低的方法。 这里面一个方案是通过倒排表的方式，先从库里面找到跟当前的输入类似的问题描述。然后针对于这些candidates问题再做余弦相似度的计算。这样会节省大量的时间。

倒排索引源于实际应用中需要根据属性的值来查找记录。这种索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因而称为倒排索引(inverted index)。带有倒排索引的文件我们称为倒排索引文件，简称倒排文件(inverted file)。

def invert_idxTable(qlist_kw):  # 一个简单的倒排表
        invertTable = {}
        for idx, tmpLst in enumerate(qlist_kw):
            for kw in tmpLst:
                if kw in invertTable.keys():
                    invertTable[kw].append(idx)
                else:
                    invertTable[kw] = [idx]
        return invertTable

**part5: 返回结果**

def filter_questionByInvertTab(inputq_keyword, qlist, invertTable):
        idx_lst = []
        q_dict = {}
        for kw in inputq_keyword:
            if kw in invertTable.keys():
                idx_lst.extend(invertTable[kw])
        idxSet = set(idx_lst)
        for idx in idxSet:
            q_dict[idx] = qlist[idx]
        return q_dict
    
    def top5results_invidx(input_q):
        inputq_keyword = clean_words(input_q)
        filtered_qdict = filter_questionByInvertTab(inputq_keyword, qlist, invertTable)
        # 计算相似度
        simi_dict = cosine_similarity(input_q, filtered_qdict)
        d = sorted(simi_dict, key=simi_dict.get, reverse=True)
        #print(d)
        # Top5最相似问题，及它们对应的答案
        print("Top5相似-基于倒排表")
        for idx in d[:5]:
            print("问题： " + qlist[idx])
            print("答案： " + alist[idx])

**part6: 测试**

print (top5results_invidx("At what age did Frédéric move to Paris?"))

[7dbf04cca19e0622097b54b6a021b905.png]: /images/20221120/4eb96f93f2774356ad7325b8b57674eb.png
[b929f19bdeab8be715dc6b4dbaa83f82.png]: /images/20221120/dd7b1a16e66d4778a515de9eb27c2bf5.png