Kaggle上NIPSPaper数据集中提供的papers.csv数据集

　　Kaggle上NIPSPaper数据集中提供的papers.csv数据集

　　背景

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

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

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

　　关于数据集

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

　　原创数据集还收录文章 文本。但是，由于重点是理解关键词提取的概念，使用全文可能需要大量计算，所以只使用摘要进行NLP建模。您可以在全文中使用相同的代码块，以获得更好的增强的关键字提取。

　　高级方法

　　

　　导入数据集

　　本文使用的数据集是 Kaggle 上的 NIPS Paper 数据集提供的 paper.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.word count 非常重要，可以向我们表明我们正在处理的数据集的大小以及跨行的字数变化。

　　最常用和最不常用的词

　　浏览最常用的词，不仅可以深入了解常用词，还可以了解可能是特定于数据的潜在停用词的词。将最常用的词与默认的英语停用词进行比较，我们将得到一个需要添加到自定义停用词列表中的词。

　　#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的各种版本的例子。归一化会将所有这些词转换成一个单一的标准化版本——“学习”。

　　词干提取通过删除后缀来规范化文本。

　　词形还原是一种更先进的基于词根的技术。

　　以下示例说明了词干提取和词形还原的工作原理：

　　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

　　

　　删除停用词：停用词包括句子中大量的介词、代词、连词等。在分析文本之前，需要删除这些词，使经常使用的词主要是与上下文相关的词，而不是文本中常用的词。

　　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)

　　

　　

　　词云

　　文字准备

　　语料库中的文本需要转换成机器学习算法可以解释的格式。这种转换有两个部分——标记化和向量化。

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

　　在准备文本时，我们使用词袋模型，忽略词序，只考虑词频。

　　创建字数向量

　　作为转换的第一步，我们将使用 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)

　　

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

　　返回整个字长的编码向量。

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

　　

　　可视化前 N 个 uni-grams、bi-grams 和 tri-grams

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

　　#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-gram 的条形图

　　#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)

　　

　　

　　最常出现的二元组的条形图

　　#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)

　　

　　

　　最常出现的三元组的条形图

　　转换为整数矩阵

　　优化字数的下一步是使用 TF-IDF 向量化器。从 countVectoriser 得到的词数的缺点是大量的一些常用词可能会稀释语料库中更多上下文特定词的影响。这被 TF-IDF 向量化器克服了，它会惩罚在整个文档中出现多次的单词。 TF-IDF 是词频得分，突出显示对上下文更重要的词，而不是文档中频繁出现的词。

　　TF-IDF 由 2 个组件组成：

　　

　　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 代码的良好实践练习。可以使用相同的方法从新闻来源和社交媒体来源中提取关键字。