Pythonを使ってテキストにベクトル空間モデルの教程を創立します.

私たちはテキストのセットを定量化できるものにする方法を考える必要があります.一番簡単な方法は単語の周波数を考慮することです.
なるべくNLTKとSciits-Leearnパッケージを使わないようにします.まず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)]

ここではCounterと呼ばれる新しいPythonオブジェクトを紹介します.オブジェクトはPython 2.7およびより高いバージョンでのみ有効です.Countersは非常に柔軟で、それらを利用してこのような機能を完成できます.1サイクルでカウントします.
各ドキュメントの単語数に基づいて、ドキュメントの量子化の最初の試みを行った.しかし、ベクトル空間モデルにおける「ベクトル」概念を学んだ人にとって、初めて量子化を試みた結果は比較できない.なぜなら、彼らは同じ語彙空間にいないからです.
私達が本当に欲しいのは、各ファイルの量子化結果には同じ長さがあります.ここの長さは私達のコーパスの語彙の総量で決められています. 

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,baskeetball,Jule,baseball,likes,loves,Jane,Linda,He,than,more]です.
ドキュメント"Jule loves me more than Linda loves me"の語彙ベクトルは、[2,0,1,0,0,0,2,0,1,0,1,1,1]です.
文書「Jane likes me more than Jule loves me」の語彙ベクトルは、[2,0,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,1,1,1,1]です.
文書「He likes baskes baskell more than baseball」の語彙ベクトルは、[0,1,0,1,1,0,0,0,0,1,1,1]です.
合わせて、私達のメインドキュメントのワードマトリックスです.
［2,0,1,0,0,2,0,1,0,1］,［2,0,1,0,1,1,1,1,0,1］,［0,1,0,1,1,0］
はい、これは合理的に見えます.機械学習の経験があれば、特徴的な空間を作ってみました.現在、各文書は同じ特徴空間にあります.これは同じ次元の空間で、全体のコーパスを表してもいいです.多すぎる情報を失わないことを意味します.
標準化ベクトルは、そのL 2のノルムを1にします.
いったん同じ特徴空間でデータを得たら、いくつかの機械学習方法を適用し始めます.分類、クラスターなど.しかし、実際には、私たちもいくつかの問題に遭遇しました.単語には同じ情報が含まれていません.
単一の文書の中にあまりにも頻繁に出現する単語があると、それらは私たちの分析を混乱させます.各語周波数ベクトルをスケーリングして、より代表的にしたいです.言い換えれば、ベクトル標準化が必要です.
私たちは本当にこの方面に関する数学の知識を討論する時間があまりないです.今はただこのような事実を受け入れます.各ベクトルのL 2ノルムが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 '
A 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]]

行単位で計算したL 2のノルムは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,baskeetball,Jule,baseball,likes,loves,Jane,Linda,He,than,more]です.
反文書ワードベクトルは[1.6096438,1.36294,1.6096438,1.36294,1.60438,1.60438,1.36294,1.36294,1.3686 4,1.3694,1.791759,1.791759]である.
現在、語彙の中のすべての語について、私達は彼らのコーパス全体における相対周波数を説明するための通常の意味での情報値を持っています.振り返ってみると、この情報値は「逆」です.つまり、情報の値が小さいほど、コーパスに頻繁に出てきます.
私たちはもうすぐ欲しい結果を得ます.TF-IDFの重み付き語ベクトルを得るためには、簡単な計算をしなければなりません.
もう一歩下がって考えましょう.線形代数を思い出してください.もしAxBのベクトルに別のAxBのベクトルをかけると、AxAの大きさのベクトル、またはスカラが得られます.私たちはそうはしません.私たちが欲しいのは同じ次元(1 xワードの数)を持つワードベクトルです.ベクトルの各要素はすでに自分のid f重みで重み付けされています.私たちはどのように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ベクトルです.これは、逆ドキュメントの周波数行列に各周波数ベクトルを乗算することができます.次に、文書に頻繁に出てくる単語も考慮して、文書ごとのベクトルを標準化し、L 2ノルムを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.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/Tfidf Transformerから得られた値は、私たちが手動で計算した値とは異なります.これは、scikit-learnがTfidfの改良バージョンを使ってゼロのエラーを処理しているからです.ここではより突っ込んだ議論がある. 

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]]

実際には、すべてのステップを関数で行うことができます. 

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]]

そして、この語彙を利用して、新しい観測文書を空間的に処理することができます. 

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_で注意してくださいテルム.freqmatixには「watch」という単語がありません.これは私達が訓練に使う文書はmydoclistの中の文書で、この語はそのコーパスの語彙の中で現れないからです.つまり、私たちの語彙辞典の外にあります.
Amazonに戻るコメントテキスト
練習します
今は勉強したものを使ってみます.TfidfVectorizerを利用して、Amazonのコメントテキストの文字列リストでTF-IDFの重み付き文書のワードモーメントを作成する試みができます. 

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!!!