Ahogrammer

Deep Dive Into NLP, ML and Cloud

BERTで日本語の含意関係認識をする

含意関係認識(Recognizing Textual Entailment: RTE)とは、2つの文1と文2が与えられたときに、文1が正しいとしたら文2も正しいか否かを判定するタスクのことです。たとえば、文1として「太郎は人間だ。」という文があるとします。この文が正しいとしたとき文2である「太郎は動物だ。」が正しいか否かを判定します。この場合は人間は動物であるため正しいと判定する必要があります。

含意関係認識を解くための手法は様々ありますが、本記事ではBERTを使った機械学習ベースの手法で解くことにします。

BERTによる含意関係認識器の実装

本節ではBERTを用いた含意関係認識のモデルを構築します。実装の手順は以下の通りです。

  • プロジェクト構成
  • パッケージのインストール
  • データセットの準備
  • モデルの定義
  • 評価用コードの実装
  • モデルの学習と評価

プロジェクト構成

本節では以下のプロジェクト構成で実装を進めていきます。

.
├── data
│   └── entail_evaluation_set.txt
├── models/
├── models.py
├── preprocessing.py
├── train.py
└── utils.py

dataディレクトリの中には使用するデータセットを格納しておきます。今回の場合は次の節で説明する日本語の含意関係認識用データを利用します。modelsディレクトリには学習したモデルを格納します。models.pyには機械学習モデルの定義を行います。preprocessing.pyには前処理用の関数を、train.pyには学習用のコードを、utils.pyにはデータ読込用の関数などを書きます。

パッケージのインストール

まずはBERTを使ったモデルを楽に実装するためにTransformersというパッケージをインストールします。Transformersは自然言語処理向けのモデルが多数含まれたパッケージであり、その中にはBERTも含まれています。BERTは公式の実装も存在するのですが、Transformersを使ったほうが実装が簡単なので、今回はこちらを使います。その他、MeCabPythonバインディング、TensorFlow、scikit-learn、pandasもインストールします。以下のコマンドを実行しましょう。

$ pip install transformers tensorflow scikit-learn pandas mecab-python3

データの準備

まずはデータセットのダウンロードを行いましょう。今回は京都大学の黒橋・河原研究室で公開しているTextual Entailment評価データを使います。このデータセットは約2700のデータ数からなり、それぞれに4値の推論判定が付与されています。Textual Entailment 評価データからダウンロードしてdataディレクトリに格納しましょう。

データセットをダウンロードして中身を見ると、以下のように空白区切りで情報が格納されています。全部で5カラムから構成され、1カラム目にID、2カラム目にカテゴリとサブカテゴリ、3カラム目に推論判定、4カラム目にテキスト、5カラム目に仮説が格納されています。また、1文ごとに空行が挟まれていることを確認できます。

15 語彙(体言):下位→上位 ◎ あの人は呼吸器専門医だ。 あの人は医者だ。

データセットを用意して形式を確認したので、読み込むための関数load_datasetutils.pyに書いていきます。ファイルをpandasで読み込んだあと、ラベルのマッピングをし、文のペアとラベルのリストを返しています。マッピングをしているのは、△や○のデータを分類するのが難しいためです。

import pandas as pd


def load_dataset(filepath, encoding='utf-8'):
    df = pd.read_csv(filepath,
                     encoding=encoding,
                     delim_whitespace=True,
                     names=['id', 'cat', 'label', 't1', 't2'])
    mapping = {
        '×': '×',
        '△': '×',
        '○': '◎',
        '◎': '◎'
    }
    df.label = df.label.map(mapping)
    return list(zip(df.t1, df.t2)), df.label

データセットを読み込むための関数を書き終わったので、次はデータセットの前処理用の関数をpreprocessing.pyに書いていきます。ここで行う前処理は、ボキャブラリの作成、単語分割、単語のID化、パディングです。まずはボキャブラリを表すクラスVocabを書きます。

import json

import numpy as np
from tensorflow.keras.preprocessing.sequence import pad_sequences


class Vocab:

    def __init__(self):
        self.token_index = {}
        self.index_token = {}

    def fit(self, labels):
        self.token_index = {label: i for i, label in enumerate(set(labels))}
        self.index_token = {v: k for k, v in self.token_index.items()}
        return self

    def encode(self, labels):
        label_ids = [self.token_index.get(label) for label in labels]
        return label_ids

    def decode(self, label_ids):
        labels = [self.index_token.get(label_id) for label_id in label_ids]
        return labels

    @property
    def size(self):
        """Return vocabulary size."""
        return len(self.token_index)

    def save(self, file_path):
        with open(file_path, 'w') as f:
            config = {
                'token_index': self.token_index,
                'index_token': self.index_token
            }
            f.write(json.dumps(config))

    @classmethod
    def load(cls, file_path):
        with open(file_path) as f:
            config = json.load(f)
            vocab = cls()
            vocab.token_index = config.token_index
            vocab.index_token = config.index_token
        return vocab

ボキャブラリを表すクラスを書き終わったら、データセット前処理用の関数をpreprocessing.pyに書きます。やっていることは、テキストを単語分割してID化したあと、パディングしているだけです。

def convert_examples_to_features(x, y,
                                 vocab,
                                 max_seq_length,
                                 tokenizer):
    features = {
        'input_ids': [],
        'attention_mask': [],
        'token_type_ids': [],
        'label_ids': np.asarray(vocab.encode(y))
    }
    for pairs in x:
        tokens = [tokenizer.cls_token]
        token_type_ids = []
        for i, sent in enumerate(pairs):
            word_tokens = tokenizer.tokenize(sent)
            tokens.extend(word_tokens)
            tokens += [tokenizer.sep_token]
            len_sent = len(word_tokens) + 1
            token_type_ids += [i] * len_sent

        input_ids = tokenizer.convert_tokens_to_ids(tokens)
        attention_mask = [1] * len(input_ids)

        features['input_ids'].append(input_ids)
        features['attention_mask'].append(attention_mask)
        features['token_type_ids'].append(token_type_ids)

    for name in ['input_ids', 'attention_mask', 'token_type_ids']:
        features[name] = pad_sequences(features[name], padding='post', maxlen=max_seq_length)

    x = [features['input_ids'], features['attention_mask'], features['token_type_ids']]
    y = features['label_ids']
    return x, y

以上でデータセットを準備するために使う関数の定義は終わりました。次はモデルを作成していきましょう。

モデルの定義

今回実装するモデルのアーキテクチャは以下の図のようになります。用意した3つの入力をBERTに入力し、分散表現に変換します。その後、分散表現を活性化関数にソフトマックス関数を指定した全結合層に入力し、各ラベルの確率を予測します。

f:id:Hironsan:20200108134547p:plain
モデルのアーキテクチャ(画像はBERTの論文より)

モデルの定義は以下のようになります。Transformersを使うととてもシンプルに実装できます。models.pyに追記してください。

import tensorflow as tf
from transformers import BertConfig, TFBertForSequenceClassification


def build_model(pretrained_model_name_or_path, num_labels):
    config = BertConfig.from_pretrained(
        pretrained_model_name_or_path,
        num_labels=num_labels
    )
    model = TFBertForSequenceClassification.from_pretrained(
        pretrained_model_name_or_path,
        config=config
    )
    model.layers[-1].activation = tf.keras.activations.softmax
    return model

以上でモデルの実装は完了です。次は学習したモデルの評価を行うコードを書いていきます。

評価用コードの実装

学習したモデルを使って評価をする関数を作成していきましょう。以下のevaluateクラスをutils.pyに書いていきます。このクラスでは、predictメソッドに(input_ids, attention_mask, token_type_ids)を与えると、予測結果を返してくれます。処理の流れとしては、前処理したデータに対してpredictメソッドで予測を行った後、np.argmaxで確率値の最も高いラベルのIDを取得し、decodeメソッドで文字列に変換しています。そして最後に、評価を行っています。

import numpy as np
from sklearn.metrics import classification_report


def evaluate(model, target_vocab, features, labels):
    label_ids = model.predict(features)
    label_ids = np.argmax(label_ids, axis=-1)
    y_pred = target_vocab.decode(label_ids)
    y_true = target_vocab.decode(labels)
    print(classification_report(y_true, y_pred, digits=4))

モデルの学習と評価

では最後に、これまでに説明した内容に基づいて、モデルを学習させて性能を評価するコードを書いていきましょう。以下のコードをtrain.pyに書いて保存します。

from sklearn.model_selection import train_test_split
from tensorflow.keras.callbacks import EarlyStopping
from transformers import BertJapaneseTokenizer

from models import build_model
from preprocessing import convert_examples_to_features, Vocab
from utils import load_dataset, evaluate


def main():
    # Set hyper-parameters.
    batch_size = 32
    epochs = 100
    model_path = 'models/'
    pretrained_model_name_or_path = 'bert-base-japanese-whole-word-masking'
    maxlen = 250

    # Data loading.
    x, y = load_dataset('./data/entail_evaluation_set.txt')
    tokenizer = BertJapaneseTokenizer.from_pretrained(pretrained_model_name_or_path)

    # Pre-processing.
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)
    target_vocab = Vocab().fit(y_train)
    features_train, labels_train = convert_examples_to_features(
        x_train,
        y_train,
        target_vocab,
        max_seq_length=maxlen,
        tokenizer=tokenizer
    )
    features_test, labels_test = convert_examples_to_features(
        x_test,
        y_test,
        target_vocab,
        max_seq_length=maxlen,
        tokenizer=tokenizer
    )

    # Build model.
    model = build_model(pretrained_model_name_or_path, target_vocab.size)
    model.compile(optimizer='sgd', loss='sparse_categorical_crossentropy')

    # Preparing callbacks.
    callbacks = [
        EarlyStopping(patience=3),
    ]

    # Train the model.
    model.fit(x=features_train,
              y=labels_train,
              batch_size=batch_size,
              epochs=epochs,
              validation_split=0.1,
              callbacks=callbacks)
    model.save_pretrained(model_path)

    # Evaluation.
    evaluate(model, target_vocab, features_test, labels_test)


if __name__ == '__main__':
    main()

コードを書き終えたら実行してみましょう。BERTは大きなモデルなのでCPU上で実行するととても時間がかかります。できればGPU上で実行させることをおすすめします。参考までにGPUNVIDIA Tesla V100)上で学習させたところ、1エポックに30程度かかり、全体としては200秒程度かかりました。性能としては正解率で0.6485という結果になりました。

Epoch 1/100
1779/1779 [==============================] - 50s 28ms/sample - loss: 0.6683 - val_loss: 0.6361
Epoch 2/100
1779/1779 [==============================] - 30s 17ms/sample - loss: 0.6442 - val_loss: 0.6549
Epoch 3/100
1779/1779 [==============================] - 30s 17ms/sample - loss: 0.6193 - val_loss: 0.6223
Epoch 4/100
1779/1779 [==============================] - 30s 17ms/sample - loss: 0.5913 - val_loss: 0.6282
Epoch 5/100
1779/1779 [==============================] - 30s 17ms/sample - loss: 0.5603 - val_loss: 0.7203
Epoch 6/100
1779/1779 [==============================] - 30s 17ms/sample - loss: 0.5252 - val_loss: 0.6349
              precision    recall  f1-score   support

           ×     0.4771    0.4371    0.4562       1670.7251    0.7561    0.7403       328

    accuracy                         0.6485       495
   macro avg     0.6011    0.5966    0.5983       495
weighted avg     0.6415    0.6485    0.6445       495

以上で実装は完了です。 今回はモデルもコードもシンプルさを重視して書いてみました。 最も基礎的なモデルなので性能はそれほど出ませんが、その分、改善の余地は大きいです。色々試してみてください。

教師あり学習を使ってオープンドメインのテキストから情報抽出する手法

オープンドメインの情報抽出は、この10年ほどで盛んになってきた自然言語処理の一分野でOpenIE(Open Information Extraction)と呼ばれている。OpenIEでは、ドメインを限定しないテキストからタプルを抽出する。たとえば、「ホンダは本田宗一郎によって創業された」という文であれば (ホンダ; 創業された; 本田宗一郎) というタプルを抽出する。抽出したタプルは知識グラフの構築や質問応答等での有用性が示されている。とりわけ、知識グラフはGartnerのハイプ・サイクル2019年版で取り上げられていることから窺えるように、今後重要な技術となるので、その要素技術としてのOpenIEを知っておく価値はある。

f:id:Hironsan:20191101083408p:plain
ハイプ・サイクル2019年版。画像は5 Trends Appear on the Gartner Hype Cycle for Emerging Technologies, 2019より引用。

本記事では、教師あり学習を使ったOpenIEの手法を紹介する。紹介する手法はNAACL 2018に提出された論文「Supervised Open Information Extraction」で提案された方法である。これまでのOpenIEでは、限られた教師データしか存在しなかったために、半教師あり学習やルールベースのアプローチが主に使われてきた。この論文では、質問応答のデータセットを変換してOpenIEのデータセットを作成し、OpenIEを系列ラベリングとして定式化して解いている。実験の結果、高性能でありつつ、予測速度に優れている点を示した。AllenNLPで実装が公開されており、以下のWebページから体験できる。

f:id:Hironsan:20191101085350g:plain
AllenNLPでのOpenIEのデモ画面

課題を解決するために、この論文では主に以下の2点を行っている。

この論文ではOpenIEを以下の図で表されるような系列ラベリングの問題として解いている。系列ラベリングとして解くためにスキーマに工夫をしている。スキーマは系列ラベリングで使われるIOB2であるが、述語(predicate)をP、項(argument)をAとして表現している。項にはポジションが付いており、このポジションがタプル内での項の順番を表している。以下の図でいうと、A0として「Obama」、Pとして「was born」、A1として「in America」が取れるので(Obama; was born; in America)というタプルが得られる。

f:id:Hironsan:20191031111914p:plain
モデルのアーキテクチャ

また、抽出したタプルの信頼度を計算するために、得られたタプルを構成する単語のBIタグの予測確率の積を取っている。このような信頼度の計算方法を使っているので、より述語や項が短いタプルに対して高い信頼度を割り当てることになる。ちなみに、タプルの信頼度を計算するのは、信頼度を使って適合率と再現率をコントロールできるようにするという意図がある。

OpenIEを学習するための教師データが限られているのは先に述べた通りだが、この論文では既存のデータセットを拡張するために質問応答のデータセットを変換してOpenIEの教師データを作成している。質問応答のデータセットとしてはQAMR(Question Answer Meaning Representation)を用いている。たとえば、以下の図の場合、質問文に含まれる「What」を回答である「mercury filling」で置き換えることでOpenIEのデータセットを得ている。このような変換自体は新しいアイデアではなく、先行研究がある。

f:id:Hironsan:20191102125614p:plain
データセットの変換

予測性能は以下の表で示される。提案手法の名前はRnnOIEで、verbがデータ拡張なし、awがデータ拡張を行った場合の性能を示している。この結果を見ると、データ拡張をすることで性能が大きく向上していることを確認できる。ただ、拡張しない場合は既存の手法と比べて優位性があるようには見えない。

f:id:Hironsan:20191102130048p:plain
予測性能

予測速度に関する結果は以下の表で示される。そもそもなぜ予測速度を載せているのかというと、OpenIEは元々Web上の文書からの情報抽出を対象としていたため、膨大な量の文書を処理するには予測速度が重視されたためである。ちなみにオープンドメインである点もその辺が理由となっている。以下の表は1秒間でどれだけの文を処理できるかということを示している。結果を見ると、既存手法と比べてそれなりに速く処理できていることがわかる。

f:id:Hironsan:20191102130424p:plain
予測速度に関する結果

感想

読んだ感想としては、結果は出ているが、何を課題にしていたのかがはっきりしない印象が残った。論文で述べていた課題である、半教師あり学習やルールベースのアプローチを使うこと自体は問題ではない。それで性能が出ていればいい話である。そうではなく、それらの手法を使った結果としてどういう問題が出てきたのかという話があればもっと良かったと思う。たとえば、ルールベースの手法を使うとルールが増えるに連れメンテナンスコストが上昇するであるとか、半教師あり学習の場合は作成したデータにノイズが混じりがちといった話があるはずである。それを述べた上で教師あり学習の必要性を示せば説得力が増したのではないか。

また、モデルについても新規性はほとんどない。モデルそのものがBiLSTMにSoftmaxをくっつけただけであるし、タグ付けのスキーマもこの前年のACL2017で固有表現認識と関係抽出を同時に解く論文「Joint Extraction of Entities and Relations Based on a Novel Tagging Scheme」で提案されたものと変わりはない。唯一言えるとしたら入力として与える特徴ベクトルに工夫をしている点であろうか。

論文中でも述べているように、QAのデータセットを変換してOpenIEのデータセットを作るというアイデア自体も新しいものではない。QAMRを変換して作った人はいなかったようだが、新規性としては弱い感じは否めない。

とまあ色々言ったが、実装がシンプルでありAlennNLPで公開されている点から初めに試す手法としてはとても良さそうである。今後はこの論文の手法が教師あり学習を用いたOpenIEのベースラインとして使われるようになるかもしれない。

参考文献

単語分散表現の信頼性を考慮した固有表現認識

ACL 2019より以下の論文を紹介。

この論文では、単語分散表現の信頼性を考慮した固有表現認識を行うモデルを提案している。単語分散表現は広く使われているが、低頻度語や未知語のように文脈が十分に存在しない単語の場合はその信頼性は頻出語と比べて低い。しかし、現在のモデルはすべての分散表現を等しく重み付けしているため、それによって性能を損なっている可能性がある。そこでこの論文では、単語の出現頻度を基に分散表現の信頼性を計算し、モデルに組み込んでいる。実験の結果、従来より良い結果を得られた。

以前から知られているが、現在の固有表現認識のモデルは未知語に弱いという課題がある。たとえば、以下の例を考えてみよう。

  • 例: 先日の雨で鬼難橋が流された。

「鬼難橋」というのは私が作った固有表現であり、実際には存在しない。とはいえ、人間が見れば橋であることはすぐに分かる。なぜなら、「橋」という文字が含まれることや「流された」という文脈に着目して判断するからである。しかし、現在の固有表現認識モデルにとっては簡単な話ではない。その理由の一つとして、訓練用データセットに現れた固有表現そのものを記憶し、文脈を有効活用していない点がある。以下のように文脈から明らかな場合でさえ、未知語に対しては上手く認識できないのが現状である。

f:id:Hironsan:20191009082108p:plain
anaGoのデモ画面

この問題を解決するために、この論文では単語分散表現の信頼性を考慮したモデルを提案している。信頼性を測る基本となるのは、ある単語の頻度が高ければその単語の分散表現は信頼できるという考え方である。なぜなら、単語の頻度が高ければ、その文脈はより多様性があり重みの更新も頻繁にされるからである。このようにして信頼性を計算できると、知らない単語(未知語)やかろうじて知っている単語(低頻度語)の場合に文字や文脈の情報をより重視して答えるモデルを作成できる。

信頼性の計算には、単語分散表現を学習させるコーパス中での単語の頻度feと固有表現認識の訓練用データセット中での単語の頻度fnを使う。これらを使ってNumeric signalとBinary signalの2種類の信号を作る。Numeric signalはハイパーパラメータ\lambdaを使って\tanh (\lambda f)で計算される。これには頻度は様々な値を取るのでtanhで正規化する狙いがある。一方、Binary signalは頻度がしきい値を下回ったら1、そうでない場合は0という条件式で計算される。

f:id:Hironsan:20191009092520p:plain
Binary signalの計算式

計算した信頼性はLSTMのゲート機構のようにして使われる。モデル全体の構成は以下の画像で示される。計算した信頼性は単語レベルと文脈レベルで使われる。要するに何を表現したいのかと言うと、単語レベルで使う場合は、信用できない単語の場合は文字表現を重視し、文脈レベルで使う場合は、より文脈を重視した判断をするということである。これにより、「鬼難橋」という未知語が出現した場合に、「橋」という文字情報や「流された」という文脈情報を重視した判断を行うことができるようになる。各レベルでのゲート機構の詳細については論文を参照してもらいたい。

f:id:Hironsan:20191008081309p:plain
提案モデルの概要

実験ではデータセットとしてOntoNotes 5.0を用いている。OntoNotes 5.0には以下のように多様な6つのジャンルが含まれている。

f:id:Hironsan:20191009094920p:plain
OntoNote 5.0のジャンル

ジャンルごとの実験結果を以下の表で示す。結果を見ると、一つのジャンルを除いて、提案モデルがベースラインより優れた性能を発揮していることがわかる。

f:id:Hironsan:20191009095109p:plain
ジャンルごとの性能

未知語に対する性能の検証は、学習とテストでOntoNote 5.0の異なるジャンルのテキストを使うことで行っている。以下の表は学習用データセットとテスト用データセットでのジャンルごとの未知語の割合を示している。たとえば、学習用データセットmzを使い、テスト用データセットbcを使った場合の未知語の割合が81.3%になることを示している。

f:id:Hironsan:20191009095428p:plain
未知語の割合

未知語に対する性能の検証結果は以下の通り。ほとんどの場合において、提案モデルがベースラインより優れた性能であることが確認できる。

f:id:Hironsan:20191009095659p:plain
ジャンル間の性能

感想

個人的には面白い論文であった。というのも、以前にリアルタイムに固有表現認識を行うアプリを作ったときに、モデルが文脈をあまり見ていないことには気づいていたのだが、この論文はその問題に対して一つの解答を示してくれたためである。単なる記憶によって解くのではなく、状況に応じて重視する情報を変えるのは面白い。

現在は事前学習済みのモデルが配布される時代なので、分散表現を学習させたコーパスの情報が必要なのは微妙な点ではあるが、固有表現認識以外のモデルに使える汎用性がある点はポイントが高い。おそらく、ある程度長いテキストの分類にはあまり効かないが、SNSのようなショートテキストや質問応答といったタスクではこの論文の手法を組み込めば性能を向上させられる可能性がある。

未知語に対する性能の検証方法はもう少し改善できるのではないかと思う。現状の検証では、「未知語の割合が様々な場合でも性能を改善できるモデルである」ということしか読み取れないのではないか。それもいいと思うのだが、既知語と未知語のそれぞれについて、提案手法でどれだけ性能が改善されたかを示す方がより説得力のある結果になったのではないか。