我們需要開始思考如何將文字集合轉化為可量化的東西。最簡單的方法是考慮詞頻。
我將盡量嘗試不使用NLTK和Scikits-Learn包。我們首先使用Python講解一些基本概念。
基本詞頻
首先，我們回顧一下如何得到每篇文件中的詞的個數：一個詞頻向量。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#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非常的靈活，利用它們你可以完成這樣的功能：在一個迴圈中進行計數。
根據每篇文件中詞的個數，我們進行了文件量化的第一個嘗試。但對於那些已經學過向量空間模型中“向量”概念的人來說，第一次嘗試量化的結果不能進行比較。這是因為它們不在同一詞彙空間中。
我們真正想要的是，每一篇檔案的量化結果都有相同的長度，而這裡的長度是由我們語料庫的詞彙總量決定的。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
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。這裡有一些程式碼，展示這是如何實現的。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
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）調整每一個單詞權重。我們看看這包含了些什麼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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做一個簡介。
|
1 2 3 4 5 6 7 8 9 10 |
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。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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.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加權的文件詞矩陣的例子。
最好的部分來了：你甚至不需要手動計算上述變數，使用scikit-learn即可。
記住，Python中的一切都是一個物件，物件本身佔用記憶體，同時物件執行操作佔用時間。使用scikit-learn包，以確保你不必擔心前面所有步驟的效率問題。
注意：你從TfidfVectorizer/TfidfTransformer得到的值將和我們手動計算的值不同。這是因為scikit-learn使用一個Tfidf的改進版本處理除零的錯誤。這裡有一個更深入的討論。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
from sklearn.feature_extraction.text import CountVectorizer count_vectorizer = CountVectorizer(min_df=1) term_freq_matrix = count_vectorizer.fit_transform(mydoclist) print "Vocabulary:", count_vectorizer.vocabulary_ from sklearn.feature_extraction.text import TfidfTransformer tfidf = TfidfTransformer(norm="l2") tfidf.fit(term_freq_matrix) tf_idf_matrix = tfidf.transform(term_freq_matrix) print tf_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.28945906 0.
0.38060387 0.57891811 0.57891811 0.22479078 0.22479078]
[ 0. 0. 0. 0.41715759 0.3172591 0.3172591
0. 0.3172591 0.6345182 0.24637999 0.24637999]
[ 0.48359121 0.48359121 0.48359121 0. 0. 0.36778358
0. 0. 0. 0.28561676 0.28561676]]
實際上，你可以用一個函式完成所有的步驟：TfidfVectorizer
|
1 2 3 4 5 6 |
from sklearn.feature_extraction.text import TfidfVectorizer tfidf_vectorizer = TfidfVectorizer(min_df = 1) tfidf_matrix = tfidf_vectorizer.fit_transform(mydoclist) print tfidf_matrix.todense() |
[[ 0. 0. 0. 0. 0.28945906 0.
0.38060387 0.57891811 0.57891811 0.22479078 0.22479078]
[ 0. 0. 0. 0.41715759 0.3172591 0.3172591
0. 0.3172591 0.6345182 0.24637999 0.24637999]
[ 0.48359121 0.48359121 0.48359121 0. 0. 0.36778358
0. 0. 0. 0.28561676 0.28561676]]
並且我們可以利用這個詞彙空間處理新的觀測文件，就像這樣：
|
1 2 3 4 |
new_docs = ['He watches basketball and baseball', 'Julie likes to play basketball', 'Jane loves to play baseball'] new_term_freq_matrix = tfidf_vectorizer.transform(new_docs) print tfidf_vectorizer.vocabulary_ print new_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.57735027 0.57735027 0.57735027 0. 0. 0. 0.
0. 0. 0. 0. ]
[ 0. 0.68091856 0. 0. 0.51785612 0.51785612
0. 0. 0. 0. 0. ]
[ 0.62276601 0. 0. 0.62276601 0. 0. 0.
0.4736296 0. 0. 0. ]]
請注意，在new_term_freq_matrix中並沒有“watches”這樣的單詞。這是因為我們用於訓練的文件是mydoclist中的文件，這個詞並不會出現在那個語料庫的詞彙中。換句話說，它在我們的詞彙詞典之外。
回到Amazon評論文字
練習2
現在是時候嘗試使用你學過的東西了。利用TfidfVectorizer，你可以在Amazon評論文字的字串列表上嘗試建立一個TF-IDF加權文件詞矩。
|
1 2 3 4 5 6 7 8 9 10 |
import os import csv #os.chdir('/Users/rweiss/Dropbox/presentations/IRiSS2013/text1/fileformats/') with open('amazon/sociology_2010.csv', 'rb') as csvfile: amazon_reader = csv.DictReader(csvfile, delimiter=',') amazon_reviews = [row['review_text'] for row in amazon_reader] #your code here!!! |
打賞支援我翻譯更多好文章，謝謝！
打賞譯者
打賞支援我翻譯更多好文章，謝謝！
