精华内容
下载资源
问答
  • python计算tfidf

    千次阅读 2016-08-16 21:28:43
    本例来自mining social web from math import log # XXX: Enter in a query term from the corpus variable QUERY_TERMS = ['mr.', 'green'] def tf(term, doc, normalize=True): doc = doc.lower().split()

    本例来自mining social web

    from math import log
    
    # XXX: Enter in a query term from the corpus variable
    QUERY_TERMS = ['mr.', 'green']
    
    def tf(term, doc, normalize=True):
        doc = doc.lower().split()
        if normalize:
            return doc.count(term.lower()) / float(len(doc))
        else:
            return doc.count(term.lower()) / 1.0
    
    
    def idf(term, corpus):
        num_texts_with_term = len([True for text in corpus if term.lower()
                                  in text.lower().split()])
    
        # tf-idf calc involves multiplying against a tf value less than 0, so it's
        # necessary to return a value greater than 1 for consistent scoring. 
        # (Multiplying two values less than 1 returns a value less than each of 
        # them.)
    
        try:
            return 1.0 + log(float(len(corpus)) / num_texts_with_term)
        except ZeroDivisionError:
            return 1.0
    
    
    def tf_idf(term, doc, corpus):
        return tf(term, doc) * idf(term, corpus)
    
    
    corpus = \
        {'a': 'Mr. Green killed Colonel Mustard in the study with the candlestick. \
    Mr. Green is not a very nice fellow.',
         'b': 'Professor Plum has a green plant in his study.',
         'c': "Miss Scarlett watered Professor Plum's green plant while he was away \
    from his office last week."}
    
    for (k, v) in sorted(corpus.items()):
        print k, ':', v
    print
        
    # Score queries by calculating cumulative tf_idf score for each term in query
    
    query_scores = {'a': 0, 'b': 0, 'c': 0}
    for term in [t.lower() for t in QUERY_TERMS]:
        for doc in sorted(corpus):
            print 'TF(%s): %s' % (doc, term), tf(term, corpus[doc])
        print 'IDF: %s' % (term, ), idf(term, corpus.values())
        print
    
        for doc in sorted(corpus):
            score = tf_idf(term, corpus[doc], corpus.values())
            print 'TF-IDF(%s): %s' % (doc, term), score
            query_scores[doc] += score
        print
    
    print "Overall TF-IDF scores for query '%s'" % (' '.join(QUERY_TERMS), )
    for (doc, score) in sorted(query_scores.items()):
        print doc, score


    展开全文
  • 利用python 计算文档的tfidf,步骤大概如下: 读入文档,对文档进行分词,每一段为一个字符串,分词用空格隔开,读入文档是一个长度为该文档段数的列表。 利用vectorizer生成词频矩阵X , 再利用tfidftransformer ...

    利用python 计算文档的tfidf,步骤大概如下:

    读入文档,对文档进行分词,每一段为一个字符串,分词用空格隔开,读入文档是一个长度为该文档段数的列表。

    利用vectorizer生成词频矩阵X , 再利用tfidftransformer 生成tfidf矩阵。

    代码如下:

    import jieba
    import numpy as np
    from sklearn import feature_extraction
    from sklearn.feature_extraction.text import TfidfTransformer
    from sklearn.feature_extraction.text import CountVectorizer
    
    
    text = """
    由张一山与唐艺昕主演的新版《鹿鼎记》备受争议,魔改的剧情和夸张的演技让人无法直视。作为主演的张一山承受了大部分观众的炮火,受尽无数吐槽。而在剧中扮演韦小宝老婆之一苏荃的朱珠却在采访中直面差评、硬刚网友,为张一山洗白。
    
    
    尽管大家已经做好了翻拍不如原版的准备,然而还是没有想到这一版本《鹿鼎记》会如此不尽人意,开播前有多受网友期待,开播后就让人感到有多失望。
    
    
    
    张一山版《鹿鼎记》在经历了剧情魔改、演员演技浮夸这一系列重创后,最终评分惨不忍睹。
    
    
    
    
    原以为有“戏骨”张一山坐镇扛剧,这部剧再差也不会差到哪里去,谁曾想整部剧最大的槽点就是张一山本人。
    
    
    过于浮夸的演技,油腻做作的肢体语言,被网友称为“猴式演技”,还有网友无情吐槽张一山“像被鞭子抽了三年的心酸小瘦猴在努力假装快乐活泼”。
    
    
    
    而朱珠在剧中扮演的则是韦小宝的御姐老婆苏荃,性格大气沉稳、临危不惧。朱珠所饰演的苏荃其实也并没有让人眼前一亮,演技总体来说还是有些流于表面,没有让整部剧口碑力挽狂澜。
    
    
    或许是戏份不多的原因,朱珠在这部戏中并没有被过多讨论,网友的炮火主要还是集中在主演张一山身上。不过朱珠参演的另外一部剧《大秦赋》也同样备受争议,并且戏份过多的朱珠还受到不少吐槽。
    
    
    《大秦赋》这部剧算是高开低走的典型,集结了张鲁一、段奕宏、邬君梅等演技派的历史大剧,是网友们相当期待的一部剧,朱珠在剧中扮演的是一代美人赵姬。
    
    
    作为秦始皇嬴政的生母,赵姬戏份过于拖沓,与嫪毐的情爱纠葛缠绵不断,被网友吐槽将《大秦赋》演成了《大情妇》或者是《嫪毐传》。
    
    
    赵姬这个角色若是演好了定能圈大波粉丝,不过朱珠却将其演绎成了只会傻笑的“傻白甜”,美则美矣,然而没有了灵魂。
    
    这边朱珠自己已经受到吐槽不断,受访时还是为旧搭档张一山发声,与给出差评的观众正面刚。
    
    朱珠表示张一山虽然看起来古灵精怪,其实是非常成熟并且大男人的一个人,心里也是非常有数。
    """
    
    word_list = text.split("\n")
    word_list
    new_word_list = [i for i in word_list if i != ""]
    new_word_list
    
    corpus = [" ".join(jieba.cut(w)) for w in new_word_list]
    corpus
    
    vectorizer = CountVectorizer()
    X = vectorizer.fit_transform(corpus)
    word = vectorizer.get_feature_names()
    word
    freq = X.toarray()
    freq
    
    transformer = TfidfTransformer()
    tfidf = transformer.fit_transform(X)
    
    tfidf.toarray()

     

    展开全文
  • # **最后是实际计算商品间相似度的程序三,这个用LSI模型来比对的话,2k行要跑四五十分钟,但我的数据量有50w。用tfidf模型来算直接报memory error 不给跑** ``` Python # -*- coding: utf-8 -*- import logging,...
  • python算法 tfidf

    2019-09-29 14:46:24
    98 tfidf = tf*idf # 计算TF-IDF 99 outdic[str(i)] = tfidf 100 orderdic = sorted(outdic.items(), key=operator.itemgetter( 101 1), reverse=True) # 给字典排序 102 return orderdic 103 104 105 def ...

    这篇博客写的不错,故转载一下,记录也学习:

    现在有一篇长文《中国的蜜蜂养殖》,用计算机提取它的关键词。

    1、词频:如果某个词很重要,它应该在这篇文章中多次出现。我们进行"词频"(Term Frequency,缩写为TF)统计。

    2、停用词:结果你肯定猜到了,出现次数最多的词是----"的"、"是"、"在"----这一类最常用的词。它们叫做"停用词"(stop words),表示对找到结果毫无帮助、必须过滤掉的词。

    3、IDF :最常见的词("的"、"是"、"在")给予最小的权重,

        较常见的词("中国")给予较小的权重,

        较少见的词("蜜蜂"、"养殖")给予较大的权重。

        这个权重叫做"逆文档频率"(Inverse Document Frequency,缩写为IDF),

        它的大小与一个词的常见程度成反比。 

    4、TF-IDF:"词频"(TF)和"逆文档频率"(IDF)以后,两个值相乘,得到了一个词的TF-IDF值。

        某个词对文章的重要性越高,它的TF-IDF值就越大。

        所以,排在最前面的几个词,就是这篇文章的关键词。

     

    如果某个词比较少见,但是它在这篇文章中多次出现,那么它很可能就反映了这篇文章的特性,正是我们所需要的关键词。发现"中国"、"蜜蜂"、"养殖"这三个词的出现次数一样多,因为"中国"是很常见的词,相对而言,"蜜蜂"和"养殖"不那么常见,"蜜蜂"和"养殖"的重要程度要大于"中国"。

     

    具体实现:

    1、计算词频

      词频(TF) = 某个词在文章中的出现次数,文章有长短之分,为了便于不同文章的比较,做"词频"标准化。

      词频(TF) = 某个词在文章中的出现次数 / 文章总词数

    或者 词频(TF) = 某个词在文章中的出现次数 / 拥有最高词频的词的次数

     

    2、某个词在文章中的出现次数

    这时,需要一个语料库(corpus),用来模拟语言的使用环境。

    逆文档频率(IDF) = log(语料库的文档总数/包含该词的文档总数+1)

     

    3、计算TF-IDF

      TF-IDF = 词频(TF) * 逆文档频率(IDF)

      可以看到,TF-IDF与一个词在文档中的出现次数成正比,与该词在整个语言中的出现次数成反比。

      所以,自动提取关键词的算法就是计算出文档的每个词的TF-IDF值,然后按降序排列,取排在最前面的几个词。

     

    从上表可见,"蜜蜂"的TF-IDF值最高,"养殖"其次,"中国"最低。(如果还计算"的"字的TF-IDF,那将是一个极其接近0的值。)

    所以,如果只选择一个词,"蜜蜂"就是这篇文章的关键词。

     

      1 import os
      2 import codecs
      3 import math
      4 import operator
      5 
      6 
      7 def fun(filepath):  # 遍历文件夹中的所有文件,返回文件list
      8     arr = []
      9     for root, dirs, files in os.walk(filepath):
     10         for fn in files:
     11             arr.append(root+"\\"+fn)
     12     return arr
     13 
     14 
     15 def wry(txt, path):  # 写入txt文件
     16     f = codecs.open(path, 'a', 'utf8')
     17     f.write(txt)
     18     f.close()
     19     return path
     20 
     21 
     22 def read(path):  # 读取txt文件,并返回list
     23     f = open(path, encoding="utf8")
     24     data = []
     25     for line in f.readlines():
     26         data.append(line)
     27     return data
     28 
     29 
     30 def toword(txtlis):  # 将一片文章按照‘/’切割成词表,返回list
     31     wordlist = []
     32     alltxt = ''
     33     for i in txtlis:
     34         alltxt = alltxt+str(i)
     35     ridenter = alltxt.replace('\n', '')
     36     wordlist = ridenter.split('/')
     37     return wordlist
     38 
     39 
     40 def getstopword(path):  # 获取停用词表
     41     swlis = []
     42     for i in read(path):
     43         outsw = str(i).replace('\n', '')
     44         swlis.append(outsw)
     45     return swlis
     46 
     47 
     48 def getridofsw(lis, swlist):  # 去除文章中的停用词
     49     afterswlis = []
     50     for i in lis:
     51         if str(i) in swlist:
     52             continue
     53         else:
     54             afterswlis.append(str(i))
     55     return afterswlis
     56 
     57 
     58 def freqword(wordlis):  # 统计词频,并返回字典
     59     freword = {}
     60     for i in wordlis:
     61         if str(i) in freword:
     62             count = freword[str(i)]
     63             freword[str(i)] = count+1
     64         else:
     65             freword[str(i)] = 1
     66     return freword
     67 
     68 
     69 def corpus(filelist, swlist):  # 建立语料库
     70     alllist = []
     71     for i in filelist:
     72         afterswlis = getridofsw(toword(read(str(i))), swlist)
     73         alllist.append(afterswlis)
     74     return alllist
     75 
     76 
     77 def wordinfilecount(word, corpuslist):  # 查出包含该词的文档数
     78     count = 0  # 计数器
     79     for i in corpuslist:
     80         for j in i:
     81             if word in set(j):  # 只要文档出现该词,这计数器加1,所以这里用集合
     82                 count = count+1
     83             else:
     84                 continue
     85     return count
     86 
     87 
     88 def tf_idf(wordlis, filelist, corpuslist):  # 计算TF-IDF,并返回字典
     89     outdic = {}
     90     tf = 0
     91     idf = 0
     92     dic = freqword(wordlis)
     93     outlis = []
     94     for i in set(wordlis):
     95         tf = dic[str(i)]/len(wordlis)  # 计算TF:某个词在文章中出现的次数/文章总词数
     96         # 计算IDF:log(语料库的文档总数/(包含该词的文档数+1))
     97         idf = math.log(len(filelist)/(wordinfilecount(str(i), corpuslist)+1))
     98         tfidf = tf*idf  # 计算TF-IDF
     99         outdic[str(i)] = tfidf
    100     orderdic = sorted(outdic.items(), key=operator.itemgetter(
    101         1), reverse=True)  # 给字典排序
    102     return orderdic
    103 
    104 
    105 def befwry(lis):  # 写入预处理,将list转为string
    106     outall = ''
    107     for i in lis:
    108         ech = str(i).replace("('", '').replace("',", '\t').replace(')', '')
    109         outall = outall+'\t'+ech+'\n'
    110     return outall
    111 
    112 
    113 def main():
    114     swpath = r'哈工大停用词表.txt'#停用词表路径
    115     swlist = getstopword(swpath)  # 获取停用词表列表
    116 
    117     filepath = r'corpus'
    118     filelist = fun(filepath)  # 获取文件列表
    119 
    120     wrypath = r'TFIDF.txt'
    121 
    122     corpuslist = corpus(filelist, swlist)  # 建立语料库
    123 
    124     outall = ''
    125 
    126     for i in filelist:
    127         afterswlis = getridofsw(toword(read(str(i))), swlist)  # 获取每一篇已经去除停用的词表
    128         tfidfdic = tf_idf(afterswlis, filelist, corpuslist)  # 计算TF-IDF
    129 
    130         titleary = str(i).split('\\')
    131         title = str(titleary[-1]).replace('utf8.txt', '')
    132         echout = title+'\n'+befwry(tfidfdic)
    133         print(title+' is ok!')
    134         outall = outall+echout
    135     print(wry(outall, wrypath)+' is ok!')
    136 
    137 if __name__ == '__main__':
    138     main()
    

     

    总结:

    TF-IDF算法的优点是简单快速,结果比较符合实际情况。

    缺点是,单纯以"词频"衡量一个词的重要性,不够全面,有时重要的词可能出现次数并不多。

    而且,这种算法无法体现词的位置信息,出现位置靠前的词与出现位置靠后的词,都被视为重要性相同,这是不正确的。(一种解决方法是,对全文的第一段和每一段的第一句话,给予较大的权重。)

     

     

    TF-IDF与与余弦相似的应用:找相似文章

    除了找到关键词,还希望找到与原文章相似的其他文章

    需要用到余弦相似性:

    句子A:我喜欢看电视,不喜欢看电影

    句子B:我不喜欢看电视,也不喜欢看电影

    基本思路是:如果这两句话的用词越相似,它们的内容就应该越相似。因此,可以从词频入手,计算它们的相似程度。

     

    1、分词

      句子A:我/喜欢/看/电视,不/喜欢/看/电影。

      句子B:我/不/喜欢/看/电视,也/不/喜欢/看/电影。

    2、列出所有值

      我,喜欢,看,电视,电影,不,也。

    3、计算词频

      句子A:我 1,喜欢 2,看 2,电视 1,电影 1,不 1,也 0。

      句子B:我 1,喜欢 2,看 2,电视 1,电影 1,不 2,也 1

    4、写出词频向量。

      句子A:[1, 2, 2, 1, 1, 1, 0]

      句子B:[1, 2, 2, 1, 1, 2, 1]

    我们可以通过夹角的大小,来判断向量的相似程度。夹角越小,就代表越相似。假定a向量是[x1, y1],b向量是[x2, y2],那么可以将余弦定理改写成下面的形式

     结论:

      我们就得到了"找出相似文章"的一种算法:

    • 使用TF-IDF算法,找出两篇文章的关键词
    • 每篇文章各取出若干个关键词(比如20个),合并成一个集合,计算每篇文章对于这个集合中的词的词频(为了避免文章长度的差异,可以使用相对词频);
    • 生成两篇文章各自的词频向量
    • 计算两个向量的余弦相似度,值越大就表示越相似

    计算两个向量的余弦相似度,值越大就表示越相似

     

     

    如何通过词频,对文章进行自动摘要

    信息都包含在句子中,有些句子包含的信息多,有些句子包含的信息少。"自动摘要"就是要找出那些包含信息最多的句子。

    句子的信息量用"关键词"来衡量。如果包含的关键词越多,就说明这个句子越重要。

    Luhn提出用"簇"(cluster)表示关键词的聚集。所谓"簇"就是包含多个关键词的句子片段。

     

    只要关键词之间的距离小于"门槛值",它们就被认为处于同一个簇之中。Luhn建议的门槛值是4或5。也就是说,如果两个关键词之间有5个以上的其他词,就可以把这两个关键词分在两个簇。

    簇的重要性 = (包含的关键词数量)^2 / 簇的长度。其中的簇一共有7个词,其中4个是关键词。因此,它的重要性分值等于 ( 4 x 4 ) / 7 = 2.3。

    然后,找出包含分值最高的簇的句子(比如5句),把它们合在一起,就构成了这篇文章的自动摘要

     

    转载于:  https://www.cnblogs.com/wang2825/articles/8974494.html

    展开全文
  • Python TFIDF计算文本相似度

    千次阅读 2020-02-02 22:25:28
    本文主要参考https://stackoverflow.com/questions/12118720/python-tf-idf-cosine-to-find-document-similaritStackOverflow的...cosine_similarity就是计算L2归一化的向量点乘。如果x,y是行向量,它们的cosine sim...

    本文主要参考https://stackoverflow.com/questions/12118720/python-tf-idf-cosine-to-find-document-similaritStackOverflow的回答
    主要是使用sklearn的TfidfTransformer

    cosine_similarity就是计算L2归一化的向量点乘。如果x,y是行向量,它们的cosine similarityk是:
    在这里插入图片描述
    linear_kernel 是多项式核的特例,如果x,和y是列向量,他们的线性核为:
    在这里插入图片描述

    fit &fit_tansform & transform

    • fit是一个适配的过程,用于train,得到一个统一的转换的规则的模型;
    • transform:将数据进行转换,比如测试数据按照训练数据同样的模型进行转换,得到特征向量;
    • fit_tansform:将上述两个合并起来,fit to data,then transform it. 如果训练阶段用的是fit_transform,在测试阶段只需要transform就行

    也就是一般训练的时候用fit_transform(train_data)
    在测试的时候用transform(test_data)

    回答一

    如果你想提取count features并应用TF-IDFnormalizaition以及行基础的欧式距离,用一个操作就行:
    TFidfVectorizor

    >>> from sklearn.feature_extraction.text import TfidfVectorizer
    >>> from sklearn.datasets import fetch_20newsgroups
    >>> twenty = fetch_20newsgroups()
    
    >>> tfidf = TfidfVectorizer().fit_transform(twenty.data)
    >>> tfidf
    <11314x130088 sparse matrix of type '<type 'numpy.float64'>'
        with 1787553 stored elements in Compressed Sparse Row format>
    

    现在要求一个文档(如第一句)同其他所有文档的距离,只需要计算第一个向量和其他所有向量的点乘,因为tfidf向量已经row-normalized
    cos距离并不考虑向量的大小(也就是绝对值),Row-normalised(行标准化)向量大小为1,所以Linear Kernel足够计算相似值。
    scipy sparse matrix查看第一个向量:

    >>> tfidf[0:1]
    <1x130088 sparse matrix of type '<type 'numpy.float64'>'
        with 89 stored elements in Compressed Sparse Row format>
    

    scikit-learn已经提供了pairwise metrics,稀疏的不稀疏的矩阵表示。这里我们需要点乘操作,也叫linear kernel:

    >>> from sklearn.metrics.pairwise import linear_kernel
    >>> cosine_similarities = linear_kernel(tfidf[0:1], tfidf).flatten()
    >>> cosine_similarities
    array([ 1.        ,  0.04405952,  0.11016969, ...,  0.04433602,
        0.04457106,  0.03293218])
    

    这里插播一下,linear_kernel的输入是(NT)和(MT)的向量,输出(N*M)的向量

    因此,要找5个最接近的相关文档,只需要用argsort切片取就行了:

    >>> related_docs_indices = cosine_similarities.argsort()[:-5:-1]
    >>> related_docs_indices
    array([    0,   958, 10576,  3277])
    >>> cosine_similarities[related_docs_indices]
    array([ 1.        ,  0.54967926,  0.32902194,  0.2825788 ])
    

    第一个结果用于检查,这是query本身,相似度为1
    在这个例子里,learn_kernel就相当于cos similarity,因为sklearn.feature_extraction.text.TfidfVectorizer本身得到的就是归一化后的向量,这样cosine_similarity就相当于linear_kernel

    回答2

    是个手动计算的方法
    循环计算test_data与train_data的特征间的cosine 距离
    首先用简单的lambda函数表示cosine距离的计算:

    cx = lambda a, b : round(np.inner(a, b)/(LA.norm(a)*LA.norm(b)), 3)
    

    然后就只要for循环就行

    for vector in trainVectorizerArray:
        print vector
        for testV in testVectorizerArray:
            print testV
            cosine = cx(vector, testV)
            print cosine
    

    回答3

    跟回答1一样,不过直接用cosine_similarity

    from sklearn.feature_extraction.text import CountVectorizer
    from sklearn.metrics.pairwise import cosine_similarity
    from sklearn.feature_extraction.text import TfidfVectorizer
    print "cosine scores ==> ",cosine_similarity(tfidf_matrix_train[0:1], tfidf_matrix_train)  #here the first element of tfidf_matrix_train is matched with other elements
    
    展开全文
  • 5、计算tfidf TFIDF=tF* iDF tFIDF_DF =pandas.DataFrame(TFIDF) 6、将每个文本中tfidf值排名前100的词和相应的tfidf值输出 file= [] for root ,dirs,files in os.walk(r ' H:\19113117 - 副本 ' ):...
  • 在sql下计算tfidf

    2017-12-05 08:42:00
    因为在R或者python中写起tfidf来还是很方便的,直接调个包,或者直接写都很快,但在sql中写起来有点慢,比较冗长,也有可能我写的不多。。下面分tfidf的 理论部分 sql操作 来介绍本文: tfidf给我直观的感觉就是...
  • python+jieba+tfidf算法 文本相似度

    万次阅读 多人点赞 2018-05-16 20:57:28
    gensim库,利用TFIDF算法来进行文本相似度计算,通过利用gensim库的corpora,models,similarities处理后续。基本思路:jieba进行分词,整理为指定格式-&gt;gensim库将要对比的文档通过doc2bow转化为稀疏向量-&...
  • python代码: # -*- coding: utf-8 -*- from gensim import corpora, models, similarities import logging from collections import defaultdict logging.basicConfig(format='%(asctime)s : %(levelname)s : %...
  • TFIDF——python

    2019-11-13 09:10:46
    每篇文章各取出若干个关键词(比如20个),合并成一个集合,计算每篇文章对于这个集合中的词的词频(为了避免文章长度的差异,可以使用相对词频); 生成两篇文章各自的词频向量 计算两个向量的余弦相似度,值...
  • TFIDFpython实现

    2021-05-21 16:59:51
    TFIDF介绍 现在有一篇长文《中国的蜜蜂养殖》,用计算机提取它的关键词。 1、词频:如果某个词很重要,它应该在这篇文章中多次出现。我们进行"词频"(Term Frequency,缩写为TF)统计。 2、停用词:结果你肯定猜到了...
  • 这篇文章主要是讲述如何通过LDA处理文本内容TXT,并计算其文档主题分布,主要是核心代码为主和运行效果图形。希望文章对你有所帮助吧尤其是初学者~哎!最后感叹下时光吧,仅以此诗纪念这三年写博客的坚持和北理工的...
  • 2.1计算TFIDF值之前的前期处理 import re import os import sys import codecs import jieba stopw = [line.strip().decode(‘utf-8’) for line in open(u’F:/自然语言处理/stops.txt’).readlines()]...
  • TFIDF

    2019-09-14 16:25:20
    TFIDF python 实战 1.TFIDF算法原理 TFIDF (term frequency - inverse document frequency) 主要思想:如果某个词或者短语在一篇文章中出现的频率TF较高,而且在其他文章中出现的频率较少,则认为此词或短语具有很...
  • python计算稀疏表示的TF-IDF

    千次阅读 2018-04-02 20:47:20
    使用sklean的计算方法,这种结果是稠密矩阵,如果数据集太大,...tfidf详细计算参考:https://blog.csdn.net/Eastmount/article/details/50323063 import jieba import jieba.posseg as pseg import os import ...
  • python 计算两个文本的相似性

    千次阅读 2019-09-09 10:41:16
    tfidf模型与lsi模型 参考:https://www.jianshu.com/p/edf666d3995f
  • [python] 基于k-means和tfidf的文本聚类代码简单实现

    万次阅读 多人点赞 2016-01-08 02:52:26
    3.scikit-learn对文本内容进行tfidf计算并构造N*M矩阵(N个文档 M个特征词); 4.再使用K-means进行文本聚类(省略特征词过来降维过程); 5.最后对聚类的结果进行简单的文本处理,按类簇归类,也可以计算P/R/F特征值...
  • 3.查询 计算哪个index的tfidf之和最大,实现搜索功能 实现代码 封装成搜索类 logging.basicConfig(format="%(asctime)s %(name)s:%(levelname)s:%(message)s", datefmt="%d-%M-%Y %H:%M:%S", l

空空如也

空空如也

1 2 3 4 5
收藏数 94
精华内容 37
关键字:

python计算tfidf

python 订阅