Jupyterのウィジェットを使ったアノテーションツール

前回の記事で紹介したJupyter Notebookのウィジェット(ボタン)の簡単な応用事例です。
参考: さよならレッドネスセンテラスポットクリーム15g

この記事でいくつか事例を紹介しようと思いますが、まずは機械学習等でテキストデータの分類モデルをつくつる時の教師データ作成(アノテーション)のツールを作ってみようと思います。
何かしらテキストデータを受け取って、事前に定義されたいくつかのカテゴリ(ラベル)の中から1個選んで、「これはカテゴリ0だ」とか「こいつはカテゴリ3だ」みたいなのを記録してくツールですね。

とりあえず、使うデータの準備と必要なライブラリを読み込んでおきます。サンプルなのでテキストの内容自体は適当です。

import pandas as pd
import ipywidgets as widgets
from IPython.display import display
# サンプルとして適当なテキストの集合を作る
df = pd.DataFrame(
    {
        "text": [f"ラベル付されるテキストその{i:03d}" for i in range(100)],
        "label": None
    }
)
print(df.head())
"""
               text label
0  ラベル付されるテキストその000  None
1  ラベル付されるテキストその001  None
2  ラベル付されるテキストその002  None
3  ラベル付されるテキストその003  None
4  ラベル付されるテキストその004  None
"""

前回の記事ではあまり名前空間のことを考えずにいろいろ書いていましたが、各種ウィジェットがグローバルスコープにあると予期せぬ挙動につながったりもするので、今回はアノテーションのクラスを定義します。
コードはやや長いですがやっていることはシンプルで、渡されたラベルの数だけボタンを作り、データフレーム内のテキストデータを1つ表示し、ボタンが押されたらボタンに対応したlabelのidをデータフレームに書き込んで、また次のテキストを表示するというそれだけです。
そして、全データ処理し終わった時に、ボタンを非活性化する処理も入れています。

今回はサンプルデータが適当で、データ中に何番目のテキストなのか入ってますが、それとは別に i 番目のデータだって表示する機能も入れています。実務では何かしら進捗がわかる機能をつけた方が良いです。どこまで進んだかわからない長いアノテーションは心が折れます。

class annotation():
    def __init__(self, df, labels):
        self.data = df
        self.i = 0  # 何番目のデータをアノテーションしているかのカウンタ
        self.buttons = [widgets.Button(description=label) for label in labels]
        self.output = widgets.Output()
        # ボタンにvalueプロパティを持たせておく
        for j in range(len(self.buttons)):
            self.buttons[j].value = j
        # ボタンにクリック寺の処理を追加
        for button in self.buttons:
            button.on_click(self.select_label)
        # ツールの初期表示実行
        self.display_tools()
    def display_tools(self):
        # ボタンや出力領域の初期表示
        self.hbox = widgets.HBox(self.buttons)
        self.output.clear_output()
        display(self.hbox, self.output)
        with self.output:
            print(f"{self.i}番目のデータ:\n")
            print(self.data.iloc[self.i]["text"])
    def select_label(self, button):
        # ボタンを押した時の処理
        # データフレームにセットされたボタンのvalueを書き込む
        self.data.iloc[self.i]["label"] = button.value
        # 次のデータに移行
        self.i += 1
        # 次のデータを表示
        self.output.clear_output(True)
        # 全データ処理し終わったら完了
        if self.i >= len(self.data):
            with self.output:
                print("完了!")
                for button in self.buttons:
                    button.disabled = True  # ボタンを非活性化
            return
        with self.output:
            print(f"{self.i}番目のデータ:\n")
            print(self.data.iloc[self.i]["text"])

上で作ったクラスは次のように使います。

labels = ["カテゴリー0", "カテゴリー1", "カテゴリー2", "カテゴリー3"]
tool = annotation(df, labels)

こうすると次の画像のようにボタンが表示され、クリックするごとにデータフレームに値が書き込まれていきます。

適当のぽちぽちとボタンを押していくと、DataFrameに次のように値が入ります。

print(df.head())
"""
               text label
0  ラベル付されるテキストその000     1
1  ラベル付されるテキストその001     2
2  ラベル付されるテキストその002     0
3  ラベル付されるテキストその003     3
4  ラベル付されるテキストその004     0
"""

ボタンの配置をもっと整えたり、スキップボタン、戻るボタンの実装などいろいろカスタマイズは考えられますが、一旦これで最低限の役割は果たせると思います。

次にもう一つ、MeCabのユーザー辞書作成の補助ツールを作っておきます。
これは、ボタンを押したらそのボタンに紐づいたラベルが記録されるのではなく、
ドロップダウンで品詞情報を選び、さらに、原形、読み、発音を手入力で入れて、確定ボタンを押したら単語辞書作成用の配列に結果格納するというものです。

今回の記事はお試しなので、追加する単語は適当にピックアップした数個ですが本来はそのリストを作らないといけないので、こちらの記事を参考にしてください。
参考: gensimでフレーズ抽出
また、アウトプットのMeCabユーザー辞書の書式はこちらです。
参考: MeCabでユーザー辞書を作って単語を追加する

ではやってみます。今回も各種パーツを一つのクラスにまとめます。

class create_dictionaly():
    def __init__(self, new_words):
        self.data = new_words  # 辞書に追加する候補のワード
        self.i = 0  # カウンタ
        self.results = []  # 結果格納用の配列
        # 確定とスキップの2種類のボタンを用意する
        self.decision_button = widgets.Button(description="確定")
        self.decision_button.on_click(self.decision_click)
        self.skip_button = widgets.Button(description="スキップ")
        self.skip_button.on_click(self.skip_click)
        # 品詞の選択機能(サンプルコードなのでIPA辞書の品詞の一部だけ実装)
        self.pos_list = [
            "名詞,一般,*,*,*,*,*",
            "名詞,固有名詞,一般,*,*,*,*",
            "名詞,サ変接続,*,*,*,*,*",
            "名詞,ナイ形容詞語幹,*,*,*,*,*",
            "名詞,形容動詞語幹,*,*,*,*,*",
            "名詞,固有名詞,人名,一般,*,*,*",
            "名詞,固有名詞,人名,姓,*,*,*",
            "名詞,固有名詞,人名,名,*,*,*",
            "名詞,固有名詞,組織,*,*,*,*",
        ]
        self.pos_select = widgets.Dropdown(options=self.pos_list)
        # 原形, 読み, 発音を設定する項目
        self.base = widgets.Text(description="原形: ")
        self.reading = widgets.Text(description="読み: ")
        self.pronunciation = widgets.Text(description="発音: ")
        # 次の単語候補表示場所
        self.new_word = widgets.Output()
        self.display_tools()
    def display_tools(self):
        # ボタンや出力領域の初期表示
        self.text_hbox = widgets.HBox(
            [self.base, self.reading, self.pronunciation])
        self.button_hbox = widgets.HBox(
            [self.decision_button, self.skip_button])
        display(self.new_word, self.text_hbox,
                self.pos_select, self.button_hbox)
        # 最初の単語を表示しておく
        self.next_word()
    def next_word(self):
        # 次の単語の表示
        # 全データ処理し終わったら完了
        if self.i >= len(self.data):
            self.new_word.clear_output(True)
            with self.new_word:
                print("完了!")
                self.decision_button.disabled = True
                self.skip_button.disabled = True
            return
        self.word = self.data[self.i]
        self.new_word.clear_output(True)
        with self.new_word:
            print(self.word)
        self.base.value = self.word
        self.reading.value = ""
        self.pronunciation.value = ""
        self.pos_select.value = self.pos_list[0]
        self.i += 1
    def decision_click(self, button):
        # 確定ボタンクリック
        # MeCabユーザー辞書の形式のテキストを生成
        result_text = f"{self.word},,,,{self.pos_select.value},"
        result_text += f"{self.base.value},{self.reading.value},{self.pronunciation.value}"
        # 結果の一覧に格納
        self.results.append(result_text)
        # 次の単語表示
        self.next_word()
    def skip_click(self, button):
        # スキップボタンクリック
        # 次の単語表示
        self.next_word()

実行は次のコードです。

cd_tool = create_dictionaly(["スマホ", "クラウド", "ガジェット", "インターフェース", "ブログ"])

このように、単語候補が出現し、原形(一旦そのままの値で補完)と読み、発音を入力して、品詞を選んで確定を押すと辞書用のデータが記録されていく仕組みになっています。

結果は、cd_tool.result に入ってます。

print("\n".join(cd_tool.results))
"""
スマホ,,,,名詞,一般,*,*,*,*,*,スマホ,スマホ,スマホ
クラウド,,,,名詞,一般,*,*,*,*,*,クラウド,クラウド,クラウド
ガジェット,,,,名詞,一般,*,*,*,*,*,ガジェット,ガジェット,ガジェット
インターフェース,,,,名詞,一般,*,*,*,*,*,インターフェース,インターフェース,インターフェース
ブログ,,,,名詞,一般,*,*,*,*,*,ブログ,ブログ,ブログ
"""

これをテキストファイルに書き出せば、ユーザー辞書のseedデータになります。

原形/読み/発音はテキストボックスを一つにまとめて自分でカンマを打つ方が早いかもと思ったり、全体的に配置のデザインがイケて無いなとか思うところはあるのですが、この先徐々に改良していきたいと思います。

以上の二つの例で、ボタンの結果をそのまま記録していくパターン、何かしらのウィジェットでデータを入力してボタンを押して確定するパターンの二つを紹介できたので、ラベル付のタスクであれば、これらの組み合わせで大抵は対応できるのではないでしょうか。

Jupyter Notebook でボタンを使う

以前、Jupyterでインタラクティブに関数を実行する方法を紹介しました。
参考: Jupyter Notebookでインタラクティブに関数を実行する

この時は、Jupyter Widgets のinteract というのを使って、スライドバー等を動かしたら自動的に値を変更してグラフを描く関数を実行する例を取り上げました。

今回は、値を変えるとかではなく、単純にNotebook上にボタンを表示して、そのボタンを押した瞬間に何か処理を実行するような方法をまとめます。

例えば、多くのテキストの値が格納されたDataFrameを対象に、ボタンをクリックするごとに次のテキストが読めるとか、何かしらの一連の処理を都度中断して経過を観察しながら徐々に実行していくとかそういった用途を想定してます。

早速説明に入りましょう。まずボタンの作成です。
前回の時は、 ipywidgets.interact 一つでいろんなUIが作れたのですが、ボタンはその中に含まれていません。ボタンを作りたい時は、ipywidgets.widgets.Buttonを使います。
さらに、ボタンを作っただけだと表示されないので、display します。もしくは、セルの最後の行で作ったボタンインスタンスを呼び出しても表示されます。(ただ、この方法は最後の1個しか出せないので、通常はdisplayしましょう。)

import ipywidgets as widgets
from IPython.display import display
button = widgets.Button(description="ボタンです")
display(button)

もしくは、下記の通り。

button = widgets.Button(description="ボタンです")
button

これで、「ボタンです」と表示されたボタンが作成されます。
description 以外の引数はドキュメントを参照してください。スタイルを警告に変えたり等の設定ができます。
参考: Widget List — Jupyter Widgets 8.0.0rc0 documentation

さて、ボタンを作成してもまだこのボタンには何の機能も実装されていません。ドキュメントにある通り、実行したい関数(仮にfooとする)を用意して、button.on_click(foo) と登録する必要があります。ボタンを押したら出力先にボタンが押された回数を表示するメッセージを出すようにしてみましょう。

button = widgets.Button(description="ボタンです")
output = widgets.Output()  # 出力先
i = 0  # ボタンが押された回数を記録しておく
def on_button_clicked(b):
    global i
    i += 1
    output.clear_output(True)  # 前のクリック時の出力を消す
    with output:
        print(f"{i}回ボタンを押しました。")
button.on_click(on_button_clicked)  # ボタンが押されたときに実行するメソッドをセット
display(button, output)

上記のコードで、ボタンが表示され、ボタンをクックするたびに
「i回ボタンを押しました。」の文字列が更新されていきます。
outputの使い方が独特ですね。 with output: するとそのスコープ配下のprint文の出力がoutputに表示されます。詳しくはOutputに関するドキュメントをご参照ください。
参考: Output widgets: leveraging Jupyter’s display system — Jupyter Widgets 8.0.0rc0 documentation

clear_output に True を渡していますが、このTrueは次の描写対象を待って消す、という処理になります。デフォルトはFalseです。
以前の記事で紹介した、セル出力のクリアと同じですね。
参考: jupyter notebookのセルの出力をコードでクリアする

ボタンの出力をoutputに出す方法は、次のように@を使ってデコレーターとして書く方法もあります。

button = widgets.Button(description="ボタンです")
output = widgets.Output()  # 出力先
i = 0  # ボタンが押された回数を記録しておく
@output.capture()
def on_button_clicked(b):
    global i
    i += 1
    output.clear_output(True)  # 前のクリック時の出力を消す
    print(f"{i}回ボタンを押しました。")
button.on_click(on_button_clicked)  # ボタンが押されたときに実行するメソッドを記録
display(button, output)

正直どちらも慣れるまではわかりにくいです。

実は昔のバージョンのjupyterはOutputを使わないとボタンの処理でprintした文を画面に出してくれなかったという話を聞いたのですが、最近のjupyterはOutputを作ってなくてもちゃんと出力してくれます。(どのバージョンからそうなったのかは調べられていないです。)
ただ、OutputはOutputとして作っておかないと、セルの出力にボタンもボタンの処理の出力も混ぜて出してしまうと、クリアしたときにボタンも消えるという不便さがあるので、Outputは必須でなくても使った方が良いです。

一度表示したボタンを消したい場合(要は、2回押すことがないとか表示するボタンの種類が次々変わるような作業をするとかといった場合)は、button.close()でボタンを消すことができます。ドキュメントのButtonのところをどう読んでもこれについての記載がなかったので僕は結構戸惑いました。buttonに実装されているメソッド/プロパティを一通り眺めて見つけたのですが、実はドキュメントでは次のページに記載されていたようです。
参考: Simple Widget Introduction — Jupyter Widgets 8.0.0rc0 documentation

以下のコードで押すと消えるボタンが

button = widgets.Button(description="押すと消えるボタン")
def on_button_clicked(b):
    b.close()
button.on_click(on_button_clicked)
display(button)

消えなくてもいいけど押せないようにしてほしい、という場合は、button.disabled の値(通常False) にTrueを代入しましょう。(ただの代入なのでコード例省略)

さて、ボタンを複数表示して押されたボタンによって処理を変えたい、という場面は多々あると思います。ボタンの数だけ on_click に設定するメソッドを定義してそれぞれ設定しても一応動くのですがコードがカッコ悪いので嫌ですね。

Buttonに何か値を持たせて、それに応じて処理を変える、というのを考えたのですが、Button()の引数に valueに相当するものがなさそうです。さっきのページに全てのウィジェットはvalueプロパティを持っている、的なことが書いてあるのに、ボタンにはvalueがないんですよね。(AttributeError: ‘Button’ object has no attribute ‘value’ が起きます。)
引用: All of the IPython widgets share a similar naming scheme. To read the value of a widget, you can query its value property.

一応、案の一つとして、button.description でボタンに表示しているテキストを取得できます。これの値によって処理を振り分けることは可能です。

ただ、実際これを使うと不便です。画面には男性/女性と表示しつつプログラム内の値としては1/2を使いたい、みたいな場面は多々あり、毎回マッピングしないといけません。

もう一つ、buttonはvalueプロパティを持っていませんでしたが、試し見てたところ後から設定することは可能でした。これを使うと一つの関数で挙動を振り分けることもできそうです。ボタンを3個作ってどれが押されたかわかるようにしてみましょう。
(ただ押したボタン名を表示するだけだったら無理やりvalue使わなくても、descriptionでいいじゃないか、って感じの例ですみません。)

# ボタンのインスタンスを作る
button_0 = widgets.Button(description="ボタン0")
button_1 = widgets.Button(description="ボタン1")
button_2 = widgets.Button(description="ボタン2")
# valueプロパティに値を設定する
button_0.value = 0
button_1.value = 1
button_2.value = 2
output = widgets.Output()  # 出力先
def on_button_clicked(b):
    output.clear_output(True)  # 前のクリック時の出力を消す
    with output:
        print(f"{b.value}番のボタンが押されました")
button_0.on_click(on_button_clicked)
button_1.on_click(on_button_clicked)
button_2.on_click(on_button_clicked)
hbox = widgets.HBox([button_0, button_1, button_2])  # HBoxを使うと横に並べることができる
display(hbox, output)

以上のコードで、ボタンが3個表示され、押したボタンによって異なる結果がアウトプット出力されます。

単純にボタンを並べると縦に並んでしまうので、HBoxというのを使って横向きに並べました。このようなレイアウト関連のツールはこちらのページにまとまっています。
参考: Layout and Styling of Jupyter widgets — Jupyter Widgets 8.0.0rc0 documentation

想定外に記事が長くなってきたので一旦今回の更新はここまでにします。
(OutputとかHBoxとかButton以外の紹介も必要でしたし。)

本当はこのButtonを使ったアノテーションのコードとか紹介したかったので次の記事でそれを書こうと思います。

Pandas.DataFrameの表示設定を変更する

以前調べたのですがしばらく使わないうちにど忘れしてしまっていたので、改めてPandasのDataFrameの表示設定を変更する方法についてまとめていきます。

ちなみにドキュメントはこちらです。
参考: Options and settings — pandas 1.4.1 documentation

(ターミナルで動かしている時も実は事情は同じなのですが、)特にJupyter NotebookでPandasを使ってデータ分析をしている時など、頻繁にデータフレームの中身を表示して中身を確認します。その場合、デフォルトの表示設定では不便な思いをすることがよくあるので、設定の変更方法を知っておくと役に立ちます。

一番頻繁に使うのは表示行数の上限設定でしょうか。
Pandasのデフォルトでは、60行をこえるDataFrameを表示する時、中間のデータが省略されて先頭と末尾のそれぞれ数行だけが表示されます。
例えば以下のようにです。

import pandas as pd
df = pd.DataFrame(range(61), columns=["value"])
print(df)
"""
    value
0       0
1       1
2       2
3       3
4       4
..    ...
56     56
57     57
58     58
59     59
60     60
[61 rows x 1 columns]
"""

中身をもっとみたい時は、head(60), tail(60), sample(60)やその他ilocなどのスライスを使って対象行数を60行以内に抑えるか、for文で回して中身をprintするなどの対応をとることが多いですが、実はこの60行の上限はPandasが内部の値として持っているもので、これ子を書き換えることが可能です。

# pd.options.display.max_rows が表示される上限の行数
print(pd.options.display.max_rows)
# 60
# 値を代入すると設定が変わる
pd.options.display.max_rows = 100

0~61の連番を表示してみてもこの記事のスペースを圧迫するだけなので設定変更した結果表示できるようになったDataFrameの例は載せませんが、上記のコードの最後の行のようにして、max_rowsに大きめの値を入れると、もっと多くの行数を表示できるようになります。
Noneにすると上限がなくなりますが、巨大なDataFrameを表示しようとしてしまった場合にブラウザが固まることがあるなどデメリットもあるので気をつけてください。

設定の確認と値の変更は、上記のようにpd.options.display以下のプロパティを見ていくほか、get_option/ set_option というメソッドで取得/設定することも可能です。これは、この後見ていく他のオプションでも同様です。

# 先ほど設定した 100 表示される
print(pd.get_option("display.max_rows"))
# 100
# set_option で値を設定できる
pd.set_option("display.max_rows", 120)

さて、表示量の上限は行数だけでなく、列数や、1行内の文字数にも設定されています。
それぞれ、20列と80文字が上限です。そのため、それを超えるDataFrameをprintすると、列が省略されたり改行されたりします。

# 横に表示される文字数の上限は80文字
print(pd.options.display.width)
# 80
# 同時に表示される列数は20列まで
print(pd.options.display.max_columns)
# 20
# 21列あるテーブルを表示すると、 途中の列が ... で省略される
# さらに、80文字を超えたので改行された
print(pd.DataFrame([range(21)]*5))
"""
   0   1   2   3   4   5   6   7   8   9   ...  11  12  13  14  15  16  17  \
0   0   1   2   3   4   5   6   7   8   9  ...  11  12  13  14  15  16  17
1   0   1   2   3   4   5   6   7   8   9  ...  11  12  13  14  15  16  17
2   0   1   2   3   4   5   6   7   8   9  ...  11  12  13  14  15  16  17
3   0   1   2   3   4   5   6   7   8   9  ...  11  12  13  14  15  16  17
4   0   1   2   3   4   5   6   7   8   9  ...  11  12  13  14  15  16  17
   18  19  20
0  18  19  20
1  18  19  20
2  18  19  20
3  18  19  20
4  18  19  20
[5 rows x 21 columns]
"""

これも、設定を変更すると改善します。例えば、40列、160文字までOKにすると次のようになります。

pd.options.display.width = 160
pd.options.display.max_columns = 40
print(pd.DataFrame([range(21)]*5))
"""
   0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20
0   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
1   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
2   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
3   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
4   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
"""

先ほど設定を変更した文字数の上限は、行トータルの文字数です。
1つのセル内の文字数には、max_colwidth というまた別の設定があります。

# デフォルトは50文字
print(pd.options.display.max_colwidth)
# 50
# 51文字以上のテキストは ... で省略される
print(pd.DataFrame(["a"*51]))
"""
                                                   0
0  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...
"""
# 100文字に増やしてみる
pd.options.display.max_colwidth = 100
# 省略されずに表示される
print(pd.DataFrame(["a"*51]))
"""
                                                     0
0  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
"""

文字数についての表示のほか、数値については小数を何桁で四捨五入して表示するかといったことも設定可能です。実はこの設定についてはこのブログでも何度か使ったことがあります。
そのうち1記事がこちらです。
参考: 文書をTfidfVectorizerでベクトル化したときの正規化について

この記事では、 pd.options.display.precision = 3 として、小数点以下3位までにヒョ時を制限しています。

import numpy as np
# 乱数でデータ生成
df = pd.DataFrame(np.random.random(size=(3, 3)))
# デフォルトは6桁
print(pd.options.display.precision)
# 6
print(df)
"""
          0         1         2
0  0.222825  0.134517  0.054559
1  0.286993  0.400856  0.117309
2  0.960378  0.022352  0.855942
"""
# 3桁までに設定すると小数点以下3桁しか表示されない
pd.options.display.precision = 3
print(df)
"""
       0      1      2
0  0.223  0.135  0.055
1  0.287  0.401  0.117
2  0.960  0.022  0.856
"""

細かい話なのですが、この時の丸め方は通常の四捨五入ではないのでご注意ください。ほとんどの値については四捨五入と同じ挙動になるのですが、丸められる桁の値がピッタリ5の場合、その上の桁が偶数の方に丸められることがあります。言葉で書くより、実例を見ていただいた方がわかりやすいと思うのでやってみます。以下の例は明らかに不自然な挙動をしているのが伝わると思います。

pd.options.display.precision = 3
print(pd.DataFrame([1.0015, 1.0025, 1.0035, 1.0045]))
"""
       0
0  1.002
1  1.002
2  1.004
3  1.004
"""
# 桁数によっては、偶数への丸めにならないこともある。
pd.options.display.precision = 4
print(pd.DataFrame([1.00015, 1.00025, 1.00035, 1.00045]))
"""
        0
0  1.0002
1  1.0003
2  1.0004
3  1.0005
"""

通常の四捨五入をしてほしい、という場合は、displayの設定変更ではなく専用のメソッドを使って四捨五入しましょう。

さて、ここまで自分がよく使うやつを中心に挙げてきましたが、他にも設定可能な項目はたくさんあります。公式ドキュメントにまとまっているので、一度目を通されることをお勧めします。
再掲: Options and settings — pandas 1.4.1 documentation

MeCabの半角スペース、全角スペース、タブ、改行に対する挙動について

某所でMeCabは半角スペースを無視するというコメントを見かけ、ちょっと疑問に思ったので調べました。そのついでに、スペースと似たような文字(全角スペースやタブ、改行など)についても調査しています。
ちなみに、Pythonラッパーの mecab-python3==1.0.4 で動作確認していますがコマンドラインの生MeCabでも挙動は同様です。

まず前提として、単語(形態素)の途中に半角スペースが入った場合、MeCabはその半角スペースの位置で単語を区切ります。こういう意味ではMeCabは半角スペースを無視しないと言えます。

print(tagger.parse("メロスは激怒した"))
"""
メロス	名詞,一般,*,*,*,*,*
は	助詞,係助詞,*,*,*,*,は,ハ,ワ
激怒	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""
# 激怒 の激と怒の間に半角スペースを挟むと単語が割れる
print(tagger.parse("メロスは激 怒した"))
"""
メロス	名詞,一般,*,*,*,*,*
は	助詞,係助詞,*,*,*,*,は,ハ,ワ
激	名詞,サ変接続,*,*,*,*,激,ゲキ,ゲキ
怒	動詞,自立,*,*,五段・ラ行,体言接続特殊2,怒る,イカ,イカ
し	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS*,特殊・タ,基本形,た,タ,タ
EOS
"""

これだけ見ると、MeCabは半角スペースを無視しないじゃないか、という話なのですが、実はそれは僕の早とちりで、MeCabが半角スペースを無視するケースはありました。それは単語と単語の間に半角スペースがあった場合です。

今度は「激怒」の前に半角スペースを置いてみます。そして事業をもっと正確に見るために、単語の生起コストと連接コストを出力するようにします。
参考: MeCabの出力形式を変更する
%cが生起コストで、%pcが連接コストです。

# コストを表示する設定でtaggerを生成
tagger = MeCab.Tagger(f"-d {dicdir}/ipadic" +
                      r" -F %m\\t%c\\t%pC\\t%H\\n"
                     )
print(tagger.parse("メロスは激怒した"))
"""
メロス	9461	-283	名詞,一般,*,*,*,*,*
は	3865	-3845	助詞,係助詞,*,*,*,*,は,ハ,ワ
激怒	4467	238	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	5500	-7956	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""
# 激怒の前(はの後ろ)に半角スペースを挟む
print(tagger.parse("メロスは 激怒した"))
"""
メロス	9461	-283	名詞,一般,*,*,*,*,*
は	3865	-3845	助詞,係助詞,*,*,*,*,は,ハ,ワ
激怒	4467	238	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	5500	-7956	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""

結果が全く同じになりましたね。注目すべきは、はと激怒の間の連接コスト、238です。
前の単語との連接コストが計算されているのですが、空白との連接コストではなくその前の「助詞,系助詞のは」との連接コストが使われています。
この例では、半角スペースは無視された、と言えるでしょう。

ちなみに、タブ、改行(\n)は半角スペース同様に無視されます。一方で全角スペース、改行(\r\n)は無視されません。(正確には\r\nの\n部分は無視されますが、\rが記号,一般として残ります。)

# タブは無視される
print(tagger.parse("メロスは\t激怒した"))
"""
メロス	9461	-283	名詞,一般,*,*,*,*,*
は	3865	-3845	助詞,係助詞,*,*,*,*,は,ハ,ワ
激怒	4467	238	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	5500	-7956	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""
# 改行(\n)も無視される
print(tagger.parse("メロスは\n激怒した"))
"""
メロス	9461	-283	名詞,一般,*,*,*,*,*
は	3865	-3845	助詞,係助詞,*,*,*,*,は,ハ,ワ
激怒	4467	238	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	5500	-7956	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""
# 全角スペースは無視されない
print(tagger.parse("メロスは 激怒した"))
"""
メロス	9461	-283	名詞,一般,*,*,*,*,*
は	3865	-3845	助詞,係助詞,*,*,*,*,は,ハ,ワ
 	1287	-355	記号,空白,*,*,*,*, , ,
激怒	4467	341	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	5500	-7956	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""
# 改行(\r\n)も無視されない。printすると見えませんが表層形に\r だけ残ります。\nは消えて。
print(tagger.parse("メロスは\r\n激怒した"))
"""
メロス	9461	-283	名詞,一般,*,*,*,*,*
は	3865	-3845	助詞,係助詞,*,*,*,*,は,ハ,ワ
	4769	-71	記号,一般,*,*,*,*,*
激怒	4467	-272	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	5500	-7956	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""

4パターンとも激怒の前に各記号を入れましたが、無視されるものと考慮されるものに分かれました。全角スペースや\rについては形態素の一つとして扱われ、その次の単語である「激怒」の前の単語との連接コストの計算にも反映されています。

テキストデータを前処理するときに、表記揺れの対応として全角スペースを半角スペースに置き換えたり、改行コードを\r\nを\nに揃えたりといったことをよくやっていたのですが、この操作はその後の形態素解析の結果に影響を与えてしまっていたのですね。
大体その後、改行を空白スペースに置換したりするのですが、これは影響なさそうです。

この改行を無視して、その前の単語との間の連接コストが形態素解析の結果に反映されるというのは僕にとっては非常に驚きでした。(BOSを挿入してるわけではないので、言われてみればそうかという気もしますが。)

例えば、次の2つのテキスト中の「中国語を勉強します。」の形態素分析結果が違う、ということが予想できた人ってあまりいなのではないでしょうか。

text1 = """来月から留学します。
中国語を勉強します。"""
text2= """来月から留学します
中国語を勉強します"""
# 文末に。があるテキストの場合
print(tagger.parse(text1))
"""
来月	5123	-316	名詞,副詞可能,*,*,*,*,来月,ライゲツ,ライゲツ
から	4159	-4367	助詞,格助詞,一般,*,*,*,から,カラ,カラ
留学	5355	2	名詞,サ変接続,*,*,*,*,留学,リュウガク,リューガク
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
ます	5537	-9478	助動詞,*,*,*,特殊・マス,基本形,ます,マス,マス
。	215	-3050	記号,句点,*,*,*,*,。,。,。
中国語	5383	-952	名詞,一般,*,*,*,*,中国語,チュウゴクゴ,チューゴクゴ
を	4183	-4993	助詞,格助詞,一般,*,*,*,を,ヲ,ヲ
勉強	4452	-1142	名詞,サ変接続,*,*,*,*,勉強,ベンキョウ,ベンキョー
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
ます	5537	-9478	助動詞,*,*,*,特殊・マス,基本形,ます,マス,マス
。	215	-3050	記号,句点,*,*,*,*,。,。,。
EOS
"""
# 句読点が省略されたテキストの場合
print(tagger.parse(text2))
"""
来月	5123	-316	名詞,副詞可能,*,*,*,*,来月,ライゲツ,ライゲツ
から	4159	-4367	助詞,格助詞,一般,*,*,*,から,カラ,カラ
留学	5355	2	名詞,サ変接続,*,*,*,*,留学,リュウガク,リューガク
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
ます	5537	-9478	助動詞,*,*,*,特殊・マス,基本形,ます,マス,マス
中国	4757	825	名詞,固有名詞,地域,国,*,*,中国,チュウゴク,チューゴク
語	7810	-7313	名詞,接尾,一般,*,*,*,語,ゴ,ゴ
を	4183	-4541	助詞,格助詞,一般,*,*,*,を,ヲ,ヲ
勉強	4452	-1142	名詞,サ変接続,*,*,*,*,勉強,ベンキョウ,ベンキョー
し	8718	-5350	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
ます	5537	-9478	助動詞,*,*,*,特殊・マス,基本形,ます,マス,マス
"""

text1の方は、「中国語」という単語が登場しましたが、text2の方は、「中国」と「語」という2つの単語に割れましたね。
これは、改行を無視して、その前の単語である「助動詞のます」との連接が考慮された結果になります。「記号,句点の。」と「中国語」の連接コストは小さいですが、「ます」と「中国語」の連接コストは大きい(1436)ので「中国語」という形態素が採用されなかったのです。(中国と語の連接コストが非常に小さく、単語が一つ増えるデメリットがあまりなかったのも要因)

以上をまとめると、以下のようになるでしょうか。
– 全角スペースや\rは他の文字と同じように形態素(単語)として扱われる。
– 半角スペース、タブ、改行(\n)は区切り位置として使われその位置で必ず形態素は切られる。
– 半角スペース、タブ、改行(\n)はそれ自体は形態素としては扱わず結果にも表示されない。
– 半角スペース、タブ、改行(\n)は連接コストの計算時は無視される。

半角スペースも形態素結果に表示してほしいよ、という場合は、表示形式のオプションで、%Mを使うことで表示できます。半角スペースの次の単語の表層系に存在したスペースをくっつけて表示してくれるようです。ただ、正直これを使う場面がすぐには思いつきません。

# %m の代わりに %M を使うと半角スペースも表示される
tagger = MeCab.Tagger(f"-d {dicdir}/ipadic" +
                      r" -F %M\\t%H\\n"
                      )
print(tagger.parse("メロスは 激怒した"))
"""
メロス	名詞,一般,*,*,*,*,*
は	助詞,係助詞,*,*,*,*,は,ハ,ワ
 激怒	名詞,サ変接続,*,*,*,*,激怒,ゲキド,ゲキド
し	動詞,自立,*,*,サ変・スル,連用形,する,シ,シ
た	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
EOS
"""

激怒、の前にスペースが入って半角1文字分字下げされているのがわかりますね。
読みはゲキドだけなので、原型、読み、発音では無視されたままであることもわかります。

NumPyの2次元配列(行列)から三角行列を取り出す

今回もNumPyの小ネタです。特に難しい処理ではないのですが、NumPyの行列(2次元配列)から三角行列を取り出したいことがあります。
自分の場合は、距離行列とか相関行列などに対して、$x_i$と$x_j$の距離や相関と、$x_j$と$x_i$の距離や相関は等しいから一方だけでいいとかそういう状況が多いです。

まぁ、値を取り出すだけなら、2重のforループなどをちゃんと書けば済む話なのですが、前回の記事で紹介したようなちょっとしたテクニックを使いたい場合など、明示的に三角行列を作りたいことがあります。
参考: NumPyの多次元配列から値が大きいn個のインデックスを取得する

自分で実装しても特に難しくないのですが、NumPyに専用関数が用意されていたのでこの記事ではそれを紹介したいと思います。

とりあえず、適当な行列を作って自分でやってみましょう。(実は実務では要素数が数万*数万みたいな巨大行列扱うことがあり、2重for文回すのはちょっと待つので嫌だなと思うのですが、小さい行列ならこれで十分です)

対角成分も0にする、狭義の下三角行列を作る場合は以下のようになるでしょうか。

import numpy as np
# 適当にデータを生成する
np.random.seed(4)
ary = np.random.randint(10, 100, size=(5, 5))
print(ary)
"""
[[56 65 79 11 97]
 [82 60 19 68 65]
 [65 67 46 60 54]
 [48 62 13 10 65]
 [31 31 83 48 66]]
"""
# 上三角成分を0にすることで下三角行列を作る
for i in range(ary.shape[0]):
    for j in range(i, ary.shape[1]):
        ary[i, j] = 0
print(ary)
"""
[[ 0  0  0  0  0]
 [82  0  0  0  0]
 [65 67  0  0  0]
 [48 62 13  0  0]
 [31 31 83 48  0]]
"""

はい、何も難しくなくできましたね。

これを2重のfor文を使わずにやる場合、NumPyには triuとtril というそれぞれ上三角行列と下三角行列を取り出すメソッドが用意されています。
参考:
numpy.triu — NumPy v1.22 Manual
numpy.tril — NumPy v1.22 Manual

とりあえず、動かしてみましょうか。2個目にkっていうオプションの引数(デフォルトは0)を取り、これを調整することで対角成分を残すかどうか、また対角成分に限らずどの斜めラインまで成分を残すかを調整できます。

# もう一回データを生成する
np.random.seed(4)
ary = np.random.randint(10, 100, size=(5, 5))
# 上三角行列
print(np.triu(ary))
"""
[[56 65 79 11 97]
 [ 0 60 19 68 65]
 [ 0  0 46 60 54]
 [ 0  0  0 10 65]
 [ 0  0  0  0 66]]
"""
# k=1とすると、対角成分も消える。(消える行が右上に広がる)
print(np.triu(ary, k=1))
"""
[[ 0 65 79 11 97]
 [ 0  0 19 68 65]
 [ 0  0  0 60 54]
 [ 0  0  0  0 65]
 [ 0  0  0  0  0]]
"""
# k=2とすると、さらに消える(消える行が右上に広がる)
print(np.triu(ary, k=2))
"""
[[ 0  0 79 11 97]
 [ 0  0  0 68 65]
 [ 0  0  0  0 54]
 [ 0  0  0  0  0]
 [ 0  0  0  0  0]]
"""
# k=-1とすると、逆に残す範囲が左下に広がる。より小さい負の数も同様。
print(np.triu(ary, k=-1))
"""
[[56 65 79 11 97]
 [82 60 19 68 65]
 [ 0 67 46 60 54]
 [ 0  0 13 10 65]
 [ 0  0  0 48 66]]
"""
# trilは下三角行列
print(np.tril(ary))
"""
[[56  0  0  0  0]
 [82 60  0  0  0]
 [65 67 46  0  0]
 [48 62 13 10  0]
 [31 31 83 48 66]]
"""
# tril の k=1 は残す範囲が広がる。境界線が右上にスライドするという意味ではtriuと同じ。
print(np.tril(ary, k=1))
"""
[[56 65  0  0  0]
 [82 60 19  0  0]
 [65 67 46 60  0]
 [48 62 13 10 65]
 [31 31 83 48 66]]
"""
# tril で対角成分も消したい場合はk=-1
print(np.tril(ary, k=-1))
"""
[[ 0  0  0  0  0]
 [82  0  0  0  0]
 [65 67  0  0  0]
 [48 62 13  0  0]
 [31 31 83 48  0]]
"""

狭義の三角行列(要するに対角成分も0)を取り出したい時、上三角行列(triu)の時はk=1で、下三角行列(tril)の時はk=-1 ってのがちょっと厄介ですね。まぁ、境界線が上に移動するか下に移動するかと考えるのが誤解が少ないかと思います。

三角行列といえば、NumPyには、tri という 三角行列を生成するメソッドもあります。(これもkという引数を取ります。)
参考: numpy.tri — NumPy v1.22 Manual
このtriで生成した三角行列を使ってマスクすることで、三角行列を作ることも可能です。というより、triuやtril の実装をみるとそういう作りになっています。
参考: triuのソースコード(GitHub)

NumPyのwhereメソッドとか使っていい感じに実装されていいますが、ぶっちゃけ掛け算(要素積)するだけで良いでしょう。

# tri で三角成分が1の三角行列を作れる
print(np.tri(5, k=-1))
"""
[[0. 0. 0. 0. 0.]
 [1. 0. 0. 0. 0.]
 [1. 1. 0. 0. 0.]
 [1. 1. 1. 0. 0.]
 [1. 1. 1. 1. 0.]]
"""
# これを要素積すると、元の行列は下三角行列になる。
print(ary * np.tri(5, k=-1))
"""
[[ 0.  0.  0.  0.  0.]
 [82.  0.  0.  0.  0.]
 [65. 67.  0.  0.  0.]
 [48. 62. 13.  0.  0.]
 [31. 31. 83. 48.  0.]]
"""
# 上三角行列が欲しいなら転置してから掛ける
print(ary * np.tri(5, k=-1).T)
"""
[[ 0. 65. 79. 11. 97.]
 [ 0.  0. 19. 68. 65.]
 [ 0.  0.  0. 60. 54.]
 [ 0.  0.  0.  0. 65.]
 [ 0.  0.  0.  0.  0.]]
"""

さて、最後に処理時間を見ておきましょう。最初に少しぼやいていましたが、2重for文のデメリットは巨大な行列を処理する場合の処理時間です。2万行*2万行(要素数4億)の行列で見てみましょう。

データ生成。

big_ary = np.random.randint(100, size=(20000, 20000))

まず、tirlです。こちら3秒ちょっとで終わりました。

% % time
big_ary_tril = np.tril(big_ary, k=-1)
"""
CPU times: user 1.18 s, sys: 1.33 s, total: 2.5 s
Wall time: 3.25 s
"""

次にfor文を回した場合です。こちらは50秒近くかかっています。もう少しで1分超えますね。

% % time
for i in range(big_ary.shape[0]):
    for j in range(i, big_ary.shape[1]):
        big_ary[i, j] = 0
"""
CPU times: user 45.3 s, sys: 1.59 s, total: 46.8 s
Wall time: 49.5 s
"""

速度、計算効率的にはtirl/triuを使った方が良いということが確認できました。

triu/trilは実装上は全ての要素に対して残すか0埋めするかの判定をかけているのに対し、for文の方は0で埋める要素だけにアクセスしているので、計算量というか演算回数だけならfor文の方が半分以下のはずですが、for文の方が圧倒的に遅いのが不思議です。NumPyのもっとコアな部分で並列処理がかなりしっかりと作り込まれているのでしょう。

ベビードール Tバックショーツ セット レディース 2点セット セクシーランジェリー 深Vネック レ

NumPyの多次元配列(といってもここで扱うのは2次元の行列ですが)の要素の中から、値が大きい順に数個取り出して、そのインデックスが欲しいことがありました。
これが多次元ではなく、1次元の配列だったら、argsort使えば一発です。
参考: numpyのarrayを並び替えた結果をインデックスで取得する

多次元になるとargsordだけではうまく動きません。
まともに実装すると、やや手間だったのですが、unravel_index というメソッドを使うとうまく書けたので紹介します。

とりあえず参考に使うデータを用意しておきます。実際はもっと巨大なデータでやったのですが、この記事では結果を確認しやすいように 5*5の行列の25個の要素から上位5要素のインデックスを取得することを目指します。
まずデータを作っておきます。

import numpy as np
np.random.seed(4)
ary = np.random.randint(10, 100, size=(5, 5))
print(ary)
"""
[[56 65 79 11 97]
 [82 60 19 68 65]
 [65 67 46 60 54]
 [48 62 13 10 65]
 [31 31 83 48 66]]
"""

このデータから値が大きい順に5このインデックスを取得することを目指します。もし、欲しいのがインデックスではなく値であればこれは簡単です。ravel() か flatten()、reshape()あたりで1次元に変形してソートするだけです。こんな感じに。

np.sort(ary.ravel())[-5:]
# array([68, 79, 82, 83, 97])

今回の用件では欲しいのは、これらの値が入ってたインデックスです。つまり、
[[1, 3], [0, 2], [1, 0], [4, 2], [0, 4]] を求めたいのです。

単純に argsortすると、行ごとにその行内でソートして結果を返してくれます。
また、axis引数にNoneを指定すると行列全体でソートしてくれるのですが結果が、ravel等で1次元に直した後にargsortしたようなイメージで帰ってきます。

print(np.argsort(ary))
"""
[[3 0 1 2 4]
 [2 1 4 3 0]
 [2 4 3 0 1]
 [3 2 0 1 4]
 [0 1 3 4 2]]
"""
print(np.argsort(ary, axis=None))
"""
array([18,  3, 17,  7, 21, 20, 12, 15, 23, 14,  0, 13,  6, 16,  9, 19,  1,
       10, 24, 11,  8,  2,  5, 22,  4])
"""

axis=Noneの方の結果(小さい順なので最後の5つ、[8, 2, 5, 22, 4]が求める5つの数のインデックス)を元の(5*5)の配列に読み替えると欲しい結果が得られることになります。
1次元でインデックスが8ってことは9番目の要素で、5*5行列の9個目の要素は[1, 4]だ、同様に2は[0, 2]、5は[1, 0] と読み替えていくわけですね。割り算と余りを使って実装できそうです。やってみると次のようになります。

for i in np.argsort(ary, axis=None)[-5:]:
    print([i//5, i%5])
"""
[1, 3]
[0, 2]
[1, 0]
[4, 2]
[0, 4]
"""

上記の変換をあらかじめ用意されたメソッドで行うのが、この記事冒頭で名前を出した unravel_index です。
ドキュメント: numpy.unravel_index — NumPy v1.22 Manual

動かしてみます。

# 以下の引数を渡していることに注意して見てください。
# np.argsort(ary, axis=None)[-5:] = [ 8  2  5 22  4]
# ary.shape = (5, 5)
print(np.unravel_index(np.argsort(ary, axis=None)[-5:], ary.shape))
# (array([1, 0, 1, 4, 0]), array([3, 2, 0, 2, 4]))

かなり近いところまで来ましたね。最終的な結果が二つのarrayからなるタプルになっていますが、それぞれから1個ずつ値を取り出してペアにすれば欲しい結果になっています。

人間が見るには微妙に扱いにくい形に見えるのですが、次のように値を取り出すのに使えます。

index_list = np.unravel_index(np.argsort(ary, axis=None)[-5:], ary.shape)
print(ary[index_list])
# [68 79 82 83 97]

今回はインデックスの方が欲しかったので、これを人が見ても見やすい形にするため、vstackして、さらに転置(.T)しても良いでしょう。

print(np.vstack(index_list).T)
"""
[[1 3]
 [0 2]
 [1 0]
 [4 2]
 [0 4]]
"""
# 以下のように書けば1行で可能。
print(np.vstack(np.unravel_index(np.argsort(ary, axis=None)[-5:], ary.shape)).T)

以上で欲しかった結果が得られました。unravel_indexがちょっと馴染みが薄かったのでまだ慣れないのですが、個人的にはこれが一番いいのではないかと思います。

大き方から順ではなく、小さい方からとたい、って時は、argsortに対するスライスの部分を少し変えるだけで対応できます。([-5:]ではなく[:5]に。)

ちなみに、argsort/ unravel_index/ vstack など少々マイナーなメソッドをいくつも使うのが嫌な場合は次のような方法もあります。多次元の配列を、インデックスと値のペアのようなデータ構造に変換してソートするやり方です。

# インデックスと値を組にしたデータにする。
lil_ary = [(i, j, ary[i, j]) for i in range(ary.shape[0]) for j in range(ary.shape[1])]
print(lil_ary[:5])  # 中身を一部確認
# [(0, 0, 56), (0, 1, 65), (0, 2, 79), (0, 3, 11), (0, 4, 97)]
# 3番目の要素(indexは2)をキーにしてソート
lil_ary.sort(key=lambda x: x[2])
# 最後の5項目を取る
print(lil_ary[-5:])
# [(1, 3, 68), (0, 2, 79), (1, 0, 82), (4, 2, 83), (0, 4, 97)]

あとはこれの、タプルのそれぞれの先頭2要素を取り出せば欲しかったインデックスです。
何をやっているのかはこちらの方がわかりやすいかも、と思っていますがこのやり方はメモリ効率などの観点でデメリットもあるので巨大なデータへの適用はお勧めしません。

gensim の phrases で用意されているスコア関数について

前回の記事から引き続き、gensim の phrases モデルの話です。
参考(前回の記事): gensimでフレーズ抽出
参考(公式ドキュメント): models.phrases – Phrase (collocation) detection — gensim
参考(Githubのソース): gensim/phrases.py at master · RaRe-Technologies/gensim · GitHub

前回の記事でこのモデルの使い方を紹介しました。このモデルは連続して出現した単語のペアに対してスコアを計算して、そのスコアが指定した閾値を超えたらその単語のペアをフレーズとして抽出しているのでした。この時に使われているスコアの計算式を具体的に見ていこうという記事です。このスコアの計算式は用意されているものが2種類と、後自分で作ったオリジナルの関数もつかえますが一旦用意されている2種類を見ていきます。

データは前回の記事と同じものを使います。形態素解析(分かち書き)まで終わったデータが、データフレームに格納されているものとします。

計算に使われる引数について

当然計算式はそれぞれ違うのですが、関数に渡される引数は共通です。(とはいえ、Pythonの実装上引数として渡されるだけで、両方が全部使っているわけではありません。)
それらの値について最初に見ておきましょう。
ドキュメント、もしくはソースコードを見ると以下のように6個の値を受け取っていますね。

def npmi_scorer(worda_count, wordb_count, bigram_count, len_vocab, min_count, corpus_word_count):
# 実装は略
def original_scorer(worda_count, wordb_count, bigram_count, len_vocab, min_count, corpus_word_count):
# 実装は略

説明と動作確認のため、適当にモデルを学習させておきます。

from gensim.models.phrases import Phrases
phrase_model = Phrases(
    sentences=df["tokens"],  # 学習するデータ
    min_count=20,  # 最低何回出現した単語および単語ペアを対象とするか。デフォルト5
    scoring='default',  # スコアリングに用いる関数。 "default", "npmi", もしくは自作の関数を指定。
    threshold=1000,  # スコアが何点を超えたらフレーズとみなすか。でフォルト10.0
)

それでは、順番に引数を見ていきます。

まず、 worda_count / wordb_count はそれぞれ1つ目、2つ目の単語が出てきた回数です。
モデルでいうと、 phrase_model.vocab から取得されます。それぞれの単語が出てきたテキスト数ではなく、出てきた回数であるところが注意が必要です。(1つのテキストに5回出てきたらそれで5と数えられます。)

bigram_count は 1つ目の単語と2つ目の単語が連続して登場した回数です。これも同様に連続して登場したテキスト数ではなく回数です。

len_vocab は vocab 辞書の要素数です。コードでいうとlen(phrase_model.vocab)。ユニグラムとバイグラムを両方数えた語彙数になります。前回の記事でいうと、{“キン”: 81, “ドル”: 111, “キン_ドル”: 81} となっていたらこれで3と数えます。 モデルを学習する時、 min_count で一定回数以下しか出現しなかった単語を足切りしますが、このvocab 作成時は足切りが行われません。1回でも出現したユニグラム、バイグラムが全部数えられるので注意が必要です。

min_count はシンプルに、モデル学習時に指定したバイグラムの最低出現回数です。ちなみに、min_count と全く同じ回数だけ出現した単語は対象に含まれるようですが、スコア関数がデフォルトのoriginal_scoreの場合は定義からスコアが絶対に0になるので結果的に抽出されません。

corpus_word_count は学習したテキストの単語の数を単純に足したものです。次のコードの二つの値が一致することからわかります。

print(phrase_model.corpus_word_count)
# 592490
print(df.tokens.apply(len).sum())
# 592490

さて、スコア計算に使われる6個の値が確認できたところで、順番にスコアの定義を見ていきましょう。

オリジナルスコア

scoring=’default’ と指定された時に採用されるのが、original_scorer です。
以下の論文で提唱されたものをベースとしています。
参考: Distributed Representations of Words and Phrases and their Compositionality

ドキュメントによると次の式で定義されています。
$$
\frac{(\text{bigram_count}-\text{min_count})\times \text{len_vocab}}{\text{worda_count}\times\text{wordb_count}}
$$

シンプルでわかりやすいですね。バイグラムが最小出現回数に比べてたくさん出現するほどスコアが伸びるようになっています。一方でユニグラムでの出現回数が増えるとスコアは下がります。出現した時は高確率で連続して出現するという場合に高くなるスコアです。
len_vobabを掛けているのはイマイチ意図が読めないですね。両単語が全く関係ないテキストをコーパスに追加していくとスコアが伸びていってしまいます。
また、min_countがスコアの計算に使われているので、min_countを変えると足切りラインだけでなくスコアも変わる点も個人的にはちょっとイマイチかなと思いました。

ソースコードも一応見ましたが、定義そのままですね。

def original_scorer(worda_count, wordb_count, bigram_count, len_vocab, min_count, corpus_word_count):
    denom = worda_count * wordb_count
    if denom == 0:
        return NEGATIVE_INFINITY
    return (bigram_count - min_count) / float(denom) * len_vocab

もう何回も使っている”キン_ドル”を例に、モデルが計算した結果と、定義通りの計算結果が一致することを見ておきましょう。

# モデルが実際に計算したスコア
print(phrase_model.export_phrases()["キン_ドル"])
# 1062.89667445223
# 計算に使われた値たち
print(len(phrase_model.vocab))
# 156664
print(phrase_model.vocab["キン"])
# 81
print(phrase_model.vocab["ドル"])
# 111
print(phrase_model.vocab["キン_ドル"])
# 81
print(phrase_model.min_count)
# 20
# 定義に沿った計算結果
print((81-20)*156664/(81*111))
# 1062.89667445223

 以上で、デフォルトのオリジナルスコアが確認できました。次はNPMIスコアです。

NPMIスコア

scoring=’npmi’ と指定すると使われるのがnpmi_scorerです。
以下の論文で提唱されたものをもとにしています。
参考: Normalized (Pointwise) Mutual Information in Colocation Extraction

ドキュメントによると定義は次の式です。
$$
\frac{\ln{(prob(\text{worda}, \text{wordb}) / (prob(\text{worda})\times prob(\text{wordb}))))}}{-\ln{(prob(\text{worda}, \text{wordb}))}}
$$

ここで、
$$
prob(\text{word}) = \frac{\text{word_count}}{\text{corpus_word_count}}
$$
だそうです。
僕は、だいたい想像つくけど、$prob(\text{worda}, \text{wordb})$の定義も書けや、と思いました。
ソースを読んだ限りでは、以下の定義のようです。
$$
prob(\text{worda}, \text{wordb}) = \frac{\text{bigram_count}}{\text{corpus_word_count}}
$$

分子と分母の両方にバイグラムの出現割合が登場するので直感的には少しわかりにくいですね。分母にマイナスがついているのも理解をややこしくしています。

注意点として、このスコアは-1〜1の範囲(もしくは-inf)で値を返します。モデルの閾値はデフォルト10ですが、これは明らかにoriginal_scorerを使うことを想定しているので、これを使う時は閾値も合わせて調整しなければなりません。

一応ソースコードも見ておきましょう。

def npmi_scorer(worda_count, wordb_count, bigram_count, len_vocab, min_count, corpus_word_count):
    if bigram_count >= min_count:
        corpus_word_count = float(corpus_word_count)
        pa = worda_count / corpus_word_count
        pb = wordb_count / corpus_word_count
        pab = bigram_count / corpus_word_count
        try:
            return log(pab / (pa * pb)) / -log(pab)
        except ValueError:  # some of the counts were zero => never a phrase
            return NEGATIVE_INFINITY
    else:
        # Return -infinity to make sure that no phrases will be created
        # from bigrams less frequent than min_count.
        return NEGATIVE_INFINITY

これも一応、モデルの計算結果と自分で計算した値を突き合わせておきます。

import numpy as np  # logを使うためにimport
# npmi をtukausetteidemoderuwogakusyuu
phrase_model = Phrases(
    sentences=df["tokens"],  # 学習するデータ
    min_count=20,  # 最低何回出現した単語および単語ペアを対象とするか。デフォルト5
    scoring='npmi',  # スコアリングに用いる関数。 "default", "npmi", もしくは自作の関数を指定。
    threshold=0.8,  # スコアが何点を超えたらフレーズとみなすか。でフォルト10.0
)
# モデルが計算したスコア
print(phrase_model.export_phrases()["キン_ドル"])
# 0.9645882456014411
# 計算に使われた値たち
print(phrase_model.vocab["キン"])
# 81
print(phrase_model.vocab["ドル"])
# 111
print(phrase_model.vocab["キン_ドル"])
# 81
print(phrase_model.corpus_word_count)
# 592490
# 定義に沿って計算
pa = 81/592490
pb = 111/592490
pab = 81/592490
print(np.log(pab / (pa * pb)) / -np.log(pab))
# 0.9645882456014411

想定通りの結果になりましたね。

これで、gensimのphrasesモデルでフレーズ抽出に使われているスコアの計算式が理解できました。

どういうスコアなのかが分かればそれをもとに閾値を適切に決めれるのでは、という期待があったのですが、正直、この計算式だからこうだみたいな目安はまだあまり見えてきませんでした。

一回 min_countと閾値を両方ともものすごく低い値にして学習し、スコアの分布を見たり、だいたい何単語くらい抽出したいのかといったことをかがえて何パターンか試して使っていくのが良いのかなと思います。

gensimでフレーズ抽出

以前このブログで、テキストデータ中のよく連続する単語を検出するコードを紹介しました。
参考: Pythonを使ってよく連続する文字列を検索する

これは単純にある単語の前か後に出現しやすい単語を探すだけのコードだったのですが、実は同じような目的のモデルでもう少しスマートなロジックで実装されたものがgensimにあることがわかったのでそれを紹介します。

なお、今回の記事は以下のバージョンのgensimで動かすことを前提とします。

$ pip freeze | grep gensim
gensim==4.1.2

僕は複数開発環境を持っているのですが、gensim==3.8.0 など、3系の環境と、今使っている4系の環境で細かい挙動が色々異なり少し手こずりました。(会社のMacで動いたコードが私物のMacで動きませんでした。)
今回紹介するモデルに限らず、githubのgensimのリポジトリのWikiにマイグレーションガイドが出てるので、gensimを頻繁に使われる方は一読をお勧めします。
参考: Migrating from Gensim 3.x to 4 · RaRe-Technologies/gensim Wiki · GitHub

前置きが長くなりました。今回紹介するのは、gensimのphrasesです。
ドキュメント: models.phrases – Phrase (collocation) detection — gensim

要は、分かち書き済みの文章から学習して、頻繁に連続する2単語をフレーズとして抽出してくれるモデルです。
「頻繁に連続する」の基準として、僕が以前の記事で紹介したような単純な割合ではなく、論文で提唱されている手法(を元にした関数)を使ってスコアリングし、そのスコアが閾値を超えたらフレーズとして判定するという手法が採られています。(デフォルトで使われるのは1個目の方です。2個目はオプションで使うことができます。)
参考:
ヨーロッパとアメリカのクロスボーダーの女性のプリントブラウスホットレターラウンドネック半袖Tシャツ女性
– Normalized (Pointwise) Mutual Information in Collocation Extraction” by Gerlof Bouma

今回の記事は使い方をメインで扱いたいので、このスコアリング関数については次の記事で紹介しましょうかね。

早速使っていきましょう。まず学習させるデータの準備です。以前用意したライブドアニュースコーパスを使います。今回はお試しで、そんなたくさんのデータ量いらないので、「ITライフハック」のデータだけ使います。
参考: livedoorニュースコーパスのファイルをデータフレームにまとめる

上記の記事で作ったCSVデータの読み込みと、分かち書きまでやっておきます。

import subprocess
import pandas as pd
import MeCab
# データの読み込み
df = pd.read_csv("./livedoor_news_corpus.csv")
# 今回は"it-life-hack" だけ使う
df = df[df.category=="it-life-hack"].reset_index(drop=True)
# ユニコード正規化とアルファベットの小文字統一
df.text = df.text.str.normalize("NFKC").str.lower()
# 辞書のパス取得
dicdir = subprocess.run(["mecab-config", "--dicdir"], capture_output=True, text=True).stdout.strip()
# 今回は品詞情報も原型変換も行わないので -Owakati で実行する。
tagger = MeCab.Tagger(f"-Owakati -d {dicdir}/ipadic")
# 分かち書きした結果を配列で返す関数
def mecab_tokenizer(text):
    return tagger.parse(text).split()
# 動作確認
print(mecab_tokenizer("すもももももももものうち"))
# ['すもも', 'も', 'もも', 'も', 'もも', 'の', 'うち']
# 分かち書き
df["tokens"] = df.text.apply(mecab_tokenizer)

これで、各テキストを分かち書きして配列にしたものがdf[“tokens”]に入りました。 (scikit-learnの場合は空白区切りの文字列にしますが、gensimの場合は単語を要素とする配列でデータを用意します。)
早速Phrasesモデルを作ります。

デフォルトのスコア関数、閾値はかなり大きめの1000で学習してみます。(あまりたくさんフレーズを見つけられても、この記事ではどうせ紹介できないのでかなり絞っています。デフォルトは10なので、通常の利用では1000は大きすぎです。)

from gensim.models.phrases import Phrases
phrase_model = Phrases(
    sentences=df["tokens"],  # 学習するデータ
    min_count=20,  # 最低何回出現した単語および単語ペアを対象とするか。デフォルト5
    scoring='default',  # スコアリングに用いる関数。 "default", "npmi", もしくは自作の関数を指定。
    threshold=1000,  # スコアが何点を超えたらフレーズとみなすか。でフォルト10.0
)

さて、これで学習ができました。学習した語彙は vocab プロパティが持っています。

phrase_model.vocab
"""
{'マイクロンジャパン': 2,
 'は': 12486,
 'マイクロンジャパン_は': 1,
 '、': 21839,
 'は_、': 3765,
 '従来': 138,
 '、_従来': 54,
 'の': 25248,
 '従来_の': 68,
# 以下略
"""

単語とその単語の出現回数に加えて、アンダーバーで二つの単語を繋いだbi-gram について、その出現回数の辞書となっています。(4系のgensimではvocabが単純な辞書ですが、実は3系では違ったのですよ。gensimオリジナルの型でしたし、単語はエンコーディングされていました。)

このモデルが結果的に見つけてくれたフレーズは、export_phrases()メソッドで取得することができます。(これも3系4系で挙動が違うメソッドです。)

phrase_model.export_phrases()
"""
{'ガ_ジェット': 1793.2403746097816,
 'インター_フェイス': 1398.7857142857142,
 '池田_利夫': 1409.4339100346021,
 '岡本_奈知': 1444.5520523497917,
 'ジャム_ハウス': 1377.0331304935767,
 'エヌプラス_copyright': 1409.4339100346021,
 'all_rights': 1259.6684809500248,
 'rights_reserved': 1393.045143638851,
 '上倉_賢': 1367.7015873015873,
 'キン_ドル': 1062.89667445223,
# 以下略
"""

見つけたフレーズと、そのフレーズのスコアの辞書として結果が得られます。

あの単語と、この単語の組み合わせのスコアって何点だったのかな?と思ったら、scoringメソッドで調べられます。気になるフレーズが検出されなかったら見てみましょう。

引数は結構たくさん渡す必要あります。まずヘルプ見てみましょう。

phrase_model.scoring?
"""
Signature:
phrase_model.scoring(
    worda_count,
    wordb_count,
    bigram_count,
    len_vocab,
    min_count,
    corpus_word_count,
)
"""

試しに、「キン_ドル」で1062.89… であることを見ておきましょうかね。worda_count とかは先に述べた通り、vocabから拾ってこれます。コーパスの単語数頭の情報はモデルが持ってるのでそこからとりましょう。

phrase_model.scoring(
    phrase_model.vocab["キン"],
    phrase_model.vocab["ドル"],
    phrase_model.vocab["キン_ドル"],
    len(phrase_model.vocab),
    phrase_model.min_count,
    phrase_model.corpus_word_count
)
# 1062.89667445223

学習に使ったデータとは別のテキストから、学習済みのフレーズを検索することもできます。

sample_data = [
    ['アマゾン', 'の', '新しい', 'ガ', 'ジェット'],
    ['新しい', 'キン', 'ドル', 'を', '買い', 'まし', 'た'],
]
print(phrase_model.find_phrases(sample_data))
# {'ガ_ジェット': 1793.2403746097816, 'キン_ドル': 1062.89667445223}

また、次のようにdictのようにモデルを使うと、渡されたデータ内で見つけたフレーズを _ で連結してくれます。結果がジェネレーターで帰ってくるので、listを使って配列にしてからprintしました。これはとても便利な機能なのですが、このような辞書的な呼び出し方ではなく、transformか何か名前のあるメソッドにしてほしかったですね。

print(list(phrase_model[sample_data]))
# [['アマゾン', 'の', '新しい', 'ガ_ジェット'], ['新しい', 'キン_ドル', 'を', '買い', 'まし', 'た']]

ちなみに、 _ だと不都合がある場合は、モデル学習時に delimiter 引数で違う文字を使うこともできます。

スコア関数を変えたり、閾値を変えたらり、また、スコア関数の中でmin_countなども使われていますので、この辺の値を変えることで結果は大きく変わります。なかなか面白いので色々試してみましょう。

また、このモデルを重ねがけするように使うことで、3単語以上からなるフレーズを抽出することもできます。(閾値などの調整に少々コツが必要そうですが。)
そのような応用もあるので、なかなか面白いモデルだと思います。

scikit-learnでテキストをBoWやtfidfに変換する時に空白以外の場所で単語を区切らないようにする

以前、scikit-learnのテキスト系の前処理モデルである、CountVectorizer
TfidfVectorizer において、1文字の単語を学習結果に含める方法の記事を書きました。
参照: scikit-learnでテキストをBoWやtfidfに変換する時に一文字の単語も学習対象に含める

この記事の最後の方で、以下のようなことを書いてました。

これ以外にも “-” (ハイフン) などが単語の境界として設定されていて想定外のところで切られたり、デフォルトでアルファベットを小文字に統一する設定になっていたり(lowercase=True)と、注意する時に気をつけないといけないことが、結構あります。

このうち、ハイフンなどの空白以外のところで単語を切ってしまう問題はワードクラウドで可視化したり単語の出現頻度変化を調べたりする用途の時に非常に厄介に思っていました。機械学習の特徴量を作る時などは最終的な精度にあまり影響しないことが多いので良いのですが。

これを回避するスマートな方法を探していたのですが、それがようやく分かったので紹介します。

前の記事でも行ったように、token_patternの指定で対応を目指したわけですが、以下のコード中の\\\\b の部分をどう調整したら良いのかがわからず苦戦していました。
このbは、\\\\wと\\\\Wの境にマッチするという非常に特殊な正規表現ですが、これをどうすれば空白と\\\\wの間にマッチさせらるのかが分からなかったのです。

# 1文字の単語も学習する設定
bow_model = CountVectorizer(token_pattern='(?u)\\b\\w+\\b')

それがあるとき気づいたのですが、この\\\\b とついでに(?u)は無くても動作変わらないんですよ。

先にそれを紹介しておきます。以前作ったニュースコーパスのデータでやってみます。
参考: livedoorニュースコーパスのファイルをデータフレームにまとめる

import MeCab
import subprocess
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
# データの読み込み
df = pd.read_csv("./livedoor_news_corpus.csv")
# ユニコード正規化とアルファベットの小文字統一
df.text = df.text.str.normalize("NFKC").str.lower()
# 改行コードを取り除く
df.text = df.text.str.replace("\n", " ")
# 辞書のパス取得
dicdir = subprocess.run(["mecab-config", "--dicdir"], capture_output=True, text=True).stdout.strip()
# 今回は品詞による絞り込みも原型への変換も行わないので -Owakati で実行する。
tagger = MeCab.Tagger(f"-Owakati -d {dicdir}/ipadic")
# 分かち書きした結果を返す。
def mecab_tokenizer(text):
    # 末尾に改行コードがつくのでstrip()で取り除く
    return tagger.parse(text).strip()
# 動作確認
print(mecab_tokenizer("すもももももももものうち"))
# すもも も もも も もも の うち
# 分かち書き
df["tokens"] = df.text.apply(mecab_tokenizer)
# 普段指定している token_pattern で学習
bow_model_1 = CountVectorizer(token_pattern='(?u)\\b\\w+\\b', min_df=10)
bow_model_1.fit(df["tokens"])
# 学習した語彙数
print(len(bow_model_1.vocabulary_))
# 15332
# # token_pattern を \\w+ だけにしたもの
bow_model_2 = CountVectorizer(token_pattern='\\w+', min_df=10)
bow_model_2.fit(df["tokens"])
# 学習した語彙数
print(len(bow_model_2.vocabulary_))
# 15332

語彙数が同じなだけでなく、学習した単語の中身も全く同じです。

# 学習した単語は一致する
set(bow_model_1.get_feature_names()) == set(bow_model_2.get_feature_names())
# True

さて、本題に戻ります。\\\\w+ でこれにマッチする単語が抜き出せるとなれば、単純にスペース以外にマッチする正規表現を書いてあげれればそれで解決です。
“[^ ]+” (ハット”^”と閉じ大括弧”]”の間にスペースを忘れないでください)や、\\\\S+ などを使えばOKです。
それぞれ試しておきます。

bow_model_3 = CountVectorizer(token_pattern='\\S+', min_df=10)
bow_model_3.fit(df["tokens"])
print(len(bow_model_3.vocabulary_))
# 15479
bow_model_4 = CountVectorizer(token_pattern="[^ ]+", min_df=10)
bow_model_4.fit(df["tokens"])
print(len(bow_model_4.vocabulary_))
# 15479

学習した語彙数が増えましたね。

「セ・リーグ」とか「ウォルト・ディズニー」が「・」で区切られずに学習されているのがわかりますよ。

print("セ・リーグ" in bow_model_1.get_feature_names())  # \\w+のモデルでは学習されていない。
# False
print("セ・リーグ" in bow_model_3.get_feature_names())  # \\S+のモデルでは学習されている
# True
print("ウォルト・ディズニー" in bow_model_1.get_feature_names())  # \\w+のモデルでは学習されていない。
# False
print("ウォルト・ディズニー" in bow_model_3.get_feature_names())  # \\S+のモデルでは学習されている
# True

これで、変なところで区切られずにMeCabで切った通りの単語で学習ができました。

ただし、この方法でもデメリットがないわけではありません。
\\\\w+ にはマッチしないが、\\\\S+にはマッチする文字がたくさん存在するのです。
要するに\\\\Wにマッチする文字たちのことです。

「?」や「!」などの感嘆符や「◆」のようなこれまで語彙に含まれなかった文字やそれを含む単語も含まれるようになります。これらが不要だという場合は、分かち書きする前か後に消しておいた方が良いでしょう。

もしくは逆に、不要に切ってほしくない文字は「- (ハイフン)」と「・(中点)」だけなんだ、みたいに特定できているのであれば、token_pattern=”[\\w\-・]+” みたいに指定するのも良いと思います。(ハイフンは正規表現の[]内で使うときは文字の範囲指定を意味する特殊文字なのでエスケープ必須なことに気をつけてください。)

いずれにせよ、結果を慎重に検証しながら使った方が良さそうです。

PythonでMeCabを動かそうとしたらmecabrc ファイルが無いというエラーが出たので原因を調べた

会社と私物でそれぞれMacbookを持っていて、AWSのアカウントとそこで動くEC2インスタンスもそれぞれあり、さらにDocker等含めていくつもPython環境を使っています。その中の一つで、突然PythonからMeCabが動かせなくなってしまったのでその解決方法のメモです。

具体的にはそれまで普通にMeCabが動かせていた環境にもかかわらず、次の様なエラーが出るようになってしまいました。MeCabをインポートして、MeCab.Tagger()するだけでエラーになるのでお手上げ状態でした。

>>> import MeCab
>>> MeCab.Tagger()
Failed initializing MeCab. Please see the README for possible solutions:
    https://github.com/SamuraiT/mecab-python3#common-issues
If you are still having trouble, please file an issue here, and include the
ERROR DETAILS below:
    https://github.com/SamuraiT/mecab-python3/issues
issueを英語で書く必要はありません。
------------------- ERROR DETAILS ------------------------
arguments:
error message: [ifs] no such file or directory: {Macのユーザー名を含む長いPathなのでマスク}/site-packages/unidic/dicdir/mecabrc

この事象が発生した環境には、MeCabは正常にインストールされていて、元々 MeCab.Tagger() も正常に実行できていました。

mecabrc ファイルも $ mecab-config –sysconfdir で取得できる場所、
つまり、/usr/local/etc/mecabrc にしっかり配置されているのに、全然違う .pyenv が管理してる各種ライブラリの配置場所を見に行ってそこに mecabrc が無いというエラーを起こしています。

原因調査編

確認してみると確かに site-packages ディレクトリ配下に mecabrc ファイルはありませんでした。というよりも、site-packages/unidic/dicdir 自体がありませんでした。

ネットで検索するとこのエラーメッセージで表示されたパスに /usr/local/etc/mecabrc をコピーして配置するという応急処置を取っている人がいましたが、ここは pipやcondaなどのパッケージ管理システムが管理している場所なので軽はずみに手動でいじりたくはありません。ということで腰を入れて原因と対策を調査しました。

結果、以下のことが原意で起きてるのがわかりました。
– transformers を、ドキュメントに沿って、[ja] というオプション付きで入れた。
-依存パッケージとしてunidic(MeCabの辞書の一つ)が一緒にインストールされた。
– unidicはインストールしただけでは辞書本体がダウンロードされない。
参考: unidic · PyPI
– 最近のmecab-python3はunidicを優先的に使おうとする。
(事象が発生したのは mecab-python3==1.0.4。mecab-python3==0.996では発生しない。)

transformers というのはBert等の学習済みモデルを手軽に使えるパッケージですね。インストール時にtransformers[ja] として入れると、日本語モデルを使うためのパッケージも一緒に入れてくれます。

これをやった時に、unidicというパッケージが入ったのです。
そして、unidicのドキュメントにある通り、この時点では辞書本体は端末にダウンロードされていませんでした。

しかし、インストールはされているので、Pythonコード上で、 import unidic は成功するし、unidic.DICDIR という値も取得できるわけです。(しかしそのディレクトリに辞書本体は無い。)

そしてさらに、このエラーが発生した環境のmecab-python3は割と最近の version 1.0.4 が入っていたのです。

mecab-python3のリポジトリで、 Add support for unidic installs via pypi というコミット を見ていただくとわかりやすいと思うのですが、この修正以降、 unidicが import できたら unidic を使おうとするようになっています。

def try_import_unidic():
    """Import unidic or unidic-lite if available. Return dicdir.
    This is specifically for dictionaries installed via pip.
    """
    try:
        import unidic
        return unidic.DICDIR
    except ImportError:
        try:
            import unidic_lite
            return unidic_lite.DICDIR
        except ImportError:
            # This is OK, just give up.
            return
class Tagger(_MeCab.Tagger):
    def __init__(self, rawargs=""):
        # First check for Unidic.
        unidicdir = try_import_unidic()
        args = rawargs
        if unidicdir:
            mecabrc = os.path.join(unidicdir, 'mecabrc')
            args = '-r "{}" -d "{}" '.format(mecabrc, unidicdir) + args
        # The first argument here isn't used. In the MeCab binary the argc and
        # argv from the shell are re-used, so the first element will be the
        # binary name.
        args = ['', '-C'] + shlex.split(args)
        # need to encode the strings to bytes, see here:
        # https://stackoverflow.com/questions/48391926/python-swig-in-typemap-does-not-work
        args = [x.encode('utf-8') for x in args]
        try:
            super(Tagger, self).__init__(args)
        except RuntimeError as ee:
            raise RuntimeError(error_info(rawargs)) from ee

Tagger作る時に最初に unidicを調べて、インポートに成功したら、引数に
args = ‘-r “{}” -d “{}” ‘.format(mecabrc, unidicdir) + args
として、unidicのmecabrcファイルと辞書のパスを追加していますね。

私物のMacの環境は、 mecab-python3 のバージョンが古く、この処理が無かったので素直にIPA辞書を使ってくれているようです。そして、このエラーが発生した環境は、つい最近までunidicが入ってなかったので、 「# This is OK, just give up.」 のコメントの通り、importできなかったので、unidicを使うのを諦めてIPA辞書を使ってくれていたようです。

対応編

エラーになる原因が分かったので対応案を検討してやっていきましょう。

案1. mecab-python3のバージョンを下げる。

要するにversion 0.996 だったら無理してunidic使おうとしないので解決です。
ただ、この先ずっとmecab-python3だけバージョンを上げずに使い続けるのか、という問題があるので個人的にはこれはお勧めしません。僕も採用しませんでした。

案2. unidicの本体をダウンロードする。

unidicのimport ができるのに、辞書本体がダウンロードされていないのが原因なので本体ダウンロードしましょうというのが方針です。実際はこれを採用しました。

コマンドはドキュメントの通りです。1回だけ実行すればOK。

python -m unidic download

これを実行すると、 MeCab.Tagger() が成功するようになりました。ただし、デフォルトでunidicが使われるようになります。 テキストをparseした結果の品詞等の情報の出力がIPA辞書と全然違うものになってしまいました。

今後、IPA辞書を使いたいときは次のようにしてIPA辞書のディレクトリを明示的に指定する必要があります。ちょっと面倒になりました。(環境によってIPA辞書のパスは違うので注意してください。)

import MeCab
MeCab.Tagger("-d /usr/local/lib/mecab/dic/ipadic/") 

案3. mecabrc ファイルパスを指定してTaggerを生成する。

実はこれも試し、成功しています。何らかの事情でunidicをダウンロードしたく無い場合は、
-r オプションで mecabrc ファイルを指定し、-d で辞書を指定することで動かすことができます。 上で参照した mecab-python3のソースコードで、
「args = ‘-r “{}” -d “{}” ‘.format(mecabrc, unidicdir) + args」
となっていますが、自分が指定した -r と -d もargsとしてMeCabに渡す引数に加えられるようなのです。そしてこれらはどちらも1つしか指定できないので後に付け加えられる分が先に書かれたunidic分を上書きしているようです。

具体的には次のように使います。(具体的なパスは環境に応じて変えてください。)

MeCab.Tagger("-r /usr/local/etc/mecabrc -d /usr/local/lib/mecab/dic/ipadic/") 

-r と -d は両方必須なので面倒です。片方だけだと指定しなかった方が unidicを見に行ってしまいます。(mecabrcファイル内に辞書ディレクトリのパスが指定されていますが、-dで指定した方が優先。)
結局これは採用しませんでした。記述量が多いから。

感想と今後の方針

MeCabは動かせるようになりましたが、デフォルトの辞書がunidicになってしまって毎回IPA辞書を指定しないといけない不便を感じるようになりました。

しかし、そもそもなぜ mecab-python3がunidic推しになったのかという問題があります。これは結構明らかで、IPA辞書がかなり昔に更新が止まってしまっているのに対して、unidicの方は最近も更新が続いているからでしょう。

新目の単語がIPA辞書に含まれていないので、その点では確かにunidicの方が優れているのですが、ざっと比較したところ、全面的にunidicが優秀というわけでもなく慣れもあってまだ個人的にIPA辞の方が使いやすい印象でいます。語彙だけでなく出力形式はかなり違いますし。

とはいえ、これを機会に、unidicの思想や特徴、活用方法をきちんと学んで、こちらを使うように寄せていくことも検討した方がいいのかなと思う出来事でした。

とりあえず、MeCab.Tagger() したときの挙動が僕が持っている環境間で異なり、コードの使い回しがしにくくなったというのが目下の自分の課題なので、これをどうにかしていこうと思います。全環境でIPA辞書を指定したコードを書くのか、もう諦めて全面的にunidicに移行するのか。