devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

关键词提取_关键词提取数据集

作者：很楠不爱3 | 2024-04-14 21:44:46

赞

踩

关键词提取数据集

关键词提取使用的是人民网的粤经济新闻数据，分别实现基于TF-IDF、TextRank和Word2vec词聚类的关键词提取算法。该数据集共包含558个文本文件，每个文件的内容均为标题和摘要。

关键词提取的实现流程

(1)将原始数据处理成result.csv文本，具体编号、标题和摘要，Text.csv数据格式如图所示。

（2）获取每行记录的标题和摘要字段，并拼接这两个字段。

（3）加载自定义停用词表stopWord.txt，然后对拼接的文本进行数据预处理操作，包括分词、去除停用词、用空格分隔文本等。

（4）编写相应算法提取关键词。

（5）将最终结果写进文件进行保存。

项目地址：zz-zik/NLP-Application-and-Practice: 本项目将《自然语言处理与应用实战》原书中代码进行了实现，并在此基础上进行了改进。原书作者：韩少云、裴广战、吴飞等。 (github.com)

数据预处理

基于TF-IDF的关键词提取算法

data_prepare.py:数据预处理，合并文本文件，在data文件夹下生成text.csv文件，内容包括，id、title、key

  1. import os
  2. import csv
  3.  
  4. # 文本文件合并
  5. def text_combine(path):
  6.     # 1.获取文件列表
  7.     files = []
  8.     for file in os.listdir(path):
  9.         if file.endswith(".txt"):
  10.             files.append(path+"/"+file)
  11.     # 2.创建text.csv文件，保存结果
  12.     with open('data/text.csv','w',newline = '',encoding= 'utf-8') as csvfile:
  13.         writer = csv.writer(csvfile)
  14.         writer.writerow(['id','title','abstract'])
  15.         # 3.遍历txt文件，获取文件编号
  16.         for file_name in files:
  17.             number = (file_name.split('/')[1].split('_')[0])
  18.             title,text = '',''
  19.             count = 0
  20.             # 4.读取标题和内容
  21.             with open(file_name,encoding='utf-8-sig') as f:
  22.                 for line in f:
  23.                     if count == 0:
  24.                         title += line.strip()
  25.                     else:
  26.                         text += line.strip()
  27.                     count += 1
  28.             res = [number,title,text]
  29.             writer.writerow(res)
  30.  
  31. #  主函数处理
  32. def main():
  33.     path = 'text_file'
  34.     text_combine(path)
  35.  
  36.  
  37. if __name__ == '__main__':
  38.     main()

基于TextRank的关键词提取算法

tfidf.py实现基于TextRank的关键词提取算法

  1. # coding=utf-8
  2.  
  3. import codecs
  4. import pandas as pd
  5. import numpy as np
  6. # 导入jieba分词
  7. import jieba.posseg
  8. import jieba.analyse
  9. # 导入文本向量化函数
  10. from sklearn.feature_extraction.text import TfidfTransformer
  11. # 导入词频统计函数
  12. from sklearn.feature_extraction.text import CountVectorizer
  13.  
  14.  
  15. # 读取text.csv文件：分词，去停用词，词性筛选
  16. def data_read(text, stopkey):
  17.     l = []
  18.     pos = ['n', 'nz', 'v', 'vd', 'vn', 'l', 'a', 'd']  # 定义选取的词性
  19.     seg = jieba.posseg.cut(text)  # 分词
  20.     for i in seg:
  21.         if i.word not in stopkey and i.flag in pos:  # 去停用词 + 词性筛选
  22.             l.append(i.word)
  23.     return l
  24.  
  25.  
  26. # tf-idf获取文本top10关键词
  27. def words_tfidf(data, stopkey, topK):
  28.     idList, titleList, abstractList = \
  29.         data['id'], data['title'], data['abstract']
  30.     corpus = []  # 将所有文档输出到一个list中，一行就是一个文档
  31.     for index in range(len(idList)):
  32.         # 拼接标题和摘要
  33.         text = '%s。%s' % (titleList[index], abstractList[index])
  34.         text = data_read(text, stopkey)  # 文本预处理
  35.         text = " ".join(text)  # 连接成字符串，空格分隔
  36.         corpus.append(text)
  37.  
  38.     # 1、构建词频矩阵，将文本中的词语转换成词频矩阵
  39.     vectorizer = CountVectorizer()
  40.     # 词频矩阵,a[i][j]:表示j词在第i个文本中的词频
  41.     X = vectorizer.fit_transform(corpus)
  42.     # 2、统计每个词的tf-idf权值
  43.     transformer = TfidfTransformer()
  44.     tfidf = transformer.fit_transform(X)
  45.     # 3、获取词袋模型中的关键词
  46.     word = vectorizer.get_feature_names()
  47.     # 4、获取tf-idf矩阵，a[i][j]表示j词在i篇文本中的tf-idf权重
  48.     weight = tfidf.toarray()
  49.     # 5、打印词语权重
  50.     ids, titles, keys = [], [], []
  51.     for i in range(len(weight)):
  52.         print(u"-------这里输出第", i + 1, u"篇文本的词语tf-idf------")
  53.         ids.append(idList[i])
  54.         titles.append(titleList[i])
  55.         df_word, df_weight = [], []  # 当前文章的所有词汇列表、词汇对应权重列表
  56.         for j in range(len(word)):
  57.             print(word[j], weight[i][j])
  58.             df_word.append(word[j])
  59.             df_weight.append(weight[i][j])
  60.         df_word = pd.DataFrame(df_word, columns=['word'])
  61.         df_weight = pd.DataFrame(df_weight, columns=['weight'])
  62.         word_weight = pd.concat([df_word, df_weight], axis=1)  # 拼接词汇列表和权重列表
  63.         word_weight = word_weight.sort_values(by="weight", ascending=False)  # 按照权重值降序排列
  64.         keyword = np.array(word_weight['word'])  # 选择词汇列并转成数组格式
  65.         word_split = [keyword[x] for x in range(0, topK)]  # 抽取前topK个词汇作为关键词
  66.         word_split = " ".join(word_split)
  67.         keys.append(word_split.encode("utf-8").decode("utf-8"))
  68.  
  69.     result = pd.DataFrame({"id": ids, "title": titles, "key": keys},
  70.                           columns=['id', 'title', 'key'])
  71.     return result
  72.  
  73.  
  74. def main():
  75.     # 读取数据集
  76.     dataFile = 'data/text.csv'
  77.     data = pd.read_csv(dataFile)
  78.     # 停用词表
  79.     stopkey = [w.strip() for w in codecs.open('data/stopWord.txt', 'r', encoding="utf-8").readlines()]
  80.     # tf-idf关键词抽取
  81.     result = words_tfidf(data, stopkey, 10)
  82.     result.to_csv("result/tfidf.csv", index=False)
  83.  
  84.  
  85. if __name__ == '__main__':
  86.     main()

构建文本数据的词向量

textrank.py：根据wiki.zh.text.vector词向量模型构建文本数据的词向量，并获取候选词语的词向量。

  1. # coding=utf-8
  2.  
  3. import pandas as pd
  4. import jieba.analyse
  5.  
  6.  
  7. # 处理标题和摘要，提取关键词
  8. def words_textrank(data, topK):
  9.     idList, titleList, abstractList = data['id'], data['title'], data['abstract']
  10.     ids, titles, keys = [], [], []
  11.     for index in range(len(idList)):
  12.         # 拼接标题和摘要
  13.         text = '%s。%s' % (titleList[index], abstractList[index])
  14.         jieba.analyse.set_stop_words("data/stopWord.txt") # 加载自定义停用词表
  15.         print("\"", titleList[index], "\"", " 10 Keywords - TextRank :")
  16.         # TextRank关键词提取，词性筛选
  17.         keywords = jieba.analyse.textrank(text, topK=topK,
  18.             allowPOS=('n', 'nz', 'v','vd', 'vn','l', 'a', 'd'))
  19.         word_split = " ".join(keywords)
  20.         keys.append(word_split.encode("utf-8").decode("utf-8"))
  21.         ids.append(idList[index])
  22.         titles.append(titleList[index])
  23.  
  24.     result = pd.DataFrame({"id": ids, "title": titles,
  25.                            "key": keys},
  26.                           columns=['id', 'title', 'key'])
  27.     return result
  28.  
  29.  
  30. def main():
  31.     dataFile = 'data/text.csv'
  32.     data = pd.read_csv(dataFile)
  33.     result = words_textrank(data, 10)
  34.     result.to_csv("result/textrank.csv", index=False)
  35.  
  36.  
  37. if __name__ == '__main__':
  38.     main()

基于Word2vec词聚类的关键词提取算法

实现基于Word2vec词聚类的关键词提取算法

（1）编写word2vec_prepare.py，构建候选词向量

  1. # coding=utf-8
  2.  
  3. import warnings
  4. warnings.filterwarnings(action='ignore',
  5.                         category=UserWarning,
  6.                         module='gensim')  # 忽略警告
  7. import codecs
  8. import pandas as pd
  9. import numpy as np
  10. import jieba  # 分词
  11. import jieba.posseg
  12. import gensim  # 加载词向量模型
  13.  
  14. # 返回特征词向量bai
  15. def word_vecs(wordList, model):
  16.     name = []
  17.     vecs = []
  18.     for word in wordList:
  19.         word = word.replace('\n', '')
  20.         try:
  21.             if word in model:  # 模型中存在该词的向量表示
  22.                 name.append(word.encode('utf8').decode("utf-8"))
  23.                 vecs.append(model[word])
  24.         except KeyError:
  25.             continue
  26.     a = pd.DataFrame(name, columns=['word'])
  27.     b = pd.DataFrame(np.array(vecs, dtype='float'))
  28.     return pd.concat([a, b], axis=1)
  29.  
  30.  
  31. # 数据预处理操作：分词，去停用词，词性筛选
  32. def data_prepare(text, stopkey):
  33.     l = []
  34.     # 定义选取的词性
  35.     pos = ['n', 'nz', 'v', 'vd', 'vn', 'l', 'a', 'd']
  36.     seg = jieba.posseg.cut(text)  # 分词
  37.     for i in seg:
  38.         # 去重 + 去停用词 + 词性筛选
  39.         if i.word not in l and i.word\
  40.                 not in stopkey and i.flag in pos:
  41.             # print i.word
  42.             l.append(i.word)
  43.     return l
  44.  
  45. # 根据数据获取候选关键词词向量
  46. def build_words_vecs(data, stopkey, model):
  47.     idList, titleList, abstractList = data['id'], data['title'], data['abstract']
  48.     for index in range(len(idList)):
  49.         id = idList[index]
  50.         title = titleList[index]
  51.         abstract = abstractList[index]
  52.         l_ti = data_prepare(title, stopkey)  # 处理标题
  53.         l_ab = data_prepare(abstract, stopkey)  # 处理摘要
  54.         # 获取候选关键词的词向量
  55.         words = np.append(l_ti, l_ab)  # 拼接数组元素
  56.         words = list(set(words))  # 数组元素去重,得到候选关键词列表
  57.         wordvecs = word_vecs(words, model)  # 获取候选关键词的词向量表示
  58.         # 词向量写入csv文件，每个词400维
  59.         data_vecs = pd.DataFrame(wordvecs)
  60.         data_vecs.to_csv('result/vecs/wordvecs_' + str(id) + '.csv', index=False)
  61.         print ("document ", id, " well done.")
  62.  
  63. def main():
  64.     # 读取数据集
  65.     dataFile = 'data/text.csv'
  66.     data = pd.read_csv(dataFile)
  67.     # 停用词表
  68.     stopkey = [w.strip() for w in codecs.open('data/stopWord.txt', 'r', encoding='utf-8').readlines()]
  69.     # 词向量模型
  70.     inp = 'wiki.zh.text.vector'
  71.     model = gensim.models.KeyedVectors.load_word2vec_format(inp, binary=False)
  72.     build_words_vecs(data, stopkey, model)
  73.  
  74.  
  75. if __name__ == '__main__':
  76.     main()
  77.

（2）编写word2vec_result.py，实现基于WordsVec词聚类的关键词提取算法

  1.  
  2. # coding=utf-8
  3.  
  4. import os
  5. # 导入kmeans聚类算法
  6. from sklearn.cluster import KMeans
  7. import pandas as pd
  8. import numpy as np
  9. import math
  10.  
  11.  
  12. # 对词向量采用K-means聚类抽取TopK关键词
  13. def words_kmeans(data, topK):
  14.     words = data["word"]  # 词汇
  15.     vecs = data.iloc[:, 1:]  # 向量表示
  16.  
  17.     kmeans = KMeans(n_clusters=1, random_state=10).fit(vecs)
  18.     labels = kmeans.labels_  # 类别结果标签
  19.     labels = pd.DataFrame(labels, columns=['label'])
  20.     new_df = pd.concat([labels, vecs], axis=1)
  21.     vec_center = kmeans.cluster_centers_  # 聚类中心
  22.  
  23.     # 计算距离（相似性） 采用欧几里得距离（欧式距离）
  24.     distances = []
  25.     vec_words = np.array(vecs)  # 候选关键词向量，dataFrame转array
  26.     vec_center = vec_center[0]  # 第一个类别聚类中心,本例只有一个类别
  27.     length = len(vec_center)  # 向量维度
  28.     for index in range(len(vec_words)):  # 候选关键词个数
  29.         cur_wordvec = vec_words[index]  # 当前词语的词向量
  30.         dis = 0  # 向量距离
  31.         for index2 in range(length):
  32.             dis += (vec_center[index2] - cur_wordvec[index2]) * \
  33.                    (vec_center[index2] - cur_wordvec[index2])
  34.         dis = math.sqrt(dis)
  35.         distances.append(dis)
  36.     distances = pd.DataFrame(distances, columns=['dis'])
  37.     # 拼接词语与其对应中心点的距离
  38.     result = pd.concat([words, labels, distances], axis=1)
  39.     # 按照距离大小进行升序排序
  40.     result = result.sort_values(by="dis", ascending=True)
  41.  
  42.     # 抽取排名前topK个词语作为文本关键词
  43.     wordlist = np.array(result['word'])
  44.     # 抽取前topK个词汇
  45.     word_split = [wordlist[x] for x in range(0, topK)]
  46.     word_split = " ".join(word_split)
  47.     return word_split
  48.  
  49.  
  50. def main():
  51.     # 读取数据集
  52.     dataFile = 'data/text.csv'
  53.     articleData = pd.read_csv(dataFile)
  54.     ids, titles, keys = [], [], []
  55.  
  56.     rootdir = "result/vecs"  # 词向量文件根目录
  57.     fileList = os.listdir(rootdir)  # 列出文件夹下所有的目录与文件
  58.     # 遍历文件
  59.     for i in range(len(fileList)):
  60.         filename = fileList[i]
  61.         path = os.path.join(rootdir, filename)
  62.         if os.path.isfile(path):
  63.             # 读取词向量文件数据
  64.             data = pd.read_csv(path, encoding='utf-8')
  65.             # 聚类算法得到当前文件的关键词
  66.             artile_keys = words_kmeans(data, 5)
  67.             # 根据文件名获得文章id以及标题
  68.             (shortname, extension) = os.path.splitext(filename)
  69.             t = shortname.split("_")
  70.             article_id = int(t[len(t) - 1])  # 获得文章id
  71.             # 获得文章标题
  72.             artile_tit = articleData[articleData.id ==
  73.                                      article_id]['title']
  74.             print(artile_tit)
  75.             print(list(artile_tit))
  76.             artile_tit = list(artile_tit)[0]  # series转成字符串
  77.             ids.append(article_id)
  78.             titles.append(artile_tit)
  79.             keys.append(artile_keys.encode("utf-8").decode("utf-8"))
  80.     # 所有结果写入文件
  81.     result = pd.DataFrame({"id": ids, "title": titles, "key": keys},
  82.                           columns=['id', 'title', 'key'])
  83.     result = result.sort_values(by="id", ascending=True)  # 排序
  84.     result.to_csv("result/word2vec.csv", index=False,
  85.                   encoding='utf_8_sig')
  86.  
  87.  
  88. if __name__ == '__main__':
  89.     main()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/424276
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号