文本向量空間模型

(點擊上方藍字，快速關注我們)

英文：stanford.edu  編譯： 伯樂在線 - 笑虎

http://python.jobbole.com/81311/

我們需要開始思考如何將文本集合轉化爲可量化的東西。最簡單的方法是考慮詞頻。

我將盡量嘗試不使用NLTK和Scikits-Learn包。我們首先使用Python講解一些基本概念。

基本詞頻

首先，我們回顧一下如何得到每篇文檔中的詞的個數：一個詞頻向量。

#examples taken from here: http://stackoverflow.com/a/1750187

 

mydoclist = ['Julie loves me more than Linda loves me',

'Jane likes me more than Julie loves me',

'He likes basketball more than baseball']

 

#mydoclist = ['sun sky bright', 'sun sun bright']

 

from collections import Counter

 

for doc in mydoclist:

    tf = Counter()

    for word in doc.split():

        tf[word] +=1

    print tf.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非常的靈活，利用它們你可以完成這樣的功能：在一個循環中進行計數。

根據每篇文檔中詞的個數，我們進行了文檔量化的第一個嘗試。但對於那些已經學過向量空間模型中「向量」概念的人來說，第一次嘗試量化的結果不能進行比較。這是因爲它們不在同一詞彙空間中。

我們真正想要的是，每一篇文件的量化結果都有相同的長度，而這裏的長度是由我們語料庫的詞彙總量決定的。

import string #allows for format()

    

def build_lexicon(corpus):

    lexicon = set()

    for doc in corpus:

        lexicon.update([word for word in doc.split()])

    return lexicon

 

def tf(term, document):

  return freq(term, document)

 

def freq(term, document):

  return document.split().count(term)

 

vocabulary = build_lexicon(mydoclist)

 

doc_term_matrix = []

print 'Our vocabulary vector is [' + ', '.join(list(vocabulary)) + ']'

for doc in mydoclist:

    print 'The doc is "' + doc + '"'

    tf_vector = [tf(word, doc) for word in vocabulary]

    tf_vector_string = ', '.join(format(freq, 'd') for freq in tf_vector)

    print 'The tf vector for Document %d is [%s]' % ((mydoclist.index(doc)+1), tf_vector_string)

    doc_term_matrix.append(tf_vector)

    

    # here's a test: why did I wrap mydoclist.index(doc)+1 in parens?  it returns an int...

    # try it!  type(mydoclist.index(doc) + 1)

 

print 'All combined, here is our master document term matrix: '

print doc_term_matrix

我們的詞向量爲[me, basketball, Julie, baseball, likes, loves, Jane, Linda, He, than, more]

文檔」Julie loves me more than Linda loves me」的詞頻向量爲：[2, 0, 1, 0, 0, 2, 0, 1, 0, 1, 1]

文檔」Jane likes me more than Julie loves me」的詞頻向量爲：[2, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1]

文檔」He likes basketball more than baseball」的詞頻向量爲：[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。這裏有一些代碼，展示這是如何實現的。

import math

 

def l2_normalizer(vec):

    denom = np.sum([el**2 for el in vec])

    return [(el / math.sqrt(denom)) for el in vec]

 

doc_term_matrix_l2 = []

for vec in doc_term_matrix:

    doc_term_matrix_l2.append(l2_normalizer(vec))

 

print 'A regular old document term matrix: '

print np.matrix(doc_term_matrix)

print '\nA document term matrix with row-wise L2 norms of 1:'

print np.matrix(doc_term_matrix_l2)

 

# if you want to check this math, perform the following:

# from numpy import linalg as la

# la.norm(doc_term_matrix[0])

# la.norm(doc_term_matrix_l2[0])

格式化後的舊的文檔詞矩陣：

[[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的文檔詞矩陣：

[[ 0.57735027 0. 0.28867513 0. 0. 0.57735027
0. 0.28867513 0. 0.28867513 0.28867513]
[ 0.63245553 0. 0.31622777 0. 0.31622777 0.31622777
0.31622777 0. 0. 0.31622777 0.31622777]
[ 0. 0.40824829 0. 0.40824829 0.40824829 0. 0.
0. 0.40824829 0.40824829 0.40824829]]

還不錯，沒有太深究線性代數的知識，你就可以馬上看到我們按比例縮小了各個向量，使它們的每一個元素都在0到1之間，並且不會丟失太多有價值的信息。你看到了，一個計數爲1的詞在一個向量中的值和其在另一個向量中的值不再相同。

爲什麼我們關心這種標準化嗎？考慮這種情況，如果你想讓一個文檔看起來比它實際上和一個特定主題更相關，你可能會通過不斷重複同一個詞，來增加它包含到一個主題的可能性。坦率地說，在某種程度上，我們得到了一個在該詞的信息價值上衰減的結果。所以我們需要按比例縮小那些在一篇文檔中頻繁出現的單詞的值。

IDF頻率加權

我們現在還沒有得到想要的結果。就像一篇文檔中的所有單詞不具有相同的價值一樣，也不是全部文檔中的所有單詞都有價值。我們嘗試利用反文檔詞頻（IDF）調整每一個單詞權重。我們看看這包含了些什麼：

def numDocsContaining(word, doclist):

    doccount = 0

    for doc in doclist:

        if freq(word, doc) > 0:

            doccount +=1

    return doccount

 

def idf(word, doclist):

    n_samples = len(doclist)

    df = numDocsContaining(word, doclist)

    return np.log(n_samples / 1+df)

 

my_idf_vector = [idf(word, mydoclist) for word in vocabulary]

 

print 'Our vocabulary vector is [' + ', '.join(list(vocabulary)) + ']'

print 'The inverse document frequency vector is [' + ', '.join(format(freq, 'f') for freq in my_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的向量，或者一個標量。我們不會那麼做，因爲我們想要的是一個具有相同維度(1 x詞數量)的詞向量，向量中的每個元素都已經被自己的idf權重加權了。我們如何在Python中實現這樣的計算呢？

在這裏我們可以編寫完整的函數，但我們不那麼做，我們將要對numpy做一個簡介。

import numpy as np

 

def build_idf_matrix(idf_vector):

    idf_mat = np.zeros((len(idf_vector), len(idf_vector)))

    np.fill_diagonal(idf_mat, idf_vector)

    return idf_mat

 

my_idf_matrix = build_idf_matrix(my_idf_vector)

 

#print my_idf_matrix

太棒了！現在我們已經將IDF向量轉化爲BxB的矩陣了，矩陣的對角線就是IDF向量。這意味着我們現在可以用反文檔詞頻矩陣乘以每一個詞頻向量了。接着，爲了確保我們也考慮那些過於頻繁地出現在文檔中的詞，我們將對每篇文檔的向量進行標準化，使其L2範數等於1。

doc_term_matrix_tfidf = []

 

#performing tf-idf matrix multiplication

for tf_vector in doc_term_matrix:

    doc_term_matrix_tfidf.append(np.dot(tf_vector, my_idf_matrix))

 

#normalizing

doc_term_matrix_tfidf_l2 = []

for tf_vector in doc_term_matrix_tfidf:

    doc_term_matrix_tfidf_l2.appendfor tf_vector in doc_term_matrix_tfidf:

    doc_term_matrix_tfidf_l2.append(l2_normalizer(tf_vector))

                                    

print vocabulary

print np.matrix(doc_term_matrix_tfidf_l2) # np.matrix() just to make it easier to look at

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

[[ 0.57211257 0. 0.28605628 0. 0. 0.57211257
0. 0.24639547 0. 0.31846153 0.31846153]
[ 0.62558902 0. 0.31279451 0. 0.31279451 0.31279451
0.26942653 0. 0. 0.34822873 0.34822873]
[ 0. 0.36063612 0. 0.36063612 0.41868557 0. 0.
0. 0.36063612 0.46611542 0.46611542]]

太棒了！你剛看到了一個展示如何繁瑣地建立一個TF-IDF加權的文檔詞矩陣的例子。<