精华内容
参与话题
问答
  • 歪碰下拉框关键字提取工具是一款提取搜索引擎和购物网站等搜索建议关键字,一般多为出现在网站搜索框下方建议区,此处的词语多为网站建议或者搜索量较多的词语,适用于SEO中关
  • 文本关键字提取

    2018-05-21 16:30:33
    文本关键字提取,需要自建知识库,采用文本处理等方式
  • 中文分词 关键字提取 工具类详细文档 每秒60W字的处理量
  • JAVA淘宝关键字提取

    2013-01-08 15:30:52
    淘宝关键字提取 from 天猫大全
  • 今天小编就为大家分享一篇python数据分析:关键字提取方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • python 关键字提取

    千次阅读 2016-10-10 16:24:21
    jieba 关键字提取 import jieba.analyse tags = jieba.analyse.extract_tags(str, topK=3) #str是提取关键字的内容,topK是提取关键字数 print ",".join(tags)

    jieba 关键字提取

    import jieba.analyse
    tags = jieba.analyse.extract_tags(str, topK=3)
    #str是提取关键字的内容,topK是提取关键字数
    print ",".join(tags)


    TF-IDF关键字提取

     是用于资讯检索和文本挖掘的加权技术。是评估一个词对一个文件集或一份文件的重要程度。TF*IDF

    TF(词频)tf(w,d) = count(w, d) / size(d)     count(w, d) :w在文档d中出现的次数   size(d):文档d中的总次数

    IDF(逆向文件频率)idf = log(n / docs(w, D))


    1.安装scikit-learn包

    2.安装jieba分词包

    3.实现

    def find_keywords(string_list, num):
        """查找关键字,num代表查找关键字个数"""
        fenci_result = []
        for str in string_list:
            fenci_result.append(jieba_seg(str))
        vectorizer = CountVectorizer()
        transformer = TfidfTransformer()
        tfidf = transformer.fit_transform(vectorizer.fit_transform(fenci_result))
        word = vectorizer.get_feature_names()
        weight = tfidf.toarray()
        keywords_dict = {}
        for i in range(len(word)):
            keywords_dict[word[i]] = 0.0
            for j in range(len(weight)):
                keywords_dict[word[i]] += weight[j][i]
        keyword_rank_dict = sorted(keywords_dict.iteritems(), key=lambda d: d[1], reverse=True)
        i = 0
        result = []
        for item in keyword_rank_dict:
            i += 1
            if i > num:
                break
            result.append(item[0])
            print item[0].encode("utf8"),
            print item[1]
        return result


    展开全文
  • 今天小编就为大家分享一篇Python3 文章标题关键字提取的例子,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • keywordfinder, 自动关键字提取不需要 Alchemy ! 自动关键字提取作为一个数据科学 Fellow,我完成了一个项目,其中包括构建关键字抽取算法。 给出一个文本块作为输入,该算法选择描述文本内容的关键字。 关键词是...
  • 关键字提取URL(Kitsune) 狐狸是一种实用工具,旨在帮助你从多个搜索引擎中提取URL地址。该方案可以同时使用多个搜索引擎,以便为您提供多种结果。从列表中有超过30选项,用户可以选择搜索引擎。 “配置”窗口,您...
  • tf-idf作为文档关键字提取的常用算法,python将tf-idf封装了对象,可直接使用
  • 新闻关键字提取和新闻推荐

    千次阅读 2018-06-15 11:29:36
    新闻关键字提取和新闻推荐 jieba——超好用的分词器 在介绍我自己的关键字提取之前先介绍一下这个中文处理的包,现在在中文处理里使用非常广泛,也真的效率很高使用便捷。有非常多的功能,也有关键字提取的...

    新闻关键字提取和新闻推荐

    jieba——超好用的分词器

    在介绍我自己的关键字提取之前先介绍一下这个中文处理的包,现在在中文处理里使用非常广泛,也真的效率很高使用便捷。有非常多的功能,也有关键字提取的功能,但是效率一般,不如它的分词功能使用的人多,那么我介绍一下在我的代码会用到的它的2个功能。
    结巴分词分为三种模式:精确模式(默认)、全模式和搜索引擎模式,下面对这三种模式分别举例介绍:

    精确模式

    import jieba
    s = u'我想和女朋友一起去北京故宫博物院参观和闲逛。'
    cut = jieba.cut(s)
    
    print '【Output】'
    print cut
    print ','.join(cut)
    【Output】
    <generator object cut at 0x7f8dbc0efc30>
    我,想,和,女朋友,一起,去,北京故宫博物院,参观,和,闲逛,。

    可见分词结果返回的是一个生成器(这对大数据量数据的分词尤为重要)。

    全模式

    print '【Output】'
    print ','.join(jieba.cut(s,cut_all = True))
    【Output】
    我,想,和,女朋友,朋友,一起,去,北京,北京故宫,北京故宫博物院,故宫,故宫博物院,博物,博物院,参观,和,闲逛,,

    可见全模式就是把文本分成尽可能多的词。

    搜索引擎模式

    print '【Output】'
    print ','.join(jieba.cut_for_search(s))
    【Output】
    我,想,和,朋友,女朋友,一起,去,北京,故宫,博物,博物院,北京故宫博物院,参观,和,闲逛,。

    获取词性

    每个词都有其词性,比如名词、动词、代词等,结巴分词的结果也可以带上每个词的词性,要用到jieba.posseg,举例如下:

    import jieba.posseg as psg
    print '【Output】'
    print [(x.word,x.flag) for x in psg.cut(s)]
    
    # 输出:
    '''
    [(u'我', u'r'), (u'想', u'v'), (u'和', u'c'), (u'女朋友', u'n'), (u'一起', u'm'), 
    (u'去', u'v'), (u'北京故宫博物院', u'ns'), (u'参观', u'n'), (u'和', u'c'), (u'闲逛', u'v'), (u'。', u'x')]
    '''

    可以看到成功获取到每个词的词性,这对于我们对分词结果做进一步处理很有帮助,比如只想获取分词结果列表中的名词,那么就可以这样过滤:

    print [(x.word,x.flag) for x in psg.cut(s) if x.flag.startswith('n')]
    
    # 输出:
    '''
    [(u'女朋友', u'n'), (u'北京故宫博物院', u'ns'), (u'参观', u'n')]
    '''

    至于词性的每个字母分别表示什么词性,jieba分词的结果可能有哪些词性,就要去查阅词性对照表了,本文结尾附了一份从网上搜到的词性对照表,想了解更详细的词性分类信息,可以到网上搜索”结巴分词词性对照”。

    关键词提取

    只要关键词提取准确,新闻推荐就不是什么难事了,在经过各方调查和各种资料的阅读,我发现要想得到非常准确的新闻关键字,即得到某词在文章中的关键程度,有两方面因素都需要考虑:

    • 词本身(词长0.1,词性0.8,词频0.3)0.4
    • 居间度0.6
      tw = 0.4  # 词权重
      vdw = 0.6  # 居间度权重
      lenw = 0.1  # 词长权重
      posw = 0.8  # 词性权重
      tfw = 0.3  # tf词频权重

      以上的小数为每一项因素在我的程序中所占的比例,仅为我个人的想法,可以依据实际情况改动。词长非常容易理解,词的长度。词性是根据jieba分词判断的词性,给出一个该词性在一篇文章中一般来讲的重要程度,比如名词等词性相对来讲会更重要一些,而连词介词则是重要度为0的需要尽量剔除的词。这里给出一份参考的词性重要度表。词频也是字面意思,在一篇文章中词的频率。
    n 0.8
    nr 0.8
    nr1 0.8
    nr2 0.8
    nrj 0.8
    nrf 0.8
    ns 0.8
    nsf 0.8
    nt 0.8
    nz 0.8
    nl 0.6
    ng 0.4
    t 0.6
    tg 0.4
    s 0.3
    f 0.2
    v 0.5
    vd 0.4
    vn 0.6
    vshi 0.0
    vyou 0.0
    vf 0.2
    vx 0.3
    vi 0.3
    vl 0.4
    vg 0.2
    a 0.5
    ad 0.3
    an 0.6
    ag 0.3
    al 0.3
    b 0.3
    bl 0.4
    z 0.4
    r 0.1
    rr 0.1
    rz 0.1
    rzt 0.1
    rzs 0.1
    rzv 0.1
    ry 0.1
    ryt 0.1
    rys 0.1
    ryv 0.1
    rg 0.1
    m 0.2
    mq 0.2
    q 0.1
    qv 0.1
    qt 0.2
    d 0.2
    p 0.1
    pba 0.0
    pbei 0.0
    c 0.0
    cc 0.3
    u 0.1
    uzhe 0.0
    ule 0.0
    uguo 0.0
    ude1 0.0
    ude2 0.0
    ude3 0.0
    usuo 0.0
    udeng 0.0
    uyy 0.0
    udh 0.0
    uls 0.0
    uzhi 0.0
    ulian 0.0
    e 0.0
    y 0.0
    o 0.0
    h 0.0
    k 0.0
    x 0.0
    xx 0.0
    xu 0.0
    w 0.0
    wkz 0.0
    wky 0.0
    wyz 0.0
    wyy 0.0
    wj 0.0
    ww 0.0
    wt 0.0
    wd 0.0
    wf 0.0
    wn 0.0
    wm 0.0
    ws 0.0
    wp 0.0
    wb 0.0
    wh 0.0
    
    居间度是一个需要重点介绍的概念,需要一定离散数学的知识,我自己也不算完全理解透彻了它的意思,但是计算方法还是很好介绍清楚的。

    居间度

    居间度是在将相似度矩阵抽象成图之下进行计算的,所以首先需要介绍一下相似度矩阵。如果将词汇进行两两对比,那么不是所有词的词义差距都是一样大的,比如做和干就是意思非常相近的两个词,而中国和吃饭则完全不是一个意思,那这么多词怎么得到它们之间的相似度呢,可以使用这份将词表示为编码的词表,在这份词表中代码越相近,他们的意思也就越相近。
    完整的这份表见我们项目组的github:

    https://github.com/dl-sdu/Sports-News-Writer

    这里写图片描述
    找到他们的代码计算出相似度之后,我们就需要这篇文章中每两个词汇之间相似度的二维表,然而这个表并不全是0,1表示的,为了大量简化计算,我把所有相似度>0.5的设为1,<0.5的设为0,从而将词汇相似度的二维表抽象成为了一个由顶点和边的图,其中每个顶点就是文章中的一个词,这里需要一点点离散数学的知识了。
        def similar_matrix(self, string_data):
            """
            function: 构建语义相关度网络
            :param string_data: 待分析的语句
            :return: similar_matrix 语义相关度网络
            """
            word_tag_dict = self.word_tag_dictionary()
            keys = word_tag_dict.keys()
            candidate_words_dict, nwword = CandidateWords().get_candidate_list(string_data)
            nwword_words = nwword.values()   #order words
            length = len(nwword_words)
            similar_matrix = numpy.zeros(shape=(length, length))
            word_list = list()
            for word in nwword_words:
                if word in keys:
                    word_list.append(word)
            for i in range(length):
                for j in range(length):
                    if (nwword_words[i] in word_list) and (nwword_words[j] in word_list):
                        similar_matrix[i][j] = self.similarity(i, j, nwword_words, word_tag_dict)
                    else:
                        similar_matrix[i][j] = 0.2
            # self.draw_network(similar_matrix, nwword_words)
            return similar_matrix
    
        def similarity_network_edges(self, string_data):
            similar_matrix = self.similar_matrix(string_data)
            row_col = similar_matrix.shape
            for i in range(row_col[0]):
                for j in xrange(i+1, row_col[0]):
                    if similar_matrix[i][j] > 0.5:
                        self.E.append((i, j))
            return self.E
    对于顶点Vi,它的居间度bci的定义为:

    这里写图片描述

    n是顶点的个数,gmk是顶点m和k之间的最短路径的个数,gmk(Vi)是顶点m和k之间的最短路径中经过顶点Vi的条数。
    对于无向图可以表示为:

    这里写图片描述

    最短路径的算法就使用Dijkstra就可以。简而言之就是哪个点,各个点之间的最短路径都经过它的频率比较高,那么它的居间度就比较高。
     def codes_betweeness_centarlity(self, string_sentence):
            """
            function: 计算词语的居间度
            :param: string_sentence :  待分析的短句
            :return: self.bcdict : 词语居间度
            """
            candidate_words_dict, nwword = CandidateWords().get_candidate_list(string_sentence)
            nwword_words = nwword.values()
            length = len(nwword_words)
            for i in range(length):
                self.G.add_node(i)
            E = SemanticSimilarity().similarity_network_edges(string_sentence)
            self.G.add_edges_from(E)
            vd = nx.betweenness_centrality(self.G, k=None, normalized=True, weight=None, endpoints=False, seed=None)
            for i in range(length):
                self.bcdict[nwword_words[i]] = vd[i]
            for i in range(length):
                self.nword[i] = nwword_words[i]
            return self.bcdict

    停用词

    在一篇新闻中,有的词只是为了保持文章通顺而存在的,这种词的词性也不一定,但是他们在各种文章中都会大量出现但是既不是关键字也对新闻推荐毫无帮助,这样的词叫停用词,比如数字或者符号(+-*/)字母等,还有一些这,那等等与文章最重要表达的意思无关的词,我从网上搜到了一张停用词表并在程序中读入这张表去掉了文章中所有的停用词。

    这里写图片描述

    完整的表还是见GitHub,这里读入停用词表:
            def get_stopwd(self):
                """
                function: 获取停用词表(哈工大+百度停用词表)
                :return: 停用词表
                """
                base_dir = os.path.dirname(__file__)  # 获取当前文件夹的绝对路径
                file_path = os.path.join(base_dir, 'stopwords.txt')  # 获取当前文件夹内的文件
                files = open(file_path, "r")  # 读取文件
                stop_words = files.readlines()
                for line in stop_words:
                    sw = line.strip('\n')
                    sw = sw.decode('utf-8')  # type is str
                    self.stopws.append(sw)
                files.close()
                return self.stopws
    读入文章并用jieba进行分词,同时保留它们的词性:
            def get_candidate_list(self, string_sentence):
                """
                function:使用停用词过滤,
                :param: string_data: 带分析的短句
                :return: candidate_dict: 停用词过滤后的候选词及其词性, nword:候选词词典及其初始化的权重
                """
                stop_words = self.get_stopwd()
                words_tag = pseg.cut(string_sentence)
                for w in words_tag:
                    if w.flag != u'x' and (w.word not in stop_words):
                        self.candidate_word.append(w.word.encode("utf-8"))  # 去除停用词后的候选词candidate_word
                        self.flag.append(w.flag.encode("utf-8"))  # 保留候选词的词性
                for i in range(len(self.flag)):
                    self.candidate_dict[self.candidate_word[i]] = self.flag[i]   # disorder dict (word:flag)
                for i in range(len(self.candidate_word)):
                    self.nword[i] = self.candidate_word[i]
                return self.candidate_dict, self.nword
    接下来统计词长,词频,词性,这些不难,因为词性我们已经储存好了,只需要乘以我们表中的权重就可以了,所以这三样放在一个函数里就行:
        def feature(self, string_data):
            """
            function: 计算候选词的词性权重,词频,词长
            :param string_data: 待分析的语句
            :return:
            """
            base_dir = os.path.dirname(__file__)
            file_path = os.path.join(base_dir, 'tag.txt')
            files = open(file_path, "r")
            poss_file = files.readlines()
            for line in poss_file:
                s = line.strip().split(' ')
                self.poss[s[0]] = s[1]
                #print s[1]
                #print s[0]
            po = self.poss
            candidate_words_dict, nword = CandidateWords().get_candidate_list(string_data)
            nwword_words = nword.values()   #order words
            pos = {}
            for word in nwword_words:
                self.word_length[word] = len(word)/3
                if candidate_words_dict[word] in po.keys():
                    pos[word] = float(po[candidate_words_dict[word]])
                else:
                    pos[word] = 0.1
            words_tf_dict = dict(Counter(nwword_words))                #统计词出现的次数的列表
            files.close()
            return pos, words_tf_dict, self.word_length, nwword_words
    接下里乘以我们预先制定好的各项因素的权重,将所有词从最关键向不关键的排下来,这里选取最重要的7个词进行示范,可以随意更改:
        def score(self, string_data):
            """
            function: 计算候选词的重要性权重(weight)
            :param string_data: 待分析的短句
            :return: 候选词的权重排位
            """
    
            tw = 0.4  # 词权重
            vdw = 0.6  # 居间度权重
            lenw = 0.1  # 词长权重
            posw = 0.8  # 词性权重
            tfw = 0.3  # tf词频权重
            pos, words_tf_dict, word_length, candidate_word = self.feature(string_data)
            vd = BetweenCentrality().codes_betweeness_centarlity(string_data)
            for word in candidate_word:
                s = (vd[word] * vdw ) + (tw * (word_length[word] * lenw + pos[word] * posw + words_tf_dict[word]*tfw))
                self.word_score[word] = s
            rank = sorted(self.word_score.iteritems(), key=lambda d: d[1], reverse=True)
            return rank
    
        def keyword(self, string_data):
            """
            function: 返回关键词及其评分
            :param string_data: 待分析的短句
            :return: keywords :关键词,关键词评分
            """
            key_score = self.score(string_data)
            keywords = []
            for key in key_score[0:7]:
                keywords.append(key[0])
            return keywords, key_score
    大功告成以后对比一下这之下的分词效果和jieba的效果。
    def main_keyword(news_list):
        string = ''
        for i in news_list:
            string += i
        keyword_list = Keyword().keyword(string)
        keywords = keyword_list[0]
        print '------------本程序的提取效果--------------'
        for key in keywords:
            print key
        print '\n'
        print '------------结巴分词的提取效果--------------'
        jieba_list = jieba.analyse.extract_tags(string)
        for key in jieba_list:
            print key
        print '\n'
        return keywords
    现在随便挑选一篇新闻如下:

    勇士几乎不可阻挡,骑士以联盟第一人詹姆斯为核心,总决赛面对勇士,2年竟然只获得一场比赛的胜利!美球迷凯尔特人球迷表示:凯尔特人才是勇士最好的对手!这真不是吹我的主队!凯尔特人不论是首发高度、替补深度都能够与勇士成分庭抗礼之势。我们有三名同位置上顶尖的球员霍福德、海沃德、欧文。防守端对勇士也能形成威胁。连勇士球迷都在感叹:等不及看到海沃德王者归来了!表示全联盟只有凯尔特人能与勇士抗衡了!海沃德和凯尔特人主教练史蒂文斯早有合作!在大学时期,少帅就是海沃德的主教练。他们在完全不被看好的情况下,打进了NCAA总决赛。两人在凯尔特人相遇,他们毫无疑问将会在北岸球馆,继续诠释着那些以往就已经契合的思维和理念。这对天作之合将是凯尔特人冲冠阵容最强大的力量!

    运行结果如下,觉得我的效果更好一点:

    这里写图片描述

    获得关键词及他们的重要排名以后,我对他们进行给分,从最重要的100分,每个递减10分,第7重要的40分,然后用TFIDF做基于内容的推荐。

    新闻推荐

    新闻推荐是门大学问了,分为以下几种:

    • 基于内容(相似度)的推荐

    • 基于用户/物品相似度的协同过滤

    • 热点新闻推荐(你看到的那些头条新闻)

    • 基于模型的推荐(通过输入一些用户特征进入模型,产生推荐结果)

    • 混合推荐(以上十八般兵器一起耍!)

      这里只做基于内容相似度的推荐,我们依据刚才的关键词及他们的关键程度分,用公式
      Similarity(A,B)=Σi∈mTFIDFA∗TFIDFBSimilarity(A,B)=Σi∈mTFIDFA∗TFIDFB
      简而言之就是求和两篇文章的相似关键词的关键程度分的乘积
      计算两篇文章的相似度然后向编辑推荐相似度最高的文章。

      以上仅为关键代码,具体代码见GitHub:https://github.com/dl-sdu/Sports-News-Writer
      这里写图片描述

    展开全文
  • 邮箱关键字提取

    2017-12-28 15:54:53
    密码对错检测 邮箱密码进行筛选对错,可以提取关键字 密码对错检测 邮箱密码进行筛选对错,可以提取关键字
  • 背景在研究和新闻文章中,关键词构成了一个重要的组成部分,因为它们提供了文章内容的简洁表示。关键词在从信息检索系统,书目数据库和搜索引擎优化中定位...随着自然语言处理(NLP)的出现,关键字提取已经发展为有效...

    背景

    在研究和新闻文章中,关键词构成了一个重要的组成部分,因为它们提供了文章内容的简洁表示。关键词在从信息检索系统,书目数据库和搜索引擎优化中定位文章方面也起着至关重要的作用。关键词还有助于将文章分类为相关主题或学科。

    提取关键词的传统方法涉及基于文章内容和作者的判断手动分配关键词。这涉及大量时间和精力,并且在选择适当的关键字方面也可能不准确。随着自然语言处理(NLP)的出现,关键字提取已经发展为有效且高效。

    在本文中,我们将结合这两者 - 我们将在一系列文章上应用NLP来提取关键字。

    关于数据集

    在本文中,我们将从包含大约3,800个摘要的机器学习数据集中提取关键字。机器学习原始数据集来自Kaggle - NIPS Paper(https://www.kaggle.com/benhamner/nips-papers/home)。神经信息处理系统(NIPS)是世界顶级机器学习会议之一。该数据集包括迄今为止所有NIPS论文的标题和摘要(从1987年的第一次会议到当前的2016年会议)。

    原始数据集还包含文章文本。然而,由于重点是理解关键字提取的概念,使用全文可能需要大量的计算,所以只有摘要被用于NLP建模。可以在全文中使用相同的代码块来获得更好的增强关键字提取。

    高级方法

    导入数据集

    本文使用的数据集是Kaggle上NIPS Paper数据集中提供的papers.csv数据集的子集。仅使用了包含摘要的那些行。标题和摘要已连接在一起,之后文件将另存为制表符分割的* .txt文件。

    import pandas

    # load the dataset

    dataset = pandas.read_csv('papers2.txt', delimiter = '')

    dataset.head()

    我们可以看到,机器学习数据集包含文章ID,发布年份和摘要。

    初步文本探索

    在我们继续进行任何文本预处理之前,建议您根据字数,最常见和最不常见的单词快速浏览数据集。

    获取每个摘要的字数

    #Fetch wordcount for each abstract

    dataset['word_count'] = dataset['abstract1'].apply(lambda x: len(str(x).split(" ")))

    dataset[['abstract1','word_count']].head()

    ##Descriptive statistics of word counts

    dataset.word_count.describe()

    每个摘要的平均字数约为156个字。单词计数范围从最小值27到最大值325.单词计数对于向我们指示我们正在处理的数据集的大小以及跨行的单词计数的变化非常重要。

    最常见和最不常见的词

    浏览一下最常用的单词,不仅可以洞察经常使用的单词,还可以洞察可能是特定于数据的潜在停止词的单词。比较最常用的单词和默认的英语停止词,我们将得到需要添加到自定义停止词列表中的单词列表。

    #Identify common words

    freq = pandas.Series(' '.join(dataset['abstract1']).split()).value_counts()[:20]

    freq

    最常见的词

    #Identify uncommon words

    freq1 = pandas.Series(' '.join(dataset

    ['abstract1']).split()).value_counts()[-20:]

    freq1

    文字预处理

    文本预处理的目标

    稀疏性:在文本挖掘中,基于词频创建巨大的矩阵,其中许多单元具有零值。这个问题被称为稀疏性,并使用各种技术最小化。

    文本预处理可分为两大类 - 噪声消除和归一化。对核心文本分析而言冗余的数据组件可视为噪声。

    文本预处理

    处理同一个单词的多个出现/表示称为标准化。归一化有两种类型 - 词干提取和词形还原。让我们考虑一下learn这个词的各种版本的例子 - learn, learned, learning, learner。归一化会将所有这些单词转换为单个标准化版本 - “learn”。

    词干通过删除后缀来归一化文本。

    Lemmatisation是一种更先进的技术,它基于基于词根。

    以下示例说明了词干和lemmatisation的工作方式:

    from nltk.stem.porter import PorterStemmer

    from nltk.stem.wordnet import WordNetLemmatizer

    lem = WordNetLemmatizer()

    stem = PorterStemmer()

    word = "inversely"

    print("stemming:",stem.stem(word))

    print("lemmatization:", lem.lemmatize(word, "v"))

    要对我们的数据集执行文本预处理,我们将首先导入所需的Python库。

    # Libraries for text preprocessing

    import re

    import nltk

    #nltk.download('stopwords')

    from nltk.corpus import stopwords

    from nltk.stem.porter import PorterStemmer

    from nltk.tokenize import RegexpTokenizer

    #nltk.download('wordnet')

    from nltk.stem.wordnet import WordNetLemmatizer

    删除停止词(stopwords):停止词包括句子中的大量介词,代词,连词等。在分析文本之前,需要删除这些单词,以便经常使用的单词主要是与上下文相关的单词,而不是文本中使用的常用单词。

    python nltk库中有一个默认的停止词列表。此外,我们可能希望添加特定于上下文的停止词,我们在开头列出的“最常用词”对此有用。我们现在将看到如何创建一个停止词列表以及如何添加自定义停止词:

    ##Creating a list of stop words and adding custom stopwords

    stop_words = set(stopwords.words("english"))

    ##Creating a list of custom stopwords

    new_words = ["using", "show", "result", "large", "also", "iv", "one", "two", "new", "previously", "shown"]

    stop_words = stop_words.union(new_words)

    我们现在将逐步执行预处理任务,以获得清理和归一化的文本语料库:

    corpus = []

    for i in range(0, 3847):

    #Remove punctuations

    text = re.sub('[^a-zA-Z]', ' ', dataset['abstract1'][i])

    #Convert to lowercase

    text = text.lower()

    #remove tags

    text=re.sub("?.*?>"," <> ",text)

    # remove special characters and digits

    text=re.sub("(\d|\W)+"," ",text)

    ##Convert to list from string

    text = text.split()

    ##Stemming

    ps=PorterStemmer()

    #Lemmatisation

    lem = WordNetLemmatizer()

    text = [lem.lemmatize(word) for word in text if not word in

    stop_words]

    text = " ".join(text)

    corpus.append(text)

    现在让我们从语料库中查看一个项:

    #View corpus item

    corpus[222]

    数据探索

    现在,我们将可视化我们在预处理后创建的文本语料库,以获得对最常用单词的分析。

    #Word cloud

    from os import path

    from PIL import Image

    from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator

    import matplotlib.pyplot as plt

    % matplotlib inline

    wordcloud = WordCloud(

    background_color='white',

    stopwords=stop_words,

    max_words=100,

    max_font_size=50,

    random_state=42

    ).generate(str(corpus))

    print(wordcloud)

    fig = plt.figure(1)

    plt.imshow(wordcloud)

    plt.axis('off')

    plt.show()

    fig.savefig("word1.png", dpi=900)

    词云

    文本准备

    语料库中的文本需要转换为可由机器学习算法解释的格式。这种转换有两部分 - 标记化和矢量化。

    标记化是将连续文本转换为单词列表的过程。然后通过矢量化过程将单词列表转换为整数矩阵。矢量化也称为特征提取。

    对于文本准备,我们使用bag of words模型,它忽略了单词的顺序,只考虑单词频率。

    创建单词计数向量

    作为转换的第一步,我们将使用CountVectoriser来标记文本并构建已知单词的词汇表。我们首先创建CountVectoriser类的变量“cv”,然后调用fit_transform函数来学习和构建词汇表。

    from sklearn.feature_extraction.text import CountVectorizer

    import re

    cv=CountVectorizer(max_df=0.8,stop_words=stop_words, max_features=10000, ngram_range=(1,3))

    X=cv.fit_transform(corpus)

    现在让我们了解传递给函数的参数:

    cv = CountVectorizer(max_df = 0.8,stop_words = stop_words,max_features = 10000,ngram_range =(1,3))

    max_df - 构建词汇表时,忽略文档频率严格高于给定阈值的项(语料库特定的停止词)。这是为了确保我们只有与上下文相关的单词而不是常用单词。

    max_features - 确定矩阵中的列数。

    n-gram范围 - 我们希望查看单个单词,两个单词(bi-gram)和三个单词(tri-gram)组合的列表。

    返回具有整个词汇长度的编码向量。

    list(cv.vocabulary_.keys())[:10]

    可视化前N个uni-grams, bi-grams & tri-grams

    我们可以使用CountVectoriser来显示前20个unigrams,bi-gram和tri-gram。

    #Most frequently occuring words

    def get_top_n_words(corpus, n=None):

    vec = CountVectorizer().fit(corpus)

    bag_of_words = vec.transform(corpus)

    sum_words = bag_of_words.sum(axis=0)

    words_freq = [(word, sum_words[0, idx]) for word, idx in

    vec.vocabulary_.items()]

    words_freq =sorted(words_freq, key = lambda x: x[1],

    reverse=True)

    return words_freq[:n]

    #Convert most freq words to dataframe for plotting bar plot

    top_words = get_top_n_words(corpus, n=20)

    top_df = pandas.DataFrame(top_words)

    top_df.columns=["Word", "Freq"]

    #Barplot of most freq words

    import seaborn as sns

    sns.set(rc={'figure.figsize':(13,8)})

    g = sns.barplot(x="Word", y="Freq", data=top_df)

    g.set_xticklabels(g.get_xticklabels(), rotation=30)

    最频繁出现的uni-grams的条形图

    #Most frequently occuring Bi-grams

    def get_top_n2_words(corpus, n=None):

    vec1 = CountVectorizer(ngram_range=(2,2),

    max_features=2000).fit(corpus)

    bag_of_words = vec1.transform(corpus)

    sum_words = bag_of_words.sum(axis=0)

    words_freq = [(word, sum_words[0, idx]) for word, idx in

    vec1.vocabulary_.items()]

    words_freq =sorted(words_freq, key = lambda x: x[1],

    reverse=True)

    return words_freq[:n]

    top2_words = get_top_n2_words(corpus, n=20)

    top2_df = pandas.DataFrame(top2_words)

    top2_df.columns=["Bi-gram", "Freq"]

    print(top2_df)

    #Barplot of most freq Bi-grams

    import seaborn as sns

    sns.set(rc={'figure.figsize':(13,8)})

    h=sns.barplot(x="Bi-gram", y="Freq", data=top2_df)

    h.set_xticklabels(h.get_xticklabels(), rotation=45)

    最频繁出现的bi-grams的条形图

    #Most frequently occuring Tri-grams

    def get_top_n3_words(corpus, n=None):

    vec1 = CountVectorizer(ngram_range=(3,3),

    max_features=2000).fit(corpus)

    bag_of_words = vec1.transform(corpus)

    sum_words = bag_of_words.sum(axis=0)

    words_freq = [(word, sum_words[0, idx]) for word, idx in

    vec1.vocabulary_.items()]

    words_freq =sorted(words_freq, key = lambda x: x[1],

    reverse=True)

    return words_freq[:n]

    top3_words = get_top_n3_words(corpus, n=20)

    top3_df = pandas.DataFrame(top3_words)

    top3_df.columns=["Tri-gram", "Freq"]

    print(top3_df)

    #Barplot of most freq Tri-grams

    import seaborn as sns

    sns.set(rc={'figure.figsize':(13,8)})

    j=sns.barplot(x="Tri-gram", y="Freq", data=top3_df)

    j.set_xticklabels(j.get_xticklabels(), rotation=45)

    最频繁发生的tri-grams的条形图

    转换为整数矩阵

    细化单词计数的下一步是使用TF-IDF向量化器。从countVectoriser获得的单词计数的不足之处在于,大量的某些常用单词可能会稀释语料库中更多上下文特定单词的影响。这被TF-IDF矢量化器克服,该矢量化器惩罚在整个文档中出现若干次的单词。TF-IDF是词频分数,它突出显示对上下文更重要的单词,而不是那些在文档中频繁出现的单词。

    TF-IDF由2个组成部分组成:

    TF - TF意思是词频(Term Frequency)

    IDF - IDF意思是逆文本频率指数(Inverse Document Frequency)

    from sklearn.feature_extraction.text import TfidfTransformer

    tfidf_transformer=TfidfTransformer(smooth_idf=True,use_idf=True)

    tfidf_transformer.fit(X)

    # get feature names

    feature_names=cv.get_feature_names()

    # fetch document for which keywords needs to be extracted

    doc=corpus[532]

    #generate tf-idf for the given document

    tf_idf_vector=tfidf_transformer.transform(cv.transform([doc]))

    根据TF-IDF分数,我们可以提取分数最高的单词来获取文档的关键字

    #Function for sorting tf_idf in descending order

    from scipy.sparse import coo_matrix

    def sort_coo(coo_matrix):

    tuples = zip(coo_matrix.col, coo_matrix.data)

    return sorted(tuples, key=lambda x: (x[1], x[0]), reverse=True)

    def extract_topn_from_vector(feature_names, sorted_items, topn=10):

    """get the feature names and tf-idf score of top n items"""

    #use only topn items from vector

    sorted_items = sorted_items[:topn]

    score_vals = []

    feature_vals = []

    # word index and corresponding tf-idf score

    for idx, score in sorted_items:

    #keep track of feature name and its corresponding score

    score_vals.append(round(score, 3))

    feature_vals.append(feature_names[idx])

    #create a tuples of feature,score

    #results = zip(feature_vals,score_vals)

    results= {}

    for idx in range(len(feature_vals)):

    results[feature_vals[idx]]=score_vals[idx]

    return results

    #sort the tf-idf vectors by descending order of scores

    sorted_items=sort_coo(tf_idf_vector.tocoo())

    #extract only the top n; n here is 10

    keywords=extract_topn_from_vector(feature_names,sorted_items,5)

    # now print the results

    print("

    Abstract:")

    print(doc)

    print("

    Keywords:")

    for k in keywords:

    print(k,keywords[k])

    最后

    理想情况下,对于IDF计算有效,它应该基于大型语料库和需要提取关键字的文本的良好代表。在我们的示例中,如果我们使用完整的文章文本而不是摘要,IDF提取将更加有效。但是,考虑到数据集的大小,我将语料库限制为仅用于演示目的的摘要。

    这是一种相当简单的方法来理解NLP的基本概念,并在现实生活中使用一些python代码提供良好的实践练习。可以使用相同的方法从新闻源和社交媒体源中提取关键字。

    展开全文
  • rake-nltk:Python实现使用NLTK的快速自动关键字提取算法
  • 文本摘要(文本关键字提取):https://github.com/AimeeLee77/keyword_extraction TF-IDF、 TextRank、 Word2Vec词聚类 词性标注 情感分析 文本分类(Text Categorization)是指计算机将一篇文章归于预先给定的某一...

    NLP领域:

    中文分词:Chinese Word Segmentation
    文本摘要(文本关键字提取):https://github.com/AimeeLee77/keyword_extraction
    	TF-IDF、
    	TextRank、
    	Word2Vec词聚类
    词性标注
    情感分析
    文本分类(Text Categorization)是指计算机将一篇文章归于预先给定的某一类或某几类的过程
    。。。
    

    中文分词算法

    word2vec
    Viterbi 解码算法
    HMM
    基于深度学习:
    	bi-LSTM(双向长短时记忆)
    	RNN
    

    repo

    LAC:baidu
    jieba: cppjieba
    tensorflow.text:https://github.com/tensorflow/text
    

    Misc

    使用TensorFlow实现基于深度学习的中文分词
    

    文本关键字提取概述

    一篇文档的关键词等同于最能表达文档主旨的N个词语,即对于文档来说最重要的词,因此,可以将文本关键词抽取问题转化为词语重要性排序问题,选取排名前TopN个词语作为文本关键词。目前,主流的文本关键词抽取方法主要有以下两大类:

    (1)基于统计的关键词提取方法
    该方法根据统计信息,如词频,来计算得到文档中词语的权重,按权重值排序提取关键词。TF-IDF和TextRank均属于此类方法,其中TF-IDF方法通过计算单文本词频(Term Frequency, TF)和逆文本频率指数(Inverse Document Frequency, IDF)得到词语权重;TextRank方法基于PageRank的思想,通过词语共现窗口构建共现网络,计算词语得分。此类方法简单易行,适用性较强,然而未考虑词序问题。

    (2)基于机器学习的关键词提取方法
    该方法包括了SVM、朴素贝叶斯等有监督学习方法,以及K-means、层次聚类等无监督学习方法。在此类方法中,模型的好坏取决于特征提取,而深度学习正是特征提取的一种有效方式。由Google推出的Word2Vec词向量模型,是自然语言领域中具有代表性的学习工具。它在训练语言模型的过程中将词典映射到一个更抽象的向量空间中,每一个词语通过高维向量表示,该向量空间中两点之间的距离就对应两个词语的相似程度。

    基于以上研究,本文分别采用TF-IDF方法、TextRank方法和Word2Vec词聚类方法,利用Python语言进行开发,实现文本关键词的抽取。

    from:https://github.com/AimeeLee77/keyword_extraction

    展开全文
  • 文本关键字提取算法归纳

    千次阅读 2018-12-21 17:46:52
    关键字提取算法1、基于统计特征的关键词提取算法TF-IDF2、基于词图模型的关键词抽取算法PageRankTextRank算法 1、基于统计特征的关键词提取算法 基于于统计特征的关键词抽取算法的思想是利用文档中词语的统计信息...
  • 5. 关键字提取算法

    2019-01-07 17:24:30
    有监督主要是通过分类的方式进行,通过构建一个较为丰富和完善的词表,以类似打标签的方式,达到关键字提取的效果。缺点是:人工维护成本很高 无监督主要是:TF-IDF 算法、TextRank 算法和主题模型算法(LSA、LSI、...
  • 关键字提取LSA/LSI/LDA算法

    千次阅读 2019-03-07 22:34:06
    1.关键字提取LSA/LSI/LDA算法
  • python关键字提取算法

    2018-12-28 16:35:41
    python中分词和提取关键字的算法。以及词云代码部分,可以更好帮助需求者。
  • 关键字 提取 寻找
  • 一种关键字提取新方法

    千次阅读 2019-01-04 16:15:25
    一种关键字提取新方法 (转载) 原文链接https://xw.qq.com/amphtml/20181116A037K400 https://xw.qq.com/amphtml/20181116A037K400 提取句子的主谓宾 然后可以 计算两个句子的相似度以及 提取句子的关键字  TF...
  • 作为一种经典的文本关键字提取和摘要自动生成算法,TextRank将文本看做若干单词组成的集合,并通过对单词节点图的节点权值进行迭代计算,挖掘单词之间的潜在语义关系。在TextRank节点图模型的基础上,将马尔可夫状态...
  • Python实现根据关键字提取日志中数据前言源码结语 前言 分析日志是工作中经常要做的事情,比如要将日志中某个特定类型的数据全部提取出来进行分析,我之前都是用Excel来做这个提取的工作(将日志粘贴到Excel,按空格...
  • 人工智能作业-同类多文档关键字提取 搜索引擎作业局部
  • NLP关键字提取之TF-IDF算法

    万次阅读 2018-09-13 11:20:40
    最近在看关键字提取的算法,之前看了hanlp的textrank算法,今天看了下tf-idf算法,这两个算法都比较简单,优缺点也很明显,主要都是通过词频来统计的。这个算法主要是参考了TF-IDF与余弦相似性的应用(一):自动...
  • 实现关键字提取,可识别中文、英文,用C++实现方法齐全。用到数据挖掘中的技术构造。
  • 为了更加直观分析一些岗位要求,我们可以利用jieba分词技术对岗位要求内容进行关键字提取,并通过词云技术进行渲染展示 首先我们将sql文件转化成Excel文件 import pandas as pd import sqlite3 conn = sqlite3....
  • 杂乱的文本串里面提取我们想要的字符是工作中经常碰到的难题,前面我们讲解过关键字+固定长度的提取技巧如下所示,左边的字符里面的规律是关键字“项目”+5位代码,如果我们需要提取5位代码,则使用的公式是:=MID...
  • NLP关键字提取之TextRank算法

    千次阅读 2018-09-06 14:26:53
    今天看了一下HanLP框架的关键字提取的算法,总的来说很简单,就是互相计算词频的一个算法。 谈起自动摘要算法,常见的并且最易实现的当属TF-IDF,但是感觉TF-IDF效果一般,不如TextRank好。 TextRank是在Google的...
  • 关键字提取记录

    2019-06-21 11:19:53
    目的是实现类似这样的效果,就是给一篇文章,自动抽取文章中的关键字 PageRank、TFIDF 利用Anjs进行新闻关键词提取 http://blog.csdn.net/zhaoxinfan/article/details/10403917 利用ictclas进行新闻关键词提取 ...

空空如也

1 2 3 4 5 ... 20
收藏数 2,706
精华内容 1,082
关键字:

关键字提取