『NLP学习笔记』TF-IDF算法进行关键词提取(Python迭代器、sorted、lambda、filter)！

àì夳堔傛蜴生んèń 2022-09-12 04:55 594阅读 0赞

<table> 
 <tbody> 
  <tr> 
   <td><font>TF-IDF算法进行关键词提取(Python迭代器、sorted、lambda、filter)！ </font></td> 
  </tr> 
 </tbody> 
</table>

### 文章目录 ###

*  一. 关键词
 *  二. TF-IDF关键词提取算法
 *  三. 算法实现
 *   *  3.1. jieba库实现
     *  3.2. Python自己实现
 *  四. Python中的迭代器iter
 *   *  4.1. \`\_\_getitem\_\_\`
     *  4.2. \`\_\_iter\_\_\`和\`\_\_next\_\_\`
 *  五. Python中的sorted()函数配合lambda用法
 *   *  5.1. 对列表或元组的嵌套
     *  5.2. 对字典的key和value排序

# 一. 关键词 #

>  *  **关键词** 是指能反映文本主题或者意思的词语，如论文中的Keyword字段。**关键词提取**是文本挖掘领域一个很重要的部分，通过对文本提取的关键词可以窥探整个文本的主题思想，进一步应用于文本的推荐或文本的搜索。
>  *  常用的关键词提取算法：`TF-IDF算法、TextRank算法。`

# 二. TF-IDF关键词提取算法 #

>  *  **TF-IDF(Term frequency-inverse document frequency)** 是关键词提取最基本、最简单易懂的方法。判断一个词再一篇文章中是否重要，一个最容易想到的衡量指标就是 **词频(TF)**，重要的词往往在文章中出现的频率也非常高；但另一方面，不是出现次数越多的词就一定重要，因为有些词在各种文章中都频繁出现（例如：我们），那它的重要性肯定不如哪些只在某篇文章中频繁出现的词重要性强。从统计学的角度，就是给予那些 不常见的词以较大的权重，而减少常见词的权重，最终得分较高的词语即为关键词。

>  *  **TF和IDF计算公式如下：**   
>      词频 ( T F ) = 某个词在文章中出现的次数 文章的总词数 (1) \\text \{词频\}(TF)=\\frac\{\\text \{ 某个词在文章中出现的次数 \}\}\{\\text \{文章的总词数\}\}\\tag\{1\} 词频(TF)=文章的总词数某个词在文章中出现的次数(1) 逆文档频率 ( I T F ) = l o g ( 语料库的文档总数 包含该词的文档数+1 ) (2) \\text \{逆文档频率\}(ITF)=log\\left(\\frac\{\\text \{ 语料库的文档总数 \}\}\{\\text \{包含该词的文档数+1\}\}\\tag\{2\}\\right) 逆文档频率(ITF)=log(包含该词的文档数\+1语料库的文档总数)(2)
>  *  一个词 **IDF** 值的计算是根据语料库得出的，如果一个词在语料库中越常见，那么分母就越大，IDF就越小越接近0。分母之所以要加1，是为了避免分母为0（即所有文档都不包含该词）。该词在语料库中越常见，IDF值越小。
>  *  **最终得到TF-IDF值：**   
>      T F − I T F = 词频 ( T F ) × 逆文档频率 ( I T F ) (3) TF-ITF=\\text \{词频\}(TF) \\times \\text \{逆文档频率\}(ITF) \\tag\{3\} TF−ITF=词频(TF)×逆文档频率(ITF)(3)
>  *  可以看出TF-IDF **与一个词在文档中的出现次数成正比**，**与该词在整个语料库中出现次数成反比**。一个词的TF-IDF值非常高，说明这个词比较少见，但是它在这篇文章中多次出现，那么这个词就非常可能是我们需要的关键词。
>  *  以文章《中国的蜜蜂养殖》为例，“蜜蜂”和“养殖”两个词的TF-IDF值都非常高，作为这篇文章的关键词实际上看也是非常合适的。另外“中国”这个词虽然在文章中的词频并不低“蜜蜂”和“养殖”低，但因为它在整个语料库中经常出现，导致IDF值非常低，所以不会作为文章的关键词。

# 三. 算法实现 #

## 3.1. jieba库实现 ##

>  *  Python的jieba库提供了基于TF-IDF算法。

from jieba.analyse import analyse
    tags = analyse.extract_tags(text, topK=20)

>  *  源码所在的位置`jieba.analyse.extract_tags(text)`：[https://github.com/fxsjy/jieba/blob/master/jieba/analyse/tfidf.py][https_github.com_fxsjy_jieba_blob_master_jieba_analyse_tfidf.py]

## 3.2. Python自己实现 ##

>  *  `gen_idf_copy.py`

#!/usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    @author: kaifang zhang
    @license: Apache License
    @time: 2021/21/09
    @contact: kaifang.zkf@dtwave-inc.com
    """
    import os
    import sys
    import math
    import argparse
    import datetime
    from segmenter import segment
    
    
    class MyDocuments(object):  # memory efficient data streaming
        def __init__(self, dirname):
            self.dirname = dirname
            if not os.path.isdir(dirname):
                print(dirname, '- not a directory!')
                sys.exit()  # sys.exit(n) 退出程序引发SystemExit异常
    
        def __iter__(self):
            for dirfile in os.walk(self.dirname):
                for fname in dirfile[2]:
                    text = open(os.path.join(dirfile[0], fname), 'r', encoding='utf-8', errors='ignore').read()
                    yield segment(text)  # time consuming
    
    
    
    def main():  # idf generator
        parser = argparse.ArgumentParser()
        parser.add_argument('--input', help='the dir of input files', type=str, default='./input')
        parser.add_argument('--output', help='the output file of idf', type=str, default='./output/idf.txt')
        args = parser.parse_args()
        inputdir, outputfile = args.input, args.output
    
        documents = MyDocuments(inputdir)
        ignored = {
        '', ' ', '', '。', '：', '，', '）', '（', '！', '?', '”', '“',  '？', '，', '。', '；', '、', '你', '我', '他', '是', '的', '地', '得', '在', '从',
                   '也', '中', '只', '这', '那', '了', '吧', '就', '但', '还', '像', '和', '在', '让', '到', '之', '对', '使', '上', '下', '于',
                   '与', '而', '会', '能', '把', '被', 'on', 'the', 'a', 'of', 'in', '甚', '给', '个'}
        id_freq = {
        }
        i = 0
        for doc in documents:
            doc = set(x for x in doc if x not in ignored)
            for x in doc:
                id_freq[x] = id_freq.get(x, 0) + 1  # get()函数返回指定键的值，如果值不在字典中返回默认值
            if i % 1000 == 0:
                print('Documents processed: ', i, ', time: ', datetime.datetime.now())
            i += 1
    
        with open(outputfile, 'w', encoding='utf-8') as f:
            for key, value in id_freq.items():
                idf = math.log10(i / (value + 1) + 0.01)
                f.write(key + ' ' + str(round(idf, 2)) + '\n')
            f.close()
    
    if __name__ == "__main__":
        main()

>  *  **`segmenter_copy.py`**

#!/usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    @author: kaifang zhang
    @license: Apache License
    @time: 2021/21/09
    @contact: kaifang.zkf@dtwave-inc.com
    """
    import jieba
    import re
    
    def segment(sentence, cut_all=False):
        """三种空格unicode(\u00A0,\u0020,\u3000)表示的区别
        1.不间断空格\u00A0,主要用在office中,让一个单词在结尾处不会换行显示,快捷键ctrl+shift+space;
        2.半角空格(英文符号)\u0020,代码中常用的;
        3.全角空格(中文符号)\u3000,中文文章中使用;
        """
        sentence = sentence.replace('\n', '').replace('\u3000', '').replace('\u00A0', '')
        sentence = ' '.join(jieba.cut(sentence, cut_all=cut_all))
        return re.sub('[a-zA-Z0-9.。:：,，)）(（！!??”“\"]', '', sentence).split()

>  *  **`tfidf_copy.py`**

#!/usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    @author: kaifang zhang
    @license: Apache License
    @time: 2021/21/09
    @contact: kaifang.zkf@dtwave-inc.com
    """
    import sys
    import re
    import argparse
    import pandas as pd
    from segmenter import segment
    
    
    class IDFLoader(object):
        def __init__(self, idf_path):
            self.idf_path = idf_path
            self.idf_freq = {
        }  # idf
            self.mean_idf = 0.0  # 均值
            self.load_idf()
    
        def load_idf(self):  # 从文件中载入idf
            cnt = 0
            with open(self.idf_path, 'r', encoding='utf-8') as f:
                for line in f:
                    try:
                        word, freq = line.strip().split(' ')
                        cnt += 1
                    except Exception as e:
                        pass
                    self.idf_freq[word] = float(freq)
                f.close()
    
            print('Vocabularies loaded: %d' % cnt)
            self.mean_idf = sum(self.idf_freq.values()) / cnt
    
    
    class TFIDF(object):
        def __init__(self, idf_path):
            self.idf_loader = IDFLoader(idf_path)
            self.idf_freq = self.idf_loader.idf_freq
            self.mean_idf = self.idf_loader.mean_idf
    
        def extract_keywords(self, sentence, topK=20):  # 提取关键词
            # 过滤
            ignored = {
        '你', '我', '他', '是', '的', '地', '得', '在', '从', '也', '中', '只', '这', '那', '了', '吧', '就', '但', '还', '像',
                       '和', '在', '让', '到', '之', '对', '使', '上', '下', '于', '与', '而', '会', '能', '把', '被', '甚', '给', '个'}
            seg_list = [one for one in segment(sentence) if one not in ignored]
    
            freq = {
        }
            for w in seg_list:
                freq[w] = freq.get(w, 0.0) + 1.0
            total = sum(freq.values())
    
            for k in freq:  # 计算 TF-IDF
                freq[k] *= self.idf_freq.get(k, self.mean_idf) / total
    
            tags = sorted(freq, key=freq.__getitem__, reverse=True)  # 排序
    
            if topK:
                return tags[:topK]
            else:
                return tags
    
    
    def main():
        parser = argparse.ArgumentParser()
        parser.add_argument('--idffile', help='the dir of input files', type=str, default='./output/idf.txt')
        parser.add_argument('--document', help='the output file of idf', type=str, default='input/业务中台评价文本.xlsx')
        parser.add_argument('--topK', help='the topK of tf-idf', type=int, default=40)
        args = parser.parse_args()
        idffile, document, topK = args.idffile, args.document, args.topK
    
        tdidf = TFIDF(idffile)
    
        data = pd.read_excel(document).values
        text = ""
        for i in range(data.shape[0]):
            for j in range(data.shape[1]):
                content = str(data[i][j])
                if content != "无" and content != "nan":
                    content = re.sub(r"[A-Za-z0-9]", "", content)
                    text = text + content
    
        tags = tdidf.extract_keywords(text, topK)
    
        for tag in tags:
            print(tag)
    
    
    if __name__ == "__main__":
        main()

# 四. Python中的迭代器iter #

## 4.1. `__getitem__` ##

>  *  如果在类中定义了\_\_getitem\_\_()方法，那么它的实例对象（假设为P）就可以以P\[key\]形式取值，当实例对象做P\[key\]运算时，就会调用类中的\_\_getitem\_\_()方法。当对类的属性进行下标的操作时，首先会被\_\_getitem\_\_() 拦截，从而执行在\_\_getitem\_\_()方法中设定的操作，如赋值，修改内容，删除内容等。
>  *  python中"**getitem**"详解：[https://www.cnblogs.com/Aiyuqianer/p/14091062.html][https_www.cnblogs.com_Aiyuqianer_p_14091062.html]

class Taget:
        def __init__(self,id):
            self.id=id
      
        def __getitem__(self, item):
            print('这个方法被调用')
            return self.id
      
    a=Taget('This is id')
    print(a.id)  # This is id
    print(a['python'])

This is id
    这个方法被调用
    This is id

>  *  **通过for … in 访问自定义对象的方式1：`__getitem__`**

class Person:
        def __init__(self):  # 构造函数
            print("调用构造函数！")
            self.result = 1
    
        def __getitem__(self, item):
            self.result += 1
            if self.result >= 10:
                raise StopIteration("停止遍历") # 抛出一个StopIteration异常
            return self.result
    
    
    if __name__ == '__main__':
        p = Person()
        for one in p:
            print(one)

>  *  **注意：`__item__` 的优先级比较高！**

class Person:
        def __init__(self):  # 构造函数
            print("调用构造函数！")
            self.result = 1
    
        def __getitem__(self, item):
            print("getitem")
            self.result += 1
            if self.result >= 10:
                raise StopIteration("停止遍历") # 抛出一个StopIteration异常
            return self.result
    
        def __iter__(self):
            print("iter")
    
    
    if __name__ == '__main__':
        p = Person()
        for one in p:
            print(one)

/Users/devinzhang/miniconda3/envs/info/bin/python /Users/devinzhang/Downloads/my_keyword/test.py
    Traceback (most recent call last):
      File "/Users/devinzhang/Downloads/my_keyword/test.py", line 28, in <module>
        for one in p:
    TypeError: iter() returned non-iterator of type 'NoneType'
    调用构造函数！
    iter
    
    Process finished with exit code 1

>  *  **通过for … in 访问自定义对象的方式2：`__item__`**

class Person:
        def __init__(self):  # 构造函数
            print("调用构造函数！")
            self.result = 1
    
        def __iter__(self):
            print("iter")
            return iter([1, 2, 3, 4, 5])
    
    
    if __name__ == '__main__':
        """
        现在写一个如下的列表，请问这个对象是否可以迭代？答案是可以的，它是一个可迭代对象。
        那请问它是不是一个迭代器？答案不是的。那怎么才能变成一个迭代器？
        iter([1, 2, 3, 4]) 这个结果就是一个迭代器。这个迭代器就可以用next访问它的下一个数据。
        """
        l = [1, 2, 3, 4]
        l = iter([1, 2, 3, 4])  # 所以iter的作用就是：返回括号里面中对象里面的迭代器。
    
        p = Person()
        for one in p:  # for in 这里也是获取对象里的迭代器。
            print(one)

/Users/devinzhang/miniconda3/envs/info/bin/python /Users/devinzhang/Downloads/my_keyword/test.py
    调用构造函数！
    iter
    1
    2
    3
    4
    5
    
    Process finished with exit code 0

class Person:
        def __init__(self):  # 构造函数
            print("调用构造函数！")
            self.result = 1
    
        def __iter__(self):
            print("iter")
            return self  # 不是迭代器
    
        def __next__(self):
            return 1
    
    
    if __name__ == '__main__':
        """
        现在写一个如下的列表，请问这个对象是否可以迭代？答案是可以的，它是一个可迭代对象。
        那请问它是不是一个迭代器？答案不是的。那怎么才能变成一个迭代器？
        iter([1, 2, 3, 4]) 这个结果就是一个迭代器。这个迭代器就可以用next访问它的下一个数据。
        """
        l = [1, 2, 3, 4]
        l = iter([1, 2, 3, 4])  # 所以iter的作用就是：返回括号里面中对象里面的迭代器。
    
        p = Person()
        for one in p:  # for in 这里也是获取对象里的迭代器。
            print(one)

## 4.2. `__iter__`和`__next__` ##

class Person:
        def __init__(self):  # 构造函数
            print("调用构造函数！")
            self.age = 1
    
        def __getitem__(self, item):
            print("getitem")
            self.result += 1
            if self.result >= 10:
                raise StopIteration("停止遍历")  # 抛出一个StopIteration异常
            return self.result
    
        def __iter__(self):
            print("iter")
            return self
    
        def __next__(self):
            self.age += 1
            if self.age >= 5:
                raise StopIteration("停止遍历")  # 抛出一个StopIteration异常
            return self.age
    
    
    if __name__ == '__main__':
        p = Person()
        for one in p:
            print(one)
        pt = iter(p)
        print(p is pt)  # iter(p)返回的也是对象，和p=Person()是一样的。

/Users/devinzhang/miniconda3/envs/info/bin/python /Users/devinzhang/Downloads/my_keyword/test.py
    调用构造函数！
    iter
    2
    3
    4
    iter
    True
    
    Process finished with exit code 0

# 五. Python中的sorted()函数配合lambda用法 #

## 5.1. 对列表或元组的嵌套 ##

>  *  **sort()函数用法**

sorted(iterable[, cmp[, key[, reverse]]])

>  *  **参数说明**
>  *  iterable – **可迭代对象**。
>  *  cmp – **比较的函数**，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
>  *  key – **主要是用来进行比较的元素**，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
>  *  reverse – **排序规则**，reverse = True 降序 ， reverse = False 升序（默认）。

#1、按第二个元素升序排列
    random = [(2, 2), (3, 4), (4, 1), (1, 3)]
    s = sorted(random,key=lambda x:x[1])
    print(s)
    #2、按第一个元素降序排列
    ss = sorted(random,key=lambda x:x[0])
    print(ss)

>  *  **结果如下：**

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5biD6KGj5bCP5byg_size_20_color_FFFFFF_t_70_g_se_x_16][]

## 5.2. 对字典的key和value排序 ##

>  *  **按照key值对字典排序：**

dict = {
        'zhangsan':23, 'lisi':28,'wangwu':12, 'zhaosi':9}
    sorted(dict) # 默认降序排序
    sorted(dict.keys()) # 默认降序排序
    sorted(dict.keys(), reverse=True)

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5biD6KGj5bCP5byg_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

>  *  **按照value值对字典排序：** 要对字典的value排序，则需要用到key参数，这里提供一种使用lambda的方式：

dict = {
        'zhangsan':23, 'lisi':28,'wangwu':12, 'zhaosi':9}
    sorted(dict.items(), key=lambda item:item[1])

![3fd76118ab4a44a290a851cca9b08823.png][]

>  *  这里的dict.items()将dict转换为可迭代对象，迭代对象元素为 `('zhangsan', 23), ('lisi', 28), ('wangwu', 12), ('zhaosi', 9)`。items()将字典转化为了元组，而这里key参数对应的lambda表达式的意思是选取元组中的**第二个元素作为比较参数**，也就是key值作为比较对象。
>  *  `lambda x:y`中x表示输出参数，y表示lambda函数的返回值，所以采用这种方式对字典的value进行排序。
>  *  注意：排序后的返回值是一个list，而原字典中的键值对转换为了list中的元组。

>  *  参考文章：[https://blog.csdn.net/weixin\_42280517/article/details/80500632][https_blog.csdn.net_weixin_42280517_article_details_80500632]

[https_github.com_fxsjy_jieba_blob_master_jieba_analyse_tfidf.py]: https://github.com/fxsjy/jieba/blob/master/jieba/analyse/tfidf.py
[https_www.cnblogs.com_Aiyuqianer_p_14091062.html]: https://www.cnblogs.com/Aiyuqianer/p/14091062.html
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5biD6KGj5bCP5byg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/ecd588f59d3c40e68421f8fd8f56c90a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5biD6KGj5bCP5byg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/f6d6b9df2b824a3fb8b939c6ea9b4629.png
[3fd76118ab4a44a290a851cca9b08823.png]: /images/20220828/a3ff65f6b17743edb32d88468cfe487f.png
[https_blog.csdn.net_weixin_42280517_article_details_80500632]: https://blog.csdn.net/weixin_42280517/article/details/80500632