kerasのTokenizerで文書をtfidfベクトル化したときの計算式について

前回で終わりにしようと思っていたのですが今回もtfidfの記事です。
あまり使う機会はないのですが、kerasのテキストの前処理機能である、
keras.preprocessing.text.Tokenizer にも実はコーパスをtfidf化する機能が実装されています。

ドキュメントを読んでもtfidf機能があること自体が書いてありません。(したがって、実装されているtfidfの定義も書いてありません。)
参考: テキストの前処理 – Keras Documentation
そして、実際に動かしてみると、一般的な定義とは違う定義で動いているようなのでどのような計算式なのか調べました。

とりあえずいつもの例文で動かしてみます。
動かし方は、インスタンスを作り、fit_on_textsでコーパスを学習した後、
texts_to_matrixで変換するときに、引数でmode="tfidf"するだけです。

やってみます。


import pandas as pd
from tensorflow.keras.preprocessing.text import Tokenizer

# 表示桁数を小数点以下3位までにする
pd.options.display.precision = 3

# データを準備
corpus = [
    'This is the first document.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?',
]

keras_tokenizer = Tokenizer()
keras_tokenizer.fit_on_texts(corpus)

# 学習した単語のリストを作成(インデック0はpaddingした単語に予約されている)
word_list = [
        keras_tokenizer.index_word.get(i, "")
        for i in range(len(keras_tokenizer.index_word)+1)
    ]

df = pd.DataFrame(
        keras_tokenizer.texts_to_matrix(corpus, mode="tfidf"),
        columns=word_list
    )
print(df)
"""
      this     is    the  document  first  second    and  third    one
0    0.0  0.588  0.588  0.588     0.693  0.847   0.000  0.000  0.000  0.000
1    0.0  0.588  0.588  0.588     1.174  0.000   1.099  0.000  0.000  0.000
2    0.0  0.588  0.588  0.588     0.000  0.000   0.000  1.099  1.099  1.099
3    0.0  0.588  0.588  0.588     0.693  0.847   0.000  0.000  0.000  0.000
"""

出現する文書数とidfの対応は以下のようになっていそうです。
出現回数1回 ・・・ idf 1.099
出現回数2回 ・・・ idf 0.847
出現回数3回 ・・・ idf 0.693
出現回数4回 ・・・ idf 0.588

このようになる数式を探してみたところ、
$$
\text{idf}_{t} = \log{\left(1+\frac{\text{総文書数}}{1+\text{単語tを含む文書数}}\right)}
$$
が当てはまるようです。

scikit-learnのデフォルトの定義である、
$$
\text{idf}_{t} = \log{\left(\frac{1+\text{総文書数}}{1+\text{単語tを含む文書数}}\right)}+1
$$
と似てるけど微妙に違いますね。

検算します。


for n in range(1, 5):
    print(np.log(1+4/(n+1)))

"""
1.0986122886681098
0.8472978603872034
0.6931471805599453
0.5877866649021191
"""

さて、idfがわかったので次はtdです。
tdに着目しやすくするために、単語1種類だけにして、出現回数だけ変えたコーパスで実験します。


corpus_2 = [
    "document",
    "document document",
    "document document document",
    "document document document document",
]

df = pd.DataFrame(
        keras_tokenizer.texts_to_matrix(corpus_2, mode="tfidf"),
        columns=word_list
    )
print(df)
"""
     this   is  the  document  first  second  and  third  one
0    0.0   0.0  0.0  0.0     0.693    0.0     0.0  0.0    0.0  0.0
1    0.0   0.0  0.0  0.0     1.174    0.0     0.0  0.0    0.0  0.0
2    0.0   0.0  0.0  0.0     1.455    0.0     0.0  0.0    0.0  0.0
3    0.0   0.0  0.0  0.0     1.654    0.0     0.0  0.0    0.0  0.0
"""

ifidfの値が、出現回数1回の場合(=idf)の何倍になっているかみます。


print(df["document"]/df["document"].iloc[0])
"""
0    1.000
1    1.693
2    2.099
3    2.386
Name: document, dtype: float64
"""

どうやら、
$$
\text{tf}_{t,d} = 1+\log{\text{文書d中の単語tの出現回数}}
$$
のようです。

検算がこちら。


for n in range(1, 5):
    print(1+np.log(n))

"""
1.0
1.6931471805599454
2.09861228866811
2.386294361119891
"""

これで、実験的にkerasにおけるtfidfの定義がわかりました。

あとはドキュメントと突き合わせて確認したかったのですが、冒頭に書いた通りドキュメントには記載がありません。
と言うことで、ソースコードを直接みてみます。

どうやらこの部分が該当するようです。
参考: keras-preprocessing/text.py at master · keras-team/keras-preprocessing · GitHub


                elif mode == 'tfidf':
                    # Use weighting scheme 2 in
                    # https://en.wikipedia.org/wiki/Tf%E2%80%93idf
                    tf = 1 + np.log(c)
                    idf = np.log(1 + self.document_count /
                                 (1 + self.index_docs.get(j, 0)))
                    x[i][j] = tf * idf

ここまで実験的に導いてきた結論と一致しますね。
ハードコーディングされているのでscikit-learnのような細かなオプションはなさそうです。

TfidfVectorizerのtfについて

前回の記事が、TfidfVectorizerのidfにフォーカスしたので、今回はtfの方を取り上げます。

以前の記事で書いた通り、一般的なtdの定義(Wikipedia日本語版の定義)では、tfはその単語の文書中の出現頻度です。
$$
\text{tf}_{t,d} = \frac{\text{文書d中の単語tの出現回数}}{\text{文書dの全ての単語の出現回数の和}}
$$
しかし、TfidfVectorizerにおいては、単純に出現回数が採用されています。
$$
\text{tf}_{t,d} = \text{文書d中の単語tの出現回数}
$$

これは、TfidfVectorizerでは通常の設定(norm=’l2′)では文書ベクトルは最後に長さ1になるように正規化するので、
tfを定数倍しても結果が変わらず、無駄な操作になるからだと考えられます。

とりあえず、norm=Falseを指定して、正規化せずにtfがただの出現回数になっていることを見ていきましょう。
サンプルのコーパスで学習して、idfとtfidfを出してみました。
出現回数が1回の単語はidf=tfidfとなり、2回の単語は、idf*2=tdidfとなっているのがみて取れます。


# %%pycodestyle
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
# 表示桁数を小数点以下3位までにする
pd.options.display.precision = 3

# データを準備しておく
corpus = [
    'This is the first document.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?',
]

tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm=False,
)
tfidf_model.fit(corpus)

tfidf = tfidf_model.transform(corpus)

# モデルから抽出した idfの値
for t, idf in zip(tfidf_model.get_feature_names(), tfidf_model.idf_):
    print(t, idf.round(3))
"""
and 1.916
document 1.223
first 1.511
is 1.0
one 1.916
second 1.916
the 1.0
third 1.916
this 1.0
"""

# tfidfの値
print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first   is    one  second  the  third  this
0  0.000     1.223  1.511  1.0  0.000   0.000  1.0  0.000   1.0
1  0.000     2.446  0.000  1.0  0.000   1.916  1.0  0.000   1.0
2  1.916     0.000  0.000  1.0  1.916   0.000  1.0  1.916   1.0
3  0.000     1.223  1.511  1.0  0.000   0.000  1.0  0.000   1.0
"""

もし本来の定義で使いたいのであれば、それ専用のオプションは用意されていないので、
各文のベクトルをそれぞれの文の単語数で割ってあげる必要があります。
あまり綺麗な書き方が思いつかなかったのですが、実装するとしたら次のようなコードになるでしょうかでしょうか。
途中のif分は元の文が空だったときに0除算を発生させないためのものです。


for i in range(len(corpus)):
    word_count = len(corpus[i].split(" "))
    if word_count > 0:
        tfidf[i] = tfidf[i] / word_count

# tfidfの値
print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first     is    one  second    the  third   this
0  0.000     0.245  0.302  0.200  0.000   0.000  0.200  0.000  0.200
1  0.000     0.408  0.000  0.167  0.000   0.319  0.167  0.000  0.167
2  0.319     0.000  0.000  0.167  0.319   0.000  0.167  0.319  0.167
3  0.000     0.245  0.302  0.200  0.000   0.000  0.200  0.000  0.200
"""

TfidfVectorizerのインスタンスを作るときに、use_id = False と指定すると、idfが1で統一されるので、tfの結果だけ確認できます。
要はCountVectorizerと似た挙動になりますね。(CountVectorizerは正規化しませんが)


tf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm=False,
    use_idf=False,
)
tf_model.fit(corpus)

tf = tf_model.transform(corpus)
print(pd.DataFrame(tf.toarray(), columns=tf_model.get_feature_names()))
"""
   and  document  first   is  one  second  the  third  this
0  0.0       1.0    1.0  1.0  0.0     0.0  1.0    0.0   1.0
1  0.0       2.0    0.0  1.0  0.0     1.0  1.0    0.0   1.0
2  1.0       0.0    0.0  1.0  1.0     0.0  1.0    1.0   1.0
3  0.0       1.0    1.0  1.0  0.0     0.0  1.0    0.0   1.0
"""

さて、tfの値ですが、全ての単語数で割る一般的な定義を実現するオプションはなくてもそれ以外の亜種のオブションはあります。
参考: sklearn.feature_extraction.text.TfidfVectorizer

わかりやすくみるために、norm=False, usr_idf=False で試していきましょう。
まず、binaryと言う引数をTrueにすると、出現回数ではなく、出現する(1)か出現しない(0)かの2値になります。


tf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm=False,
    use_idf=False,
    binary=True,
)
tf_model.fit(corpus)

tf = tf_model.transform(corpus)
print(pd.DataFrame(tf.toarray(), columns=tf_model.get_feature_names()))
"""
   and  document  first   is  one  second  the  third  this
0  0.0       1.0    1.0  1.0  0.0     0.0  1.0    0.0   1.0
1  0.0       1.0    0.0  1.0  0.0     1.0  1.0    0.0   1.0
2  1.0       0.0    0.0  1.0  1.0     0.0  1.0    1.0   1.0
3  0.0       1.0    1.0  1.0  0.0     0.0  1.0    0.0   1.0
"""

次に、 sublinear_tfという引数にTrueを渡すと、tfが、$1+\log(\text{tf})$に置き換えられます。
$1+\log(2)=1.693\dots$に注意して結果を見てください。


tf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm=False,
    use_idf=False,
    sublinear_tf=True
)
tf_model.fit(corpus)

tf = tf_model.transform(corpus)
print(pd.DataFrame(tf.toarray(), columns=tf_model.get_feature_names()))
"""
   and  document  first   is  one  second  the  third  this
0  0.0     1.000    1.0  1.0  0.0     0.0  1.0    0.0   1.0
1  0.0     1.693    0.0  1.0  0.0     1.0  1.0    0.0   1.0
2  1.0     0.000    0.0  1.0  1.0     0.0  1.0    1.0   1.0
3  0.0     1.000    1.0  1.0  0.0     0.0  1.0    0.0   1.0
"""

英語版のWikipediaにtfの亜種がいろいろ紹介されていますが、その中にもない珍しいタイプの定義です。
$\log(1+\text{tf})$ならあるのですが。
参考: tf–idf – Wikipedia (English)

一つの文章の中に同じ単語が極端に繰り返し出現した場合などに、その影響を抑えられる良い形式だと思います。

TfidfVectorizerのidfについて

この記事では、scikit-learnのTfidfVectorizerの、idf部分について掘り下げてみていきます。
以前の記事でも書いた通り、デフォルトでのidfの挙動は一般的な定義とは異なります。
参考: tf-idfの一般的な定義とscikit-learnにおけるtf-idfの定義

単語$t$についてみていくと、通常の定義は
$$
\text{idf}_{t} = \log{\frac{\text{総文書数}}{\text{単語tを含む文書数}}}
$$
であり、
TfidfVectorizer のデフォルトのオプションでは、
$$
\text{idf}_{t} = \log{\frac{1+\text{総文書数}}{1+\text{単語tを含む文書数}}}+1
$$
となっています。

まず、実際にこの数式通り動いていることを見ておきましょう。


import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer

# データを準備しておく
corpus = [
    'This is the first document.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?',
]

tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
)
tfidf_model.fit(corpus)

# モデルから抽出した idfの値
for t, idf in zip(tfidf_model.get_feature_names(), tfidf_model.idf_):
    print(t, idf)

"""
and 1.916290731874155
document 1.2231435513142097
first 1.5108256237659907
is 1.0
one 1.916290731874155
second 1.916290731874155
the 1.0
third 1.916290731874155
this 1.0
"""

# 出現回数から計算したidfの値
for i in range(1, 5):
    print(f"出現回数{i}回, idf: ", np.log((1+4)/(1+i))+1)
"""
出現回数1回, idf:  1.916290731874155
出現回数2回, idf:  1.5108256237659907
出現回数3回, idf:  1.2231435513142097
出現回数4回, idf:  1.0
"""

document は3文書に登場しているから、idfは 1.2231435513142097、firtstは2文書に登場しているから、idfは1.5108256237659907と言うふうに、
scikit-learnのドキュメント通りに計算されていることがわかりますね。

さて、scikit-learnの定義がデフォルトと異なっている理由は、次の2つがあります。
(1) コーパス中に登場しない単語で0除算が発生しないように、log中の分数の分子と分母に1を足す。
(2) コーパス中の全ての文書に登場した単語のidfが0にならないように全ての単語のidfに1を足す。

(1)の方は平滑化と呼ばれる操作です。
実はTfidfVectorizerは、学習する単語をコーパスから自動的にピックアップするのではなく、モデルの引数として渡すことができます。
次のコード例では、コーパスに登場しない、oovという単語を明示的に加えてみました。
結果、$\log((1+4)/(1+0))+1 = 2.6094379124341005$ がoovのidf値になっていることがわかります。


tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    vocabulary=['and', 'document', 'first', 'is',
                'one', 'second', 'the', 'third', 'this', "oov"],
)
tfidf_model.fit(corpus)

# モデルから抽出した idfの値
for t, idf in zip(tfidf_model.get_feature_names(), tfidf_model.idf_):
    print(t, idf)
"""
and 1.916290731874155
document 1.2231435513142097
first 1.5108256237659907
is 1.0
one 1.916290731874155
second 1.916290731874155
the 1.0
third 1.916290731874155
this 1.0
oov 2.6094379124341005
"""

この分子と分母の+1については、smooth_idfと言う引数にFalseを渡すことで使わないようにもできます。
参考: sklearn.feature_extraction.text.TfidfVectorizer

この場合、vocabulary引数で、コーパスに登場しない単語が渡されていると、0除算のワーニングが発生し、該当単語のidf値はinfになります。


tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    vocabulary=['and', 'document', 'first', 'is',
                'one', 'second', 'the', 'third', 'this', "oov"],
    smooth_idf=False,
)
tfidf_model.fit(corpus)
"""
RuntimeWarning: divide by zero encountered in true_divide
  idf = np.log(n_samples / df) + 1
"""

# モデルから抽出した idfの値
for t, idf in zip(tfidf_model.get_feature_names(), tfidf_model.idf_):
    print(t, idf)
"""
and 2.386294361119891
document 1.2876820724517808
first 1.6931471805599454
is 1.0
one 2.386294361119891
second 2.386294361119891
the 1.0
third 2.386294361119891
this 1.0
oov inf
"""

tfidfの本来の定義に近い値で使う場合は、smooth_idf=Falseを指定するべきですが、この場合は安全のため、vocabularyは指定せず、
コーパスから自動的に学習するのに任せるべきでしょう。
(僕の場合は、vocabulary引数を使うことはほとんどありません。)

次に、(2)の全てのコーパスに倒叙する単語のidfが0にならないように、全部単語のidfに1足されている部分についてです。
こちらについては、これをオフにする引数のようなものは実装されていなさそうです。

どうしてもtfidfの本来の定義で使いたいんだ、と言う場合は、かなり無理矢理な操作になりますが、
モデルが学習したidfの値(idf_プロパティに格納されている)から1を引いてしまう手があります。
(当然、サポートされている操作ではないので実行は自己責任でお願いします。)

transform する際には、idf_ の値が使われるので次のようになります。


import pandas as pd
# 表示桁数を小数点以下3位までにする
pd.options.display.precision = 3

tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm=False,
    smooth_idf=False,
)
tfidf_model.fit(corpus)
tfidf = tfidf_model.transform(corpus)

print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first   is    one  second  the  third  this
0  0.000     1.288  1.693  1.0  0.000   0.000  1.0  0.000   1.0
1  0.000     2.575  0.000  1.0  0.000   2.386  1.0  0.000   1.0
2  2.386     0.000  0.000  1.0  2.386   0.000  1.0  2.386   1.0
3  0.000     1.288  1.693  1.0  0.000   0.000  1.0  0.000   1.0
"""

# idf_ に足されている1を引く 
tfidf_model.idf_ -= 1
tfidf = tfidf_model.transform(corpus)

print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first   is    one  second  the  third  this
0  0.000     0.288  0.693  0.0  0.000   0.000  0.0  0.000   0.0
1  0.000     0.575  0.000  0.0  0.000   1.386  0.0  0.000   0.0
2  1.386     0.000  0.000  0.0  1.386   0.000  0.0  1.386   0.0
3  0.000     0.288  0.693  0.0  0.000   0.000  0.0  0.000   0.0
"""

コーパスの全ての文書に含まれていた、 is, the, this の idf値とtfidf値が0になっていることが確認できます。
また、他の単語についても、出現回数分値が落ちているのがみて取れます。

文書をTfidfVectorizerでベクトル化したときの正規化について

scikit-learnのtfidfについての記事の2本目です。
今回は結果のベクトルの正規化について紹介していきます。
前の記事でも書きましたが、TfidfVectorizerはデフォルトでは結果のベクトルを長さが1になるように正規化します。
参考: tf-idfの一般的な定義とscikit-learnにおけるtf-idfの定義

ドキュメントのsklearn.feature_extraction.text.TfidfVectorizerのページの norm の説明にある通りです。

一応実験しておきます。サンプルの文章はUser Guideのページから拝借しました。


import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer

# 表示桁数を小数点以下3位までにする
pd.options.display.precision = 3

corpus = [
    'This is the first document.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?',
]

tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm='l2',  # デフォルト
)
# コーパスを学習
tfidf = tfidf_model.fit_transform(corpus)

print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first     is    one  second    the  third   this
0  0.000     0.470   0.58  0.384  0.000   0.000  0.384  0.000  0.384
1  0.000     0.688   0.00  0.281  0.000   0.539  0.281  0.000  0.281
2  0.512     0.000   0.00  0.267  0.512   0.000  0.267  0.512  0.267
3  0.000     0.470   0.58  0.384  0.000   0.000  0.384  0.000  0.384
"""

# ベクトルの長さが1であることの確認
print((tfidf.toarray()**2).sum(axis=1)**0.5)
# [1. 1. 1. 1.]

さて、ドキュメントにnorm{‘l1’, ‘l2’}, default=’l2’とある通り、norm='l1'と指定することもできます。
そうすると、ベクトルの長さを1にする代わりに、各要素の絶対値の和が1になるように正規化してくれます。
これも実験しておきましょう。なお、tfidfの結果は元々各成分がプラスなので、絶対値を取る処理は省略しています。
厳密にやるのであれば和をとる前にnp.abs()にかけましょう。


tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm='l1',
)
# コーパスを学習
tfidf = tfidf_model.fit_transform(corpus)

print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first     is    one  second    the  third   this
0  0.000     0.213  0.263  0.174  0.000    0.00  0.174  0.000  0.174
1  0.000     0.332  0.000  0.136  0.000    0.26  0.136  0.000  0.136
2  0.219     0.000  0.000  0.114  0.219    0.00  0.114  0.219  0.114
3  0.000     0.213  0.263  0.174  0.000    0.00  0.174  0.000  0.174
"""

# ベクトルの要素の和が1であることを確認
print(tfidf.toarray().sum(axis=1))
# [1. 1. 1. 1.]

ドキュメントでは、normには'l1'と'l2'の値しかサポートされていなように書いてありますが、実は他にも指定できる文字があります。
と言うのもGithubのソースコード(この記事を書いている時点ではバージョンは0.24.0)では、次のように実装されているからです。
参考: 該当箇所


        if self.norm:
            X = normalize(X, norm=self.norm, copy=False)

sklearn.preprocessing.normalize が呼び出されてます。
そして、そのドキュメントをみると、'l1','l2'に加えて'max'も対応しています。
'max'は、一番絶対値が大きい要素の絶対値が1になるように、要するに全部の要素の値が-1から1の範囲に収まるように、そして絶対値が一番大きい成分の値が±1になるように正規化してくれます。
ドキュメントに無い使い方なので、ご利用される場合は自己責任でお願いしたいのですが、次のコードの通り問題なく動作します。


tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm='max',
)
# コーパスを学習
tfidf = tfidf_model.fit_transform(corpus)

print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
   and  document  first     is  one  second    the  third   this
0  0.0      0.81    1.0  0.662  0.0   0.000  0.662    0.0  0.662
1  0.0      1.00    0.0  0.409  0.0   0.783  0.409    0.0  0.409
2  1.0      0.00    0.0  0.522  1.0   0.000  0.522    1.0  0.522
3  0.0      0.81    1.0  0.662  0.0   0.000  0.662    0.0  0.662
"""

また、もう一つ、これもドキュメントには無いのですが、正規化しないようにすることも可能です。
if self.norm:
とif文で分岐していますので、ここでFalseと判定される値を入れておけば大丈夫です。
FalseやNoneを入れておけば正規化されません。
(空白文字列でも、空配列でも、0でもお好きな値を使えますが、あまりトリッキーなことをしても意味はないのでFalseで良いでしょう)


tfidf_model = TfidfVectorizer(
    token_pattern="(?u)\\b\\w+\\b",
    norm=False, 
)
# コーパスを学習
tfidf = tfidf_model.fit_transform(corpus)

print(pd.DataFrame(tfidf.toarray(), columns=tfidf_model.get_feature_names()))
"""
     and  document  first   is    one  second  the  third  this
0  0.000     1.223  1.511  1.0  0.000   0.000  1.0  0.000   1.0
1  0.000     2.446  0.000  1.0  0.000   1.916  1.0  0.000   1.0
2  1.916     0.000  0.000  1.0  1.916   0.000  1.0  1.916   1.0
3  0.000     1.223  1.511  1.0  0.000   0.000  1.0  0.000   1.0
"""

次の記事からtfとidfの定義に関するオプションをいじって挙動を見ていくのですが、
その際は違いを見やすくするために正規化は行わないで試していきます。

tf-idfの一般的な定義とscikit-learnにおけるtf-idfの定義

テキストをベクトル化するときに用いる基本的な方法の一つであるtf-idfについてこれから数回の更新でまとめていこうと思います。
最初にこの記事では一般的な定義と、scikit-learn(TfidfVectorizer)で引数を特に指定しなかった場合に実行されるデフォルトの定義について紹介し、
今後の記事でそのバリエーションとして、オプションを変えるとどのような定義で計算できるのかを紹介していく予定です。

さて、一言にtf-idfといってもその定義には非常に多くのバリエーションがあります。
英語版のWikipediaを見ていただくとそれらが紹介されています。
参考: tf–idf – Wikipedia (English)

一方で日本語版(この記事執筆時点)のWikipediaではそのうちの1個が紹介されています。
一般的にはこれを指すことが多そうなので、この記事ではこれを一般的な定義と呼びましょう。
参考: tf-idf – Wikipedia (日本語)

早速一般的な定義について紹介していきます。
文書$d$のtf-idfは、コーパス中の単語数に等しい長さのベクトルです。
そのベクトル中の単語$t$に対応する成分$\text{tfidf}_{t,d}$は次のように単語の出現頻度(Term Frequency)と、逆文書頻度(Inverse Document Frequency)の積として計算されます。
$$
\text{tfidf}_{t,d} = \text{tf}_{t,d}\cdot \text{idf}_{t}
$$
単語の出現頻度の定義は次のようになります。
$$
\text{tf}_{t,d} = \frac{\text{文書d中の単語tの出現回数}}{\text{文書dの全ての単語の出現回数の和}}
$$
そして、逆文書頻度の定義は次のようになっています。
$$
\text{idf}_{t} = \log{\frac{\text{総文書数}}{\text{単語tを含む文書数}}}
$$

ある文書に登場する単語は、その文書に多く登場するほど、tfが高まり、コーパス全体で珍しいほどidfが高まって、結果的にtfidfが高くなるようになります。

さて、ここまでが一般的なtfidfの定義の話でした。
普段、文書をtfidfでベクトル化するときは、僕はsciki-learnのTfidfVectorizerを使うことが多いです。
そのため、重要なのはTfidfVectorizerでどのように実装されているのかです。

User Guide をみると、tf, idfそれぞれ一般的なものとは違う設計になっていることがわかります。
参考: 6.2.3. Text feature extraction

まず、一番大きな特徴として、TfidfVectorizer(デフォルト設定)でベクトル化した文書はベクトルの長さが1になるように正則化されます。
これは単純に、tfidfベクトルに変換した後に、結果のベクトルをそれ自体の長さで割って返す実装になっています。

次に、tf,idfの定義がそれぞれ一般的なものと違います。
tf は、単語の出現頻度ではなく、単純に出現回数になっています。

$$
\text{tf}_{t,d} = \text{文書d中の単語tの出現回数}
$$

そして、idfについては、$\log$の中の分数の分子と分母にそれぞれ$1$を足す平滑化処理が行われており、さらに、最後に$1$が足されています。
つまり、TfidfVectorizerのidfは次の式で計算されます。
$$
\text{idf}_{t} = \log{\frac{1+\text{総文書数}}{1+\text{単語tを含む文書数}}}+1
$$

これらの3つの特徴と、オプションを変えた場合の挙動について今後の記事で紹介していきたいと思います。
– ベクトルの正規化
– tfの定義の違い
– idfの定義の違い

Random projection について

前回の記事で紹介した、Johnson–Lindenstraussの補題を理論的背景に持つ次元削減の手法として、
Random projection と呼ばれるものがあります。
参考: Random projection – Wikipedia

手法は至ってシンプルで、乱数で生成した行列を掛けるによってデータを低次元へと埋め込んでしまうようです。

補題が主張する、距離を維持できる線形写像があるぞって話と、
ランダムに生成した行列で定義される線型写像で距離が維持できるぞと言う話は、
かなり論理にギャップがあるように感じ、その間のロジックをまだ正確には追えていないのですが、
scikit-learnに実装があるのでまずは試してみることにしました。

2000次元のデータを1000件用意し、Gaussian Random Projection という要するに正規分布で生成した行列で低次元にうつす手法を使い、
距離が保たれていることを確認します。

まずはデータの生成です。


import numpy as np

X = np.random.randn(1000, 2000)*10
print(X.shape)
# (1000, 2000)

続いて、Gaussian Random Projection のモデルのインスタンスを生成して、学習、変換します。
ハイパーパラメーター$\varepsilon$は$0.5$としました。
ドキュメントによると、次元削減後の次元は
$n\_components >= 4 \log(n\_samples) / (eps^2 / 2 – eps^3 / 3)$
となるようです。


print(4*np.log(len(X))/(eps**2/2-eps**3/3))
# 331.5722533911425

ですから、 332次元に圧縮されるかと思いきや、結果は331次元になります。
(ドキュメントのミスなのかバグなのか不明)


from sklearn.random_projection import GaussianRandomProjection


eps = 0.5
grp = GaussianRandomProjection(eps=eps)
grp.fit(X)
X_new = grp.transform(X)
print(X_new.shape)
# (1000, 331)

これで、元々2000次元だったデータを331次元に圧縮することができました。
それも、331×2000次元のランダム行列を掛けただけという、超単純な方法でです。

ちなみにその行列自体は grp.components_で取得できます。


print(grp.components_.shape)
# (331, 2000)
print(grp.components_.mean())
# -7.730060662586934e-05
print(grp.components_.var())
# 0.0030132642015398016

要素の平均はほぼ$0$であり、分散は$1/331=0.0030211…$に近い値になっており、ドキュメント通りであることが確認できます。

さて、最後に距離がある程度保存できていることを確認しておきましょう。
元のデータ X と、変換後のデータX_new それぞれについて距離行列を算出します。
そして、比率(変化率)を算出しその最小最大を見てみましょう。


X_pdist = pdist(X)
X_new_pdist = pdist(X_new)

print((X_new_pdist/X_pdist).min(), (X_new_pdist/X_pdist).max())
# 0.8230255694414008 1.18365715425175

eps が 0.5 だったので、 0.5倍〜1.5倍の範囲に収まる想定だったのですが、それよりもずっと良い精度で距離を維持できていることがわかりました。
今回は元のデータが正規分布だったので簡単だったのかもしれませんね。

Johnson–Lindenstraussの補題

『Pythonではじめる教師なし学習 ―機械学習の可能性を広げるラベルなしデータの利用』
という本の中で、「Johnson–Lindenstraussの補題」と言うものを知ったのでその紹介です。

これは、(高次元の)ユークリッド空間内の要素をそれぞれの要素間の距離をある程度保ったまま、
別の(低次元の)ユークリッド空間へ線型写像で移せることを主張するものです。

英語版のWikipediaに主張があるので、それを日本語訳しました。
Johnson–Lindenstrauss lemma – Wikipedia

$\varepsilon$を$0 < \varepsilon < 1$とし、$X$を $\mathbb{R}^N$内の$m$点の集合とします。さらに、$n$が$n > 8\log(m)/\varepsilon^2$を満たすとします。
すると、線型写像 $f:\mathbb{R}^N \longrightarrow \mathbb{R}^n$であって、
任意の$u, v \in X$ に対して、
$$
(1-\varepsilon)\|u-v\|^2 \leq \|f(u)-f(v)\|^2 \leq (1+\varepsilon)\|u-v\|^2
$$
を満たすものが存在する。

僕の個人的な感想ですが、この補題のすごいところは$n$の条件に元の次元$N$が含まれていないことです。
$N$が非常に大きな数だった場合に、要素間の距離をそこそこ保ったままはるかに小さな次元に埋め込める可能性を秘めています。

その一方で、$N$が小さく、要素数$m$が極端に大きい場合は、次元削減としての効果はあまり得られません。

matplotlibのメモリラベルテキストの回転だけをオブジェクト指向インターフェースで行いたい

主にX軸のメモリが日付などの場合に発生するのですが、matplotlibのメモリテキストが重なって読めなくなることがあります。
それをテキストを回転させて読めるようにする方法のまとめです。

とりあえず、プロットするデータを生成しておきます。


import matplotlib.pyplot as plt
from datetime import datetime, timedelta
import numpy as np
import pandas as pd

# 日付のリスト生成
dates = [datetime(2021, 1, 1) + timedelta(days=i) for i in range(10)]
date_str_list = [d.strftime("%Y-%m-%d") for d in dates]
# ランダムウォークデータ作成
data = np.cumsum(np.random.randn(10))

他サイトなどを見ると、よく用いられているのは、
plt.xticks(rotation=角度)
です。
結果だけ見れば正直これで十分なのですが、
これでも確かに回転できますが、これは、オブジェクト指向インターフェースではなく、ここだけpyplotインターフェースになります。
個人的に、これらを混在させるのは好きではありません。


fig = plt.figure(facecolor="w")
ax = fig.add_subplot(1, 1, 1)
ax.plot(date_str_list, data)
plt.xticks(rotation=90)
plt.show()

そしてオブジェクト指向インターフェースで回転させる方法として、よく見かけるのは、
ax.set_xticklabels(xlabels, rotation=角度)
とするものです。
これでもラベルを回転できるのですが、第一引数のxlabelsが省略できず、改めて指定する必要があります。
回転だけやりたいんだというときにこの仕様は面倒です。

前置き長くなりましたが、以上の2個の方法の良いとこどりで、オブジェクト指向インターフェースで回転だけを実行する方法を調べました。
結果として以下の方法があることがわかりました。

ax.tick_params(axis="x", labelrotation=角度)
ax.xaxis.set_tick_params(rotation=角度)
引数はどちらもlabelrotation=でもrotation=でも両方対応しているようです。

それぞれコード例は以下のようになります。


fig = plt.figure(facecolor="w")
ax = fig.add_subplot(1, 1, 1)
ax.plot(date_str_list, data)
ax.tick_params(axis="x", labelrotation=90)
plt.show()

fig = plt.figure(facecolor="w")
ax = fig.add_subplot(1, 1, 1)
ax.plot(date_str_list, data)
ax.xaxis.set_tick_params(rotation=90)
plt.show()

matplotlibのdpiとfigsizeの正確な意味を調べてみた

以前、「matplotlibはdpiの数値を大きくすると画像の解像度が上がる」、みたいな非常に雑な理解で記事を書いたのですが、改めて仕様を確認したのでそのメモです。
参考: matplotlibのグラフを高解像度で保存する
前提として、「dpi」は「dots per inch」の略で1インチあたりのドット数を意味します。
正直、画面に表示される画像のサイズというのは、PCのディスプレイサイズに大きく依存するので、1インチを定義することなんてできないだろうと思って流していたのですが、
実は、 figsizeで指定する数値の単位がインチだったようです。

参考: matplotlib.figure.Figure

figsize(float, float), default: rcParams[“figure.figsize”] (default: [6.4, 4.8])
Width, height in inches.

したがって、 figsize で指定した(横幅, 縦幅) と dpi を掛け合わせると、
生成される図のピクセル数が (横幅*dpi) × (縦幅*dpi) と求まるということのようです。

デフォルトの設定(rcParamsでfigsizeとdpiは確認できる)で、figureを生成して確認してみましょう。


import matplotlib.pyplot as plt

print(plt.rcParams["figure.figsize"])
# [6.0, 4.0]
print(plt.rcParams["figure.dpi"])
# 72.0
fig = plt.figure()
# <Figure size 432x288 with 0 Axes>

ドキュメントによると figsizeのデフォルトは、[6.4, 4.8]、dpiのデフォルトは100のはずなのですが、なぜか僕の環境はそれぞれ、
[6.0, 4.0]と 72になってます。これの原因は不明ですが話の本題とズレるので置いておきます。

生成された図のサイズは、横幅が 6*72=432ピクセル、縦幅が4*72=288ピクセルと、理論通りになりました。

例えば、(滅多にそんな要件はないでしょうが)フルHDサイズのグラフ(1920×1080)が作りたかったら、
figsizeを(16, 9)、dpiを120で作成すれば良いことになります。


fig = plt.figure(figsize=(16, 9), dpi=120)
# <Figure size 1920x1080 with 0 Axes>

文字列のバイト数を取得する

Amazon Comprehend も Amazon Translate も、1度に処理できるテキストサイズの上限が文字数ではなく、バイト数で決まっています。(どちらも5000byte)
とりあえずAPIに投げてエラー処理で対応してもいいのですが、あまり無駄にAPIを叩くようなことをはしない方がいいので、
できるだけ事前にAPIに渡すテキストのサイズが上限を超えていないことを確認することが望ましいです。

そこで、Pythonの文字列の長さをバイト数で取得する方法を調べました。
結論から言うと、バイト列オブジェクトにエンコードして、その後に長さを調べると良いようです。
エンコードには、 str.encodeを使います。

以下のようにして、”走れメロス”が15バイトであることがわかりました。


title="走れメロス"
print(len(title.encode()))
# 15