用Python给文本创立向量空间模型的教程

2024-04-01 18:08:02 30

我们需要开始思考如何将文本集合转化为可量化的东西。最简单的方法是考虑词频。

我将尽量尝试不使用NLTK和Scikits-Learn包。我们首先使用Python讲解一些基本概念。

基本词频

首先，我们回顾一下如何得到每篇文档中的词的个数：一个词频向量。

#examplestakenfromhere:http://stackoverflow.com/a/1750187

mydoclist=['JulielovesmemorethanLindalovesme',
'JanelikesmemorethanJulielovesme',
'Helikesbasketballmorethanbaseball']

#mydoclist=['sunskybright','sunsunbright']

fromcollectionsimportCounter

fordocinmydoclist:
tf=Counter()
forwordindoc.split():
tf[word]+=1
printtf.items()

[('me',2),('Julie',1),('loves',2),('Linda',1),('than',1),('more',1)]
[('me',2),('Julie',1),('likes',1),('loves',1),('Jane',1),('than',1),('more',1)]
[('basketball',1),('baseball',1),('likes',1),('He',1),('than',1),('more',1)]

这里我们引入了一个新的Python对象，被称作为Counter。该对象只在Python2.7及更高的版本中有效。Counters非常的灵活，利用它们你可以完成这样的功能：在一个循环中进行计数。

根据每篇文档中词的个数，我们进行了文档量化的第一个尝试。但对于那些已经学过向量空间模型中“向量”概念的人来说，第一次尝试量化的结果不能进行比较。这是因为它们不在同一词汇空间中。

我们真正想要的是，每一篇文件的量化结果都有相同的长度，而这里的长度是由我们语料库的词汇总量决定的。

importstring#allowsforformat()

defbuild_lexicon(corpus):
lexicon=set()
fordocincorpus:
lexicon.update([wordforwordindoc.split()])
returnlexicon

deftf(term,document):
returnfreq(term,document)

deffreq(term,document):
returndocument.split().count(term)

vocabulary=build_lexicon(mydoclist)

doc_term_matrix=[]
print'Ourvocabularyvectoris['+','.join(list(vocabulary))+']'
fordocinmydoclist:
print'Thedocis"'+doc+'"'
tf_vector=[tf(word,doc)forwordinvocabulary]
tf_vector_string=','.join(format(freq,'d')forfreqintf_vector)
print'ThetfvectorforDocument%dis[%s]'%((mydoclist.index(doc)+1),tf_vector_string)
doc_term_matrix.append(tf_vector)

#here'satest:whydidIwrapmydoclist.index(doc)+1inparens?itreturnsanint...
#tryit!type(mydoclist.index(doc)+1)

print'Allcombined,hereisourmasterdocumenttermmatrix:'
printdoc_term_matrix

我们的词向量为[me,basketball,Julie,baseball,likes,loves,Jane,Linda,He,than,more]

文档”JulielovesmemorethanLindalovesme”的词频向量为：[2,0,1,0,0,2,0,1,0,1,1]

文档”JanelikesmemorethanJulielovesme”的词频向量为：[2,0,1,0,1,1,1,0,0,1,1]

文档”Helikesbasketballmorethanbaseball”的词频向量为：[0,1,0,1,1,0,0,0,1,1,1]

合在一起，就是我们主文档的词矩阵：

[[2,0,1,0,0,2,0,1,0,1,1],[2,0,1,0,1,1,1,0,0,1,1],[0,1,0,1,1,0,0,0,1,1,1]]

好吧，这看起来似乎很合理。如果你有任何机器学习的经验，你刚刚看到的是建立一个特征空间。现在每篇文档都在相同的特征空间中，这意味着我们可以在同样维数的空间中表示整个语料库，而不会丢失太多信息。

标准化向量，使其L2范数为1

一旦你在同一个特征空间中得到了数据，你就可以开始应用一些机器学习方法：分类、聚类等等。但实际上，我们同样遇到一些问题。单词并不都包含相同的信息。

如果有些单词在一个单一的文件中过于频繁地出现，它们将扰乱我们的分析。我们想要对每一个词频向量进行比例缩放，使其变得更具有代表性。换句话说，我们需要进行向量标准化。

我们真的没有时间过多地讨论关于这方面的数学知识。现在仅仅接受这样一个事实：我们需要确保每个向量的L2范数等于1。这里有一些代码，展示这是如何实现的。

importmath

defl2_normalizer(vec):
denom=np.sum([el**2forelinvec])
return[(el/math.sqrt(denom))forelinvec]

doc_term_matrix_l2=[]
forvecindoc_term_matrix:
doc_term_matrix_l2.append(l2_normalizer(vec))

print'Aregularolddocumenttermmatrix:'
printnp.matrix(doc_term_matrix)
print'\nAdocumenttermmatrixwithrow-wiseL2normsof1:'
printnp.matrix(doc_term_matrix_l2)

#ifyouwanttocheckthismath,performthefollowing:
#fromnumpyimportlinalgasla
#la.norm(doc_term_matrix[0])
#la.norm(doc_term_matrix_l2[0])

格式化后的旧的文档词矩阵：

[[20100201011]
[20101110011]
[01011000111]]

按行计算的L2范数为1的文档词矩阵：

[[0.577350270.0.288675130.0.0.57735027
0.0.288675130.0.288675130.28867513]
[0.632455530.0.316227770.0.316227770.31622777
0.316227770.0.0.316227770.31622777]
[0.0.408248290.0.408248290.408248290.0.
0.0.408248290.408248290.40824829]]

还不错，没有太深究线性代数的知识，你就可以马上看到我们按比例缩小了各个向量，使它们的每一个元素都在0到1之间，并且不会丢失太多有价值的信息。你看到了，一个计数为1的词在一个向量中的值和其在另一个向量中的值不再相同。

为什么我们关心这种标准化吗？考虑这种情况，如果你想让一个文档看起来比它实际上和一个特定主题更相关，你可能会通过不断重复同一个词，来增加它包含到一个主题的可能性。坦率地说，在某种程度上，我们得到了一个在该词的信息价值上衰减的结果。所以我们需要按比例缩小那些在一篇文档中频繁出现的单词的值。

IDF频率加权

我们现在还没有得到想要的结果。就像一篇文档中的所有单词不具有相同的价值一样，也不是全部文档中的所有单词都有价值。我们尝试利用反文档词频（IDF）调整每一个单词权重。我们看看这包含了些什么：

defnumDocsContaining(word,doclist):
doccount=0
fordocindoclist:
iffreq(word,doc)>0:
doccount+=1
returndoccount

defidf(word,doclist):
n_samples=len(doclist)
df=numDocsContaining(word,doclist)
returnnp.log(n_samples/1+df)

my_idf_vector=[idf(word,mydoclist)forwordinvocabulary]

print'Ourvocabularyvectoris['+','.join(list(vocabulary))+']'
print'Theinversedocumentfrequencyvectoris['+','.join(format(freq,'f')forfreqinmy_idf_vector)+']'

我们的词向量为[me,basketball,Julie,baseball,likes,loves,Jane,Linda,He,than,more]

反文档词频向量为[1.609438,1.386294,1.609438,1.386294,1.609438,1.609438,1.386294,1.386294,1.386294,1.791759,1.791759]

现在，对于词汇中的每一个词，我们都有一个常规意义上的信息值，用于解释他们在整个语料库中的相对频率。回想一下，这个信息值是一个“逆”！即信息值越小的词，它在语料库中出现的越频繁。

我们快得到想要的结果了。为了得到TF-IDF加权词向量，你必须做一个简单的计算：tf*idf。

现在让我们退一步想想。回想下线性代数：如果你用一个AxB的向量乘以另一个AxB的向量，你将得到一个大小为AxA的向量，或者一个标量。我们不会那么做，因为我们想要的是一个具有相同维度(1x词数量)的词向量，向量中的每个元素都已经被自己的idf权重加权了。我们如何在Python中实现这样的计算呢？

在这里我们可以编写完整的函数，但我们不那么做，我们将要对numpy做一个简介。

importnumpyasnp

defbuild_idf_matrix(idf_vector):
idf_mat=np.zeros((len(idf_vector),len(idf_vector)))
np.fill_diagonal(idf_mat,idf_vector)
returnidf_mat

my_idf_matrix=build_idf_matrix(my_idf_vector)

#printmy_idf_matrix

太棒了！现在我们已经将IDF向量转化为BxB的矩阵了，矩阵的对角线就是IDF向量。这意味着我们现在可以用反文档词频矩阵乘以每一个词频向量了。接着，为了确保我们也考虑那些过于频繁地出现在文档中的词，我们将对每篇文档的向量进行标准化，使其L2范数等于1。

doc_term_matrix_tfidf=[]

#performingtf-idfmatrixmultiplication
fortf_vectorindoc_term_matrix:
doc_term_matrix_tfidf.append(np.dot(tf_vector,my_idf_matrix))

#normalizing
doc_term_matrix_tfidf_l2=[]
fortf_vectorindoc_term_matrix_tfidf:
doc_term_matrix_tfidf_l2.append(l2_normalizer(tf_vector))

printvocabulary
printnp.matrix(doc_term_matrix_tfidf_l2)#np.matrix()justtomakeiteasiertolookat

set(['me','basketball','Julie','baseball','likes','loves','Jane','Linda','He','than','more'])

[[0.572112570.0.286056280.0.0.57211257
0.0.246395470.0.318461530.31846153]
[0.625589020.0.312794510.0.312794510.31279451
0.269426530.0.0.348228730.34822873]
[0.0.360636120.0.360636120.418685570.0.
0.0.360636120.466115420.46611542]]

太棒了！你刚看到了一个展示如何繁琐地建立一个TF-IDF加权的文档词矩阵的例子。

最好的部分来了：你甚至不需要手动计算上述变量，使用scikit-learn即可。

记住，Python中的一切都是一个对象，对象本身占用内存，同时对象执行操作占用时间。使用scikit-learn包，以确保你不必担心前面所有步骤的效率问题。

注意：你从TfidfVectorizer/TfidfTransformer得到的值将和我们手动计算的值不同。这是因为scikit-learn使用一个Tfidf的改进版本处理除零的错误。这里有一个更深入的讨论。

fromsklearn.feature_extraction.textimportCountVectorizer

count_vectorizer=CountVectorizer(min_df=1)
term_freq_matrix=count_vectorizer.fit_transform(mydoclist)
print"Vocabulary:",count_vectorizer.vocabulary_

fromsklearn.feature_extraction.textimportTfidfTransformer

tfidf=TfidfTransformer(norm="l2")
tfidf.fit(term_freq_matrix)

tf_idf_matrix=tfidf.transform(term_freq_matrix)
printtf_idf_matrix.todense()

Vocabulary:{u'me':8,u'basketball':1,u'julie':4,u'baseball':0,u'likes':5,u'loves':7,u'jane':3,u'linda':6,u'more':9,u'than':10,u'he':2}
[[0.0.0.0.0.289459060.
0.380603870.578918110.578918110.224790780.22479078]
[0.0.0.0.417157590.31725910.3172591
0.0.31725910.63451820.246379990.24637999]
[0.483591210.483591210.483591210.0.0.36778358
0.0.0.0.285616760.28561676]]

实际上，你可以用一个函数完成所有的步骤：TfidfVectorizer

fromsklearn.feature_extraction.textimportTfidfVectorizer

tfidf_vectorizer=TfidfVectorizer(min_df=1)
tfidf_matrix=tfidf_vectorizer.fit_transform(mydoclist)

printtfidf_matrix.todense()

[[0.0.0.0.0.289459060.
0.380603870.578918110.578918110.224790780.22479078]
[0.0.0.0.417157590.31725910.3172591
0.0.31725910.63451820.246379990.24637999]
[0.483591210.483591210.483591210.0.0.36778358
0.0.0.0.285616760.28561676]]

并且我们可以利用这个词汇空间处理新的观测文档，就像这样：

new_docs=['Hewatchesbasketballandbaseball','Julielikestoplaybasketball','Janelovestoplaybaseball']
new_term_freq_matrix=tfidf_vectorizer.transform(new_docs)
printtfidf_vectorizer.vocabulary_
printnew_term_freq_matrix.todense()

{u'me':8,u'basketball':1,u'julie':4,u'baseball':0,u'likes':5,u'loves':7,u'jane':3,u'linda':6,u'more':9,u'than':10,u'he':2}
[[0.577350270.577350270.577350270.0.0.0.
0.0.0.0.]
[0.0.680918560.0.0.517856120.51785612
0.0.0.0.0.]
[0.622766010.0.0.622766010.0.0.
0.47362960.0.0.]]

请注意，在new_term_freq_matrix中并没有“watches”这样的单词。这是因为我们用于训练的文档是mydoclist中的文档，这个词并不会出现在那个语料库的词汇中。换句话说，它在我们的词汇词典之外。

回到Amazon评论文本

练习2

现在是时候尝试使用你学过的东西了。利用TfidfVectorizer，你可以在Amazon评论文本的字符串列表上尝试建立一个TF-IDF加权文档词矩。

importos
importcsv

#os.chdir('/Users/rweiss/Dropbox/presentations/IRiSS2013/text1/fileformats/')

withopen('amazon/sociology_2010.csv','rb')ascsvfile:
amazon_reader=csv.DictReader(csvfile,delimiter=',')
amazon_reviews=[row['review_text']forrowinamazon_reader]

#yourcodehere!!!

用Python给文本创立向量空间模型的教程

热门推荐

随机推荐