精华内容
下载资源
问答
  • pythonNLP-文本相似度计算-Demo

    千次阅读 2016-12-20 15:53:21
    参照博客[我爱自然语言处理]里面的如何计算两个文本相似度系列,把代码自己实现了一遍,对整个流程有了了解。纯属个人记录,新手想学习可直接去上面的博客学习,讲的非常好。代码#-*- coding:utf-8 import gensim ...

    参照博客[我爱自然语言处理]里面的如何计算两个文本的相似度系列,把代码自己实现了一遍,对整个流程有了了解。纯属个人记录,新手想学习可直接去上面的博客学习,讲的非常好。

    代码

    #-*- coding:utf-8
    import gensim
    from gensim import corpora, models, similarities
    import traceback
    
    
    documents = [ "Shipment of gold damaged in a fire",
                  "Delivery of silver arrived in a silver truck",
                  "Shipment of gold arrived in a truck"]
    
    '''
    @:return:texts是token_list,只要我生成了token_list,给它就行了
    '''
    def pre_process( documents ):
        try:
    
            documents_token_list = [ [word for word in document.lower().split() ] for document in documents ]
    
            print "[INFO]: pre_process is finished!"
            return documents_token_list
    
        except Exception,e:
            print traceback.print_exc()
    
    '''
    这个函数是比较通用的,可以跟我自己写的结合。
    这个是根据document[ token_list ]来训练tf_idf模型的
    @texts: documents = [ document1, document2, ... ] document1 = token_list1
    @return: dictionary 根据texts建立的vsm空间,并且记录了每个词的位置,和我的实现一样,对于vsm空间每个词,你要记录他的位置。否则,文档生成vsm空间的时候,每个词无法找到自己的位置
    @return: corpus_idf 每篇document在vsm上的tf-idf表示.但是他的输出和我的不太一样,我的输出就是单纯的vsm空间中tf-idf的值,但是它的空间里面不是。还有位置信息在。并且输出的时候,看到的好像没有值为0的向量,但是vsm向量的空间是一样的。所以,我觉得应该是只输出了非0的。
    
    这两个返回值和我的都不一样,因为字典(vsm)以及corpus_idf(vsm)都输出了位置信息。
    但是这两个信息,可以快速生成lda和lsi模型
    
    '''
    def tf_idf_trainning(documents_token_list):
        try:
    
            # 将所有文章的token_list映射为 vsm空间
            dictionary = corpora.Dictionary(documents_token_list)
    
            # 每篇document在vsm上的tf表示
            corpus_tf = [ dictionary.doc2bow(token_list) for token_list in documents_token_list ]
    
            # 用corpus_tf作为特征,训练tf_idf_model
            tf_idf_model = models.TfidfModel(corpus_tf)
    
            # 每篇document在vsm上的tf-idf表示
            corpus_tfidf = tf_idf_model[corpus_tf]
    
            print "[INFO]: tf_idf_trainning is finished!"
            return dictionary, corpus_tf, corpus_tfidf
    
        except Exception,e:
            print traceback.print_exc()
    
    def lsi_trainning( dictionary, corpus_tfidf, K ):
        try:
    
            # 用tf_idf作为特征,训练lsi模型
            lsi_model = models.LsiModel( corpus_tfidf, id2word=dictionary, num_topics = K )
    
            # 每篇document在K维空间上表示
            corpus_lsi = lsi_model[corpus_tfidf]
    
            print "[INFO]: lsi_trainning is finished!"
            return lsi_model, corpus_lsi
    
        except Exception,e:
            print traceback.print_exc()
    
    def lda_trainning( dictionary, corpus_tfidf, K ):
        try:
    
            # 用corpus_tf作为特征,训练lda_model
            lda_model = models.LdaModel( corpus_tfidf, id2word=dictionary, num_topics = K )
    
            # 每篇document在K维空间上表示
            corpus_lda = lda_model[corpus_tfidf]
            for aa in corpus_lda:
                print aa
    
            print "[INFO]: lda_trainning is finished!"
            return lda_model, corpus_lda
    
        except Exception,e:
            print traceback.print_exc()
    
    def similarity( query, dictionary, corpus_tf, lda_model ):
        try:
    
            # 建立索引
            index = similarities.MatrixSimilarity( lda_model[corpus_tf] )
    
            # 在dictionary建立query的vsm_tf表示
            query_bow = dictionary.doc2bow( query.lower().split() )
    
            # 查询在K维空间的表示
            query_lda = lda_model[query_bow]
    
            # 计算相似度
            simi = index[query_lda]
            query_simi_list = [ item for _, item in enumerate(simi) ]
            print query_simi_list
    
        except Exception,e:
            print traceback.print_exc()
    
    
    
    
    documents_token_list = pre_process(documents)
    dict, corpus_tf, corpus_tfidf = tf_idf_trainning(documents_token_list)
    #lsi_trainning(corpus_tfidf, dict, 2)
    lda_model, corpus_lda = lda_trainning(dict, corpus_tfidf, 2)
    
    similarity( "Shipment of gold arrived in a truck", dict, corpus_tf, lda_model )
    
    

    代码

    #-*- coding:utf-8
    from gensim import corpora, models, similarities
    from nltk.tokenize import word_tokenize
    from nltk.corpus import stopwords
    from nltk.stem.lancaster import LancasterStemmer
    import traceback
    
    '''
    ------------------------------------------------------------
    函数声明
    '''
    
    # 预处理
    def pre_process(PATH):
        try:
    
            # 课程信息
            courses = [ line.strip() for line in file(PATH) ]
            courses_copy = courses
            courses_name = [ course.split('\t')[0] for course in courses ]
    
            # 分词-转化小写
            texts_tokenized = [[word.lower() for word in word_tokenize(document.decode("utf-8"))] for document in courses]
    
            # 去除停用词
            english_stopwords = stopwords.words('english')
            texts_filtered_stopwords = [ [ word for word in document if word not in english_stopwords ] for document in texts_tokenized ]
    
            # 去除标点符号
            english_punctuations = [',', '.',  ':', ';', '?', '(', ')', '[', ']', '&', '!', '*', '@', '#', '$', '%']
            texts_filterd = [ [ word for word in document if word not in english_punctuations ] for document in texts_filtered_stopwords ]
    
            # 词干化
            st = LancasterStemmer()
            texts_stemmed = [ [ st.stem(word) for word in document ] for document in texts_filterd ]
            #print texts_stemmed[0]
    
            # 去除低频词
            all_stems = sum(texts_stemmed, [])
            stem_once = set( stem for stem in set(all_stems) if all_stems.count(stem) == 1 )
            texts = [ [ word for word in text if word not in stem_once ] for text in texts_stemmed]
    
            print "[INFO]: pre_process is finished!"
            return texts, courses_copy, courses_name
    
    
        except Exception,e:
            print traceback.print_exc()
    
    # 训练tf_idf模型
    def tf_idf_trainning(documents_token_list):
        try:
    
            # 将所有文章的token_list映射为 vsm空间
            dictionary = corpora.Dictionary(documents_token_list)
    
            # 每篇document在vsm上的tf表示
            corpus_tf = [ dictionary.doc2bow(token_list) for token_list in documents_token_list ]
    
            # 用corpus_tf作为特征,训练tf_idf_model
            tf_idf_model = models.TfidfModel(corpus_tf)
    
            # 每篇document在vsm上的tf-idf表示
            corpus_tfidf = tf_idf_model[corpus_tf]
    
            print "[INFO]: tf_idf_trainning is finished!"
            return dictionary, corpus_tf, corpus_tfidf
    
        except Exception,e:
            print traceback.print_exc()
    
    # 训练lsi模型
    def lda_trainning( dictionary, corpus_tfidf, K ):
        try:
    
            # 用corpus_tf作为特征,训练lda_model
            lda_model = models.LdaModel( corpus_tfidf, id2word=dictionary, num_topics = K )
    
            # 每篇document在K维空间上表示
            corpus_lda = lda_model[corpus_tfidf]
    
            print "[INFO]: lda_trainning is finished!"
            return lda_model, corpus_lda
    
        except Exception,e:
            print traceback.print_exc()
    
    # 基于lda模型的相似度计算
    def similarity( query, dictionary, corpus_tf, lda_model ):
        try:
    
            # 建立索引
            index = similarities.MatrixSimilarity( lda_model[corpus_tf] )
    
            # 在dictionary建立query的vsm_tf表示
            query_bow = dictionary.doc2bow( query.lower().split() )
    
            # 查询在K维空间的表示
            query_lda = lda_model[query_bow]
    
            # 计算相似度
            simi = index[query_lda]
            sort_simi = sorted(enumerate(simi), key=lambda item: -item[1])
            print sort_simi[0:10]
    
        except Exception,e:
            print traceback.print_exc()
    
    
    '''
    ------------------------------------------------------------
    常量定义
    '''
    
    PATH = "../../data/coursera/coursera_corpus"
    number_of_topics = 10
    
    '''
    ------------------------------------------------------------
    '''
    
    texts, courses, courses_name = pre_process(PATH)
    dict, corpus_tf, corpus_tfidf = tf_idf_trainning(texts)
    lda_model, corpus_lda = lda_trainning( dict, corpus_tf, number_of_topics )
    
    similarity(courses[210], dict, corpus_tf, lda_model)
    展开全文
  • 如何python文本相似度计算

    千次阅读 2019-09-06 14:53:31
    # 第一个fit_transform是计算tf-idf 第二个fit_transform是将文本转为词频矩阵 tfidf = transformer.fit_transform(vectorizer.fit_transform(cons)) # 获取词袋模型中的所有词语 # word = vectorizer.get_...

    import nltk
    import numpy as np
    import jieba
    import codecs
    import os
    from pymongo import MongoClient
    from sklearn.feature_extraction.text import TfidfTransformer
    from sklearn.feature_extraction.text import CountVectorizer
    from scipy.cluster import hierarchy
    from scipy import cluster
    import scipy

    connect=MongoClient("",27017
    db2 = connect['
    ’]
    db2.authenticate(“", "”)
    collect = db2.****

    class SummaryTxt:

    def __init__(self,stopwordspath):
        # 单词数量
        self.N = 100
        # 单词间的距离
        self.CLUSTER_THRESHOLD = 5
        # 返回的top n句子
        self.TOP_SENTENCES = 5
        self.stopwrods = {}
        #加载停用词
        if os.path.exists(stopwordspath):
            stoplist = [line.strip() for line in codecs.open(stopwordspath, 'r', encoding='utf8').readlines()]
            self.stopwrods = {}.fromkeys(stoplist)
    
    def _split_sentences(self,texts):
        '''
        把texts拆分成单个句子,保存在列表里面,以(.!?。!?)这些标点作为拆分的意见,
        :param texts: 文本信息
        :return:
        '''
        splitstr = '!?。!?;;   :'
        start = 0
        index = 0  # 每个字符的位置
        sentences = []
        for text in texts:
            if text in splitstr:  # 检查标点符号下一个字符是否还是标点
                sentences.append(texts[start:index + 1])  # 当前标点符号位置
                start = index + 1  # start标记到下一句的开头
            index += 1
        if start < len(texts):
            sentences.append(texts[start:])  # 这是为了处理文本末尾没有标
    
        return sentences
    
    def _score_sentences(self,sentences, topn_words):
        '''
        利用前N个关键字给句子打分
        :param sentences: 句子列表
        :param topn_words: 关键字列表
        :return:
        '''
        scores = []
        sentence_idx = -1
        for s in [list(jieba.cut(s)) for s in sentences]:
            sentence_idx += 1
            word_idx = []
            for w in topn_words:
                try:
                    word_idx.append(s.index(w))  # 关键词出现在该句子中的索引位置
                except ValueError:  # w不在句子中
                    pass
            word_idx.sort()
            if len(word_idx) == 0:
                continue
            # 对于两个连续的单词,利用单词位置索引,通过距离阀值计算族
            clusters = []
            cluster = [word_idx[0]]
            i = 1
            while i < len(word_idx):
                if word_idx[i] - word_idx[i - 1] < self.CLUSTER_THRESHOLD:
                    cluster.append(word_idx[i])
                else:
                    clusters.append(cluster[:])
                    cluster = [word_idx[i]]
                i += 1
            clusters.append(cluster)
            # 对每个族打分,每个族类的最大分数是对句子的打分
            max_cluster_score = 0
            for c in clusters:
                significant_words_in_cluster = len(c)
                total_words_in_cluster = c[-1] - c[0] + 1
                score = 1.0 * significant_words_in_cluster * significant_words_in_cluster / total_words_in_cluster
                if score > max_cluster_score:
                    max_cluster_score = score
            scores.append((sentence_idx, max_cluster_score))
        return scores
    
    def summaryScoredtxt(self,text):
        # 将文章分成句子
        sentences = self._split_sentences(text)
    
        # 生成分词
        words = [w for sentence in sentences for w in jieba.cut(sentence) if w not in self.stopwrods if
                 len(w) > 1 and w != '\t']
        # words = []
        # for sentence in sentences:
        #     for w in jieba.cut(sentence):
        #         if w not in stopwords and len(w) > 1 and w != '\t':
        #             words.append(w)
    
        # 统计词频
        wordfre = nltk.FreqDist(words)
    
        # 获取词频最高的前N个词
        topn_words = [w[0] for w in sorted(wordfre.items(), key=lambda d: d[1], reverse=True)][:self.N]
    
        # 根据最高的n个关键词,给句子打分
        scored_sentences = self._score_sentences(sentences, topn_words)
    
        # 利用均值和标准差过滤非重要句子
        avg = np.mean([s[1] for s in scored_sentences])  # 均值
        std = np.std([s[1] for s in scored_sentences])  # 标准差
        summarySentences = []
    
        for (sent_idx, score) in scored_sentences:
            if score > (avg + 0.5 * std):
                summarySentences.append(sentences[sent_idx])
                # print(sentences[sent_idx])
        return summarySentences
    
    def cos_sim(self,cons):
        # 将文本中的词语转换为词频矩阵 矩阵元素a[i][j] 表示j词在i类文本下的词频
        vectorizer = CountVectorizer()
        # 该类会统计每个词语的tf-idf权值
        transformer = TfidfTransformer()
        # 第一个fit_transform是计算tf-idf 第二个fit_transform是将文本转为词频矩阵
        tfidf = transformer.fit_transform(vectorizer.fit_transform(cons))
        # 获取词袋模型中的所有词语
        # word = vectorizer.get_feature_names()
        weight = tfidf.toarray()
        # print(weight.shape)
        Y = scipy.spatial.distance.pdist((weight, 'cityblock')) # 计算距离列表
        Z = hierarchy.linkage(Y, 'average')  # 进行层次聚类
        cluster.hierarchy.cophenet(Z, Y)  # 计算共表相关系数
        
        # with open("result.csv", 'a+', encoding="utf-8") as result:
        #     result.write(weight[0])
        #     result.write('\n')
    #     return weight
    

    if name==‘main’:
    obj =SummaryTxt(’./stopwords.txt’)
    i = 0
    # a_list = []
    for item in collect.find(no_cursor_timeout=True)[i:100]:
    txt = str(item[“content”])
    con = [str(obj.summaryScoredtxt(txt)).replace("’,’","").replace("[’","").replace("’]","")]
    if len(con[0]) > 3:
    obj.cos_sim(con)
    # a_list.append(obj.cos_sim(con))
    # obj.chenci(a_list)
    # print(a_list)

    展开全文
  • python文本相似度计算

    2017-07-31 14:57:28
    两篇中文文本如何计算相似度相似度是数学上的概念,自然语言肯定无法完成,所有要把文本转化为向量。两个向量计算相似度就很简单了,欧式距离、余弦相似度等等各种方法,只需要中学水平的数学知识。 那么如何将...

    步骤

    1. 分词、去停用词
    2. 词袋模型向量化文本
    3. TF-IDF模型向量化文本
    4. LSI模型向量化文本
    5. 计算相似度

    理论知识

    两篇中文文本,如何计算相似度?相似度是数学上的概念,自然语言肯定无法完成,所有要把文本转化为向量。两个向量计算相似度就很简单了,欧式距离、余弦相似度等等各种方法,只需要中学水平的数学知识。

    那么如何将文本表示成向量呢?

    • 词袋模型
      最简单的表示方法是词袋模型。把一篇文本想象成一个个词构成的,所有词放入一个袋子里,没有先后顺序、没有语义。
      例如:

        John likes to watch movies. Mary likes too.
        John also likes to watch football games.

      这两个句子,可以构建出一个词典,key为上文出现过的词,value为这个词的索引序号
      {"John": 1, "likes": 2,"to": 3, "watch": 4, "movies": 5,"also": 6, "football": 7, "games": 8,"Mary": 9, "too": 10}
      那么,上面两个句子用词袋模型表示成向量就是:
      [1, 2, 1, 1, 1, 0, 0, 0, 1, 1]
      [1, 1,1, 1, 0, 1, 1, 1, 0, 0]
      相对于英文,中文更复杂一些,涉及到分词。准确地分词是所有中文文本分析的基础,本文使用结巴分词,完全开源而且分词准确率相对有保障。

    • TF-IDF模型
      词袋模型简单易懂,但是存在问题。中文文本里最常见的词是“的”、“是”、“有”这样的没有实际含义的词。一篇关于足球的中文文本,“的”出现的数量肯定多于“足球”。所以,要对文本中出现的词赋予权重。
      一个词的权重由TF * IDF 表示,其中TF表示词频,即一个词在这篇文本中出现的频率;IDF表示逆文档频率,即一个词在所有文本中出现的频率倒数。因此,一个词在某文本中出现的越多,在其他文本中出现的越少,则这个词能很好地反映这篇文本的内容,权重就越大。
      回过头看词袋模型,只考虑了文本的词频,而TF-IDF模型则包含了词的权重,更加准确。文本向量与词袋模型中的维数相同,只是每个词的对应分量值换成了该词的TF-IDF值。


      TF

    IDF
    • LSI模型
      TF-IDF模型足够胜任普通的文本分析任务,用TF-IDF模型计算文本相似度已经比较靠谱了,但是细究的话还存在不足之处。实际的中文文本,用TF-IDF表示的向量维数可能是几百、几千,不易分析计算。此外,一些文本的主题或者说中心思想,并不能很好地通过文本中的词来表示,能真正概括这篇文本内容的词可能没有直接出现在文本中。
      因此,这里引入了Latent Semantic Indexing(LSI)从文本潜在的主题来进行分析。LSI是概率主题模型的一种,另一种常见的是LDA,核心思想是:每篇文本中有多个概率分布不同的主题;每个主题中都包含所有已知词,但是这些词在不同主题中的概率分布不同。LSI通过奇异值分解的方法计算出文本中各个主题的概率分布,严格的数学证明需要看相关论文。假设有5个主题,那么通过LSI模型,文本向量就可以降到5维,每个分量表示对应主题的权重。

    python实现

    分词上使用了结巴分词,词袋模型、TF-IDF模型、LSI模型的实现使用了gensim库。

    import jieba.posseg as pseg
    import codecs
    from gensim import corpora, models, similarities

    构建停用词表

    stop_words = '/Users/yiiyuanliu/Desktop/nlp/demo/stop_words.txt'
    stopwords = codecs.open(stop_words,'r',encoding='utf8').readlines()
    stopwords = [ w.strip() for w in stopwords ]

    结巴分词后的停用词性 [标点符号、连词、助词、副词、介词、时语素、‘的’、数词、方位词、代词]

    stop_flag = ['x', 'c', 'u','d', 'p', 't', 'uj', 'm', 'f', 'r']

    对一篇文章分词、去停用词

    def tokenization(filename):
        result = []
        with open(filename, 'r') as f:
            text = f.read()
            words = pseg.cut(text)
        for word, flag in words:
            if flag not in stop_flag and word not in stopwords:
                result.append(word)
        return result

    选取三篇文章,前两篇是高血压主题的,第三篇是iOS主题的。

    filenames = ['/Users/yiiyuanliu/Desktop/nlp/demo/articles/13 件小事帮您稳血压.txt', 
                 '/Users/yiiyuanliu/Desktop/nlp/demo/articles/高血压患者宜喝低脂奶.txt',
                 '/Users/yiiyuanliu/Desktop/nlp/demo/articles/ios.txt'
                ]
    corpus = []
    for each in filenames:
        corpus.append(tokenization(each))
    print len(corpus)
    Building prefix dict from the default dictionary ...
    Loading model from cache /var/folders/1q/5404x10d3k76q2wqys68pzkh0000gn/T/jieba.cache
    Loading model cost 0.349 seconds.
    Prefix dict has been built succesfully.
    
    
    3

    建立词袋模型

    dictionary = corpora.Dictionary(corpus)
    print dictionary
    Dictionary(431 unique tokens: [u'\u627e\u51fa', u'\u804c\u4f4d', u'\u6253\u9f3e', u'\u4eba\u7fa4', u'\u996e\u54c1']...)
    doc_vectors = [dictionary.doc2bow(text) for text in corpus]
    print len(doc_vectors)
    print doc_vectors
    3
    [[(0, 1), (1, 3), (2, 2), (3, 1), (4, 3), (5, 3), (6, 3), (7, 1), (8, 1), (9, 1), (10, 1), (11, 3), (12, 1), (13, 2), (14, 3), (15, 3), (16, 1), (17, 2), (18, 1), (19, 1), (20, 1), (21, 2), (22, 1), (23, 1), (24, 1), (25, 1), (26, 1), (27, 3), (28, 1), (29, 1), (30, 1), (31, 1), (32, 1), (33, 1), (34, 1), (35, 1), (36, 1), (37, 1), (38, 1), (39, 1), (40, 2), (41, 1), (42, 2), (43, 1), (44, 2), (45, 1), (46, 4), (47, 1), (48, 2), (49, 1), (50, 2), (51, 1), (52, 1), (53, 1), (54, 1), (55, 1), (56, 1), (57, 1), (58, 1), (59, 1), (60, 1), (61, 1), (62, 1), (63, 1), (64, 1), (65, 3), (66, 1), (67, 1), (68, 1), (69, 2), (70, 2), (71, 5), (72, 1), (73, 2), (74, 3), (75, 1), (76, 1), (77, 1), (78, 2), (79, 1), (80, 1), (81, 1), (82, 1), (83, 2), (84, 3), (85, 1), (86, 2), (87, 1), (88, 3), (89, 1), (90, 1), (91, 1), (92, 2), (93, 1), (94, 1), (95, 2), (96, 2), (97, 1), (98, 3), (99, 1), (100, 1), (101, 1), (102, 2), (103, 1), (104, 1), (105, 1), (106, 1), (107, 1), (108, 2), (109, 1), (110, 1), (111, 1), (112, 1), (113, 1), (114, 1), (115, 1), (116, 1), (117, 1), (118, 1), (119, 2), (120, 1), (121, 1), (122, 1), (123, 1), (124, 1), (125, 1), (126, 1), (127, 1), (128, 5), (129, 5), (130, 1), (131, 1), (132, 2), (133, 1), (134, 1), (135, 1), (136, 1), (137, 1), (138, 6), (139, 1), (140, 1), (141, 1), (142, 4), (143, 1), (144, 2), (145, 1), (146, 1), (147, 1), (148, 2), (149, 1), (150, 1), (151, 5), (152, 1), (153, 1), (154, 1), (155, 1), (156, 1), (157, 1), (158, 1), (159, 1), (160, 1), (161, 2), (162, 15), (163, 3), (164, 1), (165, 1), (166, 2), (167, 1), (168, 6), (169, 1), (170, 1), (171, 1), (172, 3), (173, 1), (174, 1), (175, 2), (176, 1), (177, 1), (178, 2), (179, 2), (180, 1), (181, 6), (182, 1), (183, 1), (184, 1), (185, 2), (186, 1), (187, 1), (188, 1), (189, 1), (190, 1), (191, 1), (192, 1), (193, 1), (194, 1), (195, 1), (196, 1), (197, 1), (198, 1), (199, 1), (200, 1), (201, 5), (202, 1), (203, 2), (204, 2), (205, 1), (206, 1), (207, 1), (208, 1), (209, 2), (210, 1), (211, 1), (212, 1), (213, 1), (214, 1), (215, 1), (216, 1), (217, 1), (218, 1), (219, 3), (220, 1), (221, 1), (222, 4), (223, 1), (224, 1), (225, 1), (226, 1), (227, 1), (228, 1), (229, 1), (230, 1), (231, 2), (232, 12), (233, 1), (234, 1), (235, 1), (236, 2), (237, 1), (238, 1), (239, 1), (240, 1), (241, 1), (242, 1), (243, 1), (244, 1), (245, 1), (246, 1), (247, 4), (248, 2), (249, 1), (250, 1), (251, 1), (252, 1), (253, 2), (254, 1), (255, 1), (256, 1), (257, 6), (258, 1), (259, 2)], [(6, 1), (7, 1), (11, 1), (14, 1), (15, 2), (27, 1), (47, 2), (71, 1), (78, 1), (92, 2), (101, 1), (106, 1), (112, 4), (121, 1), (138, 6), (143, 1), (151, 2), (155, 1), (158, 1), (162, 4), (170, 2), (203, 1), (213, 1), (227, 1), (232, 7), (254, 2), (260, 1), (261, 1), (262, 1), (263, 1), (264, 1), (265, 1), (266, 1), (267, 2), (268, 1), (269, 1), (270, 1), (271, 1), (272, 1), (273, 1), (274, 1), (275, 1), (276, 2), (277, 3), (278, 1), (279, 1), (280, 1), (281, 1), (282, 1), (283, 1), (284, 1), (285, 1), (286, 2), (287, 1), (288, 3), (289, 1), (290, 1), (291, 1), (292, 2), (293, 2), (294, 1), (295, 1), (296, 1), (297, 3), (298, 1), (299, 1), (300, 1), (301, 1), (302, 1)], [(14, 5), (19, 1), (22, 1), (25, 1), (27, 3), (77, 3), (89, 1), (103, 2), (132, 1), (137, 2), (147, 1), (161, 1), (169, 5), (201, 2), (208, 2), (257, 1), (266, 1), (272, 1), (303, 2), (304, 2), (305, 1), (306, 6), (307, 1), (308, 2), (309, 2), (310, 1), (311, 2), (312, 1), (313, 1), (314, 10), (315, 1), (316, 1), (317, 3), (318, 1), (319, 1), (320, 1), (321, 3), (322, 2), (323, 3), (324, 2), (325, 14), (326, 1), (327, 1), (328, 3), (329, 1), (330, 1), (331, 2), (332, 6), (333, 2), (334, 3), (335, 1), (336, 1), (337, 1), (338, 1), (339, 1), (340, 4), (341, 1), (342, 1), (343, 1), (344, 3), (345, 1), (346, 1), (347, 1), (348, 1), (349, 1), (350, 1), (351, 2), (352, 4), (353, 2), (354, 1), (355, 1), (356, 1), (357, 3), (358, 1), (359, 14), (360, 1), (361, 1), (362, 1), (363, 1), (364, 2), (365, 1), (366, 1), (367, 1), (368, 4), (369, 1), (370, 1), (371, 1), (372, 1), (373, 1), (374, 1), (375, 1), (376, 2), (377, 1), (378, 1), (379, 1), (380, 1), (381, 2), (382, 1), (383, 4), (384, 1), (385, 2), (386, 1), (387, 1), (388, 2), (389, 1), (390, 1), (391, 1), (392, 2), (393, 1), (394, 1), (395, 2), (396, 1), (397, 1), (398, 2), (399, 1), (400, 1), (401, 2), (402, 1), (403, 3), (404, 2), (405, 1), (406, 1), (407, 2), (408, 1), (409, 2), (410, 1), (411, 2), (412, 2), (413, 1), (414, 1), (415, 1), (416, 1), (417, 1), (418, 1), (419, 5), (420, 1), (421, 1), (422, 1), (423, 3), (424, 1), (425, 1), (426, 1), (427, 1), (428, 1), (429, 1), (430, 6)]]

    建立TF-IDF模型

    tfidf = models.TfidfModel(doc_vectors)
    tfidf_vectors = tfidf[doc_vectors]
    print len(tfidf_vectors)
    print len(tfidf_vectors[0])
    3
    258

    构建一个query文本,是高血压主题的,利用词袋模型的字典将其映射到向量空间

    query = tokenization('/Users/yiiyuanliu/Desktop/nlp/demo/articles/关于降压药的五个问题.txt')
    query_bow = dictionary.doc2bow(query)
    print len(query_bow)
    print query_bow
    35
    [(6, 1), (11, 1), (14, 1), (19, 1), (25, 1), (28, 1), (38, 2), (44, 3), (50, 4), (67, 1), (71, 1), (97, 1), (101, 3), (105, 2), (137, 1), (138, 4), (148, 6), (151, 2), (155, 1), (158, 3), (162, 4), (169, 1), (173, 2), (203, 1), (232, 12), (236, 1), (244, 9), (257, 1), (266, 1), (275, 2), (282, 1), (290, 2), (344, 1), (402, 1), (404, 3)]
    index = similarities.MatrixSimilarity(tfidf_vectors)

    用TF-IDF模型计算相似度,相对于前两篇高血压主题的文本,iOS主题文本与query的相似度很低。可见TF-IDF模型是有效的,然而在语料较少的情况下,与同是高血压主题的文本相似度也不高。

    sims = index[query_bow]
    print list(enumerate(sims))
    [(0, 0.28532028), (1, 0.28572506), (2, 0.023022989)]

    构建LSI模型,设置主题数为2(理论上这两个主题应该分别为高血压和iOS)

    lsi = models.LsiModel(tfidf_vectors, id2word=dictionary, num_topics=2)
    lsi.print_topics(2)
    [(0,
      u'0.286*"\u9ad8\u8840\u538b" + 0.241*"\u8840\u538b" + 0.204*"\u60a3\u8005" + 0.198*"\u559d" + 0.198*"\u4f4e" + 0.198*"\u8865\u9499" + 0.155*"\u538b\u529b" + 0.155*"\u852c\u83dc" + 0.132*"\u542b\u9499" + 0.132*"\u8840\u9499"'),
     (1,
      u'0.451*"iOS" + 0.451*"\u5f00\u53d1" + 0.322*"\u610f\u4e49" + 0.193*"\u57f9\u8bad" + 0.193*"\u9762\u8bd5" + 0.193*"\u884c\u4e1a" + 0.161*"\u7b97\u6cd5" + 0.129*"\u9ad8\u8003" + 0.129*"\u5e02\u573a" + 0.129*"\u57fa\u7840"')]
    lsi_vector = lsi[tfidf_vectors]
    for vec in lsi_vector:
        print vec
    [(0, 0.74917098831536277), (1, -0.0070559356931168236)]
    [(0, 0.74809557226254608), (1, -0.054041302062161914)]
    [(0, 0.045784366765220297), (1, 0.99846660199817183)]

    在LSI向量空间中,所有文本的向量都是二维的

    query = tokenization('/Users/yiiyuanliu/Desktop/nlp/demo/articles/关于降压药的五个问题.txt')
    query_bow = dictionary.doc2bow(query)
    print query_bow
    [(6, 1), (11, 1), (14, 1), (19, 1), (25, 1), (28, 1), (38, 2), (44, 3), (50, 4), (67, 1), (71, 1), (97, 1), (101, 3), (105, 2), (137, 1), (138, 4), (148, 6), (151, 2), (155, 1), (158, 3), (162, 4), (169, 1), (173, 2), (203, 1), (232, 12), (236, 1), (244, 9), (257, 1), (266, 1), (275, 2), (282, 1), (290, 2), (344, 1), (402, 1), (404, 3)]
    query_lsi = lsi[query_bow]
    print query_lsi
    [(0, 7.5170080232286249), (1, 0.10900815862153138)]
    index = similarities.MatrixSimilarity(lsi_vector)
    sims = index[query_lsi]
    print list(enumerate(sims))
    [(0, 0.99971396), (1, 0.99625134), (2, 0.060286518)]

    可以看到LSI的效果很好,一个高血压主题的文本与前两个训练文本的相似性很高,而与iOS主题的第三篇训练文本相似度很低



    作者:lyy0905
    链接:http://www.jianshu.com/p/edf666d3995f
    來源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
    展开全文
  • Python文本相似度计算

    千次阅读 2017-12-29 17:08:11
    主要步骤文本相似度计算主要用到gensim和jieba两个Python库,重要的是思想,要理解如何利用线性代数的知识解决相似度计算问题。 其主要步骤如下: * 读取文档 * 对要计算的多篇文档进行分词 * 对文档进行整理成...

    主要步骤

    文本相似度计算主要用到gensim和jieba两个Python库,重要的是思想,要理解如何利用线性代数的知识解决相似度计算问题。

    其主要步骤如下:
    * 读取文档
    * 对要计算的多篇文档进行分词
    * 对文档进行整理成制定格式,方此案后续进行计算
    * 计算出词语的频率
    * 【可选】对频率低的词语进行过滤
    * 通过语料库添加字典
    * 加载要对比的文档
    * 将要对比的文档通过doc2bow转化为稀疏向量
    * 对稀疏向量进行进一步处理,得到新语料库
    * 对新语料库通过‘tfidfmodel’进行处理,得到tfidf
    * 通过token2id得到特征数
    * 稀疏矩阵相似度,从而建立索引

    * 得到最终相似度结果

    代码

    # 导入所需Python库
    from gensim import corpora,models,similarities
    import jieba
    import urllib.request
    from collections import defaultdict
    
    # 1.读取文档
    d1=urllib.request.urlopen("http://127.0.0.1/ljm.html").read().decode("utf-8","ignore")
    d2=urllib.request.urlopen("http://127.0.0.1/gcd.html").read().decode("utf-8","ignore")
    
    # 2.对要计算的多篇文档进行分词
    data1=jieba.cut(d1)
    data2=jieba.cut(d2)
    
    # 3.整理文档格式,方便后续计算
    data11=""
    for item in data1:
        data11+=item+" "
    data21=""
    for item in data2:
        data21+=item+" "
    documents=[data11,data21]
    texts=[[word for word in document.split()]
            for document in documents]
    
    # 4.计算词语频率
    frequency=defaultdict(int)
    for text in texts:
        for token in text:
            frequency[token]+=1
    # 5.过滤词频
    texts=[[token for token in text if frequency[token]>25]
            for text in texts]
    
    # 6.通过corpora语料库建立词典
    dictionary=corpora.Dictionary(texts)
    dictionary.save('D:/Python35/12345.txt') 
    
    # 7.加载要对比文档,同时处理成规定格式
    # doc3="D:/Python35/d3.txt"
    d3=urllib.request.urlopen("http://127.0.0.1/dmbj.html").read().decode("utf-8","ignore")
    data3=jieba.cut(d3)
    data31=""
    for item in data3:
        data31+=item+" "
    new_doc=data31
    
    # 8.将要对比文档通过doc2bow转化为稀疏向量
    new_vec=dictionary.doc2bow(new_doc.split())
    
    # 9.建立新的语料库
    corpus=[dictionary.doc2bow(text) for text in texts]
    corpora.MmCorpus.serialize('D:/Python35/6562.txt',corpus) 
    
    # 10.强新语料库通过tfidfmodel进行计算,得到tfidf
    tfidf=models.TfidfModel(corpus)
    # 11.通过token2id得到特征数
    featureNum=len(dictionary.token2id.keys())
    
    # 12.计算稀疏矩阵像是度,建立索引
    index = similarities.SparseMatrixSimilarity(tfidf[corpus], num_features=featureNum)
    # 13.得到相似性
    sims=index[tfidf[new_vec]]
    
    print(sims)
    
    展开全文
  • [307]python文本相似度计算

    千次阅读 2018-07-11 08:54:17
    两篇中文文本如何计算相似度相似度是数学上的概念,自然语言肯定无法完成,所有要把文本转化为向量。两个向量计算相似度就很简单了,欧式距离、余弦相似度等等各种方法,只需要中学水平的数学知识。 那么如何将...
  • 作者系浙江大学生物医学工程专业的硕士在读;...两篇中文文本如何计算相似度相似度是数学上的概念,自然语言肯定无法完成,所有要把文本转化为向量。两个向量计算相似度就很简单了,欧式距离、余弦相似度
  • 在文本处理中,比如商品评论挖掘,有时需要了解每个评论分别和商品的描述之间的相似度,以此衡量评论的客观性。 评论和商品描述的相似度越高,说明评论的用语比较官方,不带太多...那么Python 里面有计算文本相似度...
  • 本文是讲述如何使用word2vec的基础教程,文章比较基础,希望对你有所帮助! 官网C语言下载地址:http://word2vec.googlecode.com/svn/trunk/ 官网Python下载地址:...
  • python中的sklearn包中实现文本聚类时,kmeans、BIRCH等算法,采用的都是欧式距离,如何进行修改为余弦相似度。kmeans方法是可以选择其他距离,但计算聚类中心还是取平均值,这对余弦距离不适用。也就是说,选取...
  • 具体来说,我们介绍了基于字典的方法:1) 测量文档情绪,2) 计算文本复杂度,3) 识别前瞻性句子和风险披露,4) 收集文本中的信息量,以及 5) 计算不同片段的相似度文本。 对于这些任务中的每一个,我们都引用了相关...
  • 句子相似度或语义文本相似度是衡量两段文本的相似程度或表达相同含义的程度。 相关任务包括释义或重复标识,搜索和匹配应用程序。 用于文本相似性的常用方法包括简单的词向量点积,成对分类,以及最近的深度神经网络...
  • 我们的源代码表示和相似度计算的主要用例是为编码人员提供有意义的代码建议。 我们认为类似的技术可能对代码安全性分析,代码作者身份和代码code窃检测很有用。 通过Docker进行Altair演示! 从GitHub下载包含200,...
  • difflib,[Python]标准库,计算文本差异 Levenshtein,快速计算字符串相似度。 很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。 很多已经做案例的人,却不知道如何去学习更加高深的知识。 ...
  • 本教程将介绍如何使用机器学习技术(如word2vec和余弦相似度等),在Python中用几行代码制作抄袭检测器。搭建完成后,抄袭检测器将会从文件中载入学生们的作业,然后通过计算相似度来判断学生有无相互抄袭行为。 ...
  • 如何计算文本相似度 如何进行词向量编码 如何处理同义不同词表达的召回 本场 Chat 适合人群: 有一定编程基础的童鞋 对问答对问答方式有需求的童鞋 特别说明:本场 Chat 主要采用 Python 语言进行分享,如果其他...
  • 本教程将介绍如何使用机器学习技术(如word2vec和余弦相似度等),在Python中用几行代码制作抄袭检测器。搭建完成后,抄袭检测器将会从文件中载入学生们的作业,然后通过计算相似度来判断学生有无相互抄袭行为。 ...
  • 尽管LSH对于重复的文档比对语义相似的文档更重要,但是在这种方法中,我努力使用LSH来计算文本之间的语义相似度。 为此,该算法使用TFIDF提取文本的主要标记(或者您可以预先计算它们并作为参数传递)。 另外,在...
  • 一、什么是拼写纠错 根据两个单词的编辑距离,计算相似度。可以将错误的单词改正。 编辑距离(Edit Distance),又称Levenshtein距离,是指...那么,如何Python计算编辑距离呢?我们可以从较为简单的情况进行分析...
  • ByteCog还使用来基于两个样本的熵图差异计算“原始相似度”值,最后ByteCog使用来计算“真实相似度”,因为在大多数情况下会返回如果样本在熵方向上基本相同,则该值非常高,因此可用于“调整”此样本情况下的相似...
  • b) 通过参数调整 200 个topic,信息量保存效果较优(计算主题) 方案三(0.72): word2vec + CNN 说实话: 没有一个好的机器,是调不出来一个好的结果 (: 逃 通过AUC 来评估模型的效果 2.语言模型(Language ...
  • # 6、相似度计算 sparse_matrix = SparseMatrixSimilarity(tf_texts, num_features) similarities = sparse_matrix.get_similarities(tf_kw) #similarities = sparse_matrix.get_similarities(tf_texts) #...
  • 百度NLP三面

    2017-04-01 00:42:00
    首先,面试官根据项目经验进行提问,主要是自然语言处理...如何进行相似度计算文本聚类结果如何评估? 分词时,为了提高效率,怎么存储词典?(键树)如何压缩存储? 一个字符数组中,每个字符都出现了3次,只有...
  • [Python人工智能] 九.gensim词向量Word2Vec安装及《庆余年》中文短文本相似度计算 原文查阅: [Python人工智能] 一.TensorFlow2.0环境搭建及神经网络入门 [Python人工智能] 二.TensorFlow基础及一元直线...
  • 召回过程优化3

    2021-02-21 23:10:35
    tfidf使用的是词频和整个文档的词语,如果用户问题的某个词语没有出现过,那么此时,计算出来的相似度可能就不准确。该问题的解决思路: 对用户输入的问题进行文本的对齐,比如,使用训练好的word2vector,往句子中...
  • 特点:在得到文本word级别的序列表示之后,根据两个序列表示计算相似度匹配矩阵,融合每个位置上的匹配信息给出最终相似度打分; SimNet使用PaddleFluid和Tensorflow实现,更多文档请参考: SimNet PaddleFluid ...
  • 文本相似度计算 文本生成 语义表示 视频 使用教程 命令行工具 自定义数据 Fine-tune模型转化为PaddleHub Module 自定义任务 服务化部署 进阶指南 文本Embedding服务 语义相似度计算 ULMFit优化策略 超参优化...
  • 文本相似度计算 文本生成 语义表示 视频 使用教程 命令行工具 自定义数据 Fine-tune模型转化为PaddleHub Module 自定义任务 服务化部署 进阶指南 文本Embedding服务 语义相似度计算 ULMFit优化策略 超参优化...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

python如何计算文本相似度

python 订阅