Full-text search for Japanese with ngram full-text parser

TL;DR

Create an index with ngram full-text parser.

CREATE FULLTEXT INDEX idx_message_log ON message_log (message) WITH PARSER ngram;

ngram Full-Text Parser

We want to do a full-text search for searching our entire texts that exist about 150k rows. Its text is written in Japanese.

Our table like this;

create table message_log
(
    id int(11) unsigned not null,
    message varchar(255) default '' not null,
    primary key (id)
);

If message column would fill out in English or other space-separated languages, you can create a full-text index.

CREATE FULLTEXT INDEX idx_message_log on message_log.message (message);

However, we treat the message as Japanese. In this case, we cannot get any message, because Japanese is not the text space-separated words.

For instance, Japanese like this;

好きなメンバーとその理由を教えて下さい!

not space-separated;

好きな メンバー と その 理由 を 教えて 下さい!

We assume we have this record.

id message
1 好きなメンバーとその理由を教えて下さい!
2 好きな メンバー と その 理由 を 教えて 下さい!

We find messages with the full-text search function.

SELECT * FROM message_log WHERE MATCH (message) AGAINST ('メンバー');

And then get this result.

id message
2 好きな メンバー と その 理由 を 教えて 下さい!

We expect to can get all records. However, it does not include the text 好きなメンバーとその理由を教えて下さい!.

So we create an index with ngram full-text parser.

CREATE FULLTEXT INDEX idx_message_log ON message_log (message) WITH PARSER ngram;

Again, find messages.

SELECT * FROM message_log WHERE MATCH (message) AGAINST ('メンバー');

And then we get ID 1 and 2 that we expected.

id message
1 好きなメンバーとその理由を教えて下さい!
2 好きな メンバー と その 理由 を 教えて 下さい!

Building a CI for Golang test

I built a CI with Jenkins for Golang test. We run go test on a Docker container and even run Jenkins on a Docker container.

Directories

app
├── docker
│   ├── dockerfiles # Dockerfiles for unit test
│   └── test
│       ├── init-db.sh # This initializes DB before testing
│       └── test.sh # Testing script
└── Jenkinsfile # The configuration for Jenkins pipeline

Environment of CI

Our Jenkins server uses an EC2 instance of t2.large, and the server runs on Docker container, and even a unit test run on Docker container on the container Jenkins runs with /var/run/docker.sock.

Jenkins loads Jenkinsfile and then execute it on the Jenkins pipeline.

How to build an execution environment

Create an AWS EC2 instance

We prepare the instance of EC2 installed Docker CE. Please see Get Docker CE for CentOS installation guide.

Create a Docker image for golang unit test

Jenkins

Dockerfile

FROM jenkins/jenkins:lts

# Switch to root user
USER root

# Install Docker
RUN apt-get update
RUN apt-get install -y \
     apt-transport-https \
     ca-certificates \
     curl \
     gnupg2 \
     software-properties-common

RUN curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
RUN add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"
RUN apt-get update
RUN apt-get install -y docker-ce
RUN echo "jenkins ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

# Switch back to jenkins user
USER jenkins

# Set system timezone JST

ENV TZ Asia/Tokyo

Run on a Jenkins host.

$ docker build --rm --tag jenkins-docker:latest .

Golang

Dockerfile

FROM circleci/golang:1.9

# Install goose
RUN curl https://glide.sh/get | sh
RUN go get bitbucket.org/liamstask/goose/cmd/goose

# Set system timezone JST
ENV TZ Asia/Tokyo

Run on our Jenkins host.

$ docker build --rm --tag golang:latest .

Launch Jenkins

$ sudo docker run --env JAVA_OPTS=-Dorg.apache.commons.jelly.tags.fmt.timeZone=Asia/Tokyo -v /var/run/docker.sock:/var/run/docker.sock --name jenkins -d -p 80:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins-docker:latest

-v /var/run/docker.sock:/var/run/docker.sock is used to manipulate host’s Docker because we want to launch containers on host-side.

-v jenkins_home:/var/jenkins_home is used to store everything of our Jenkins configurations and build results on our host’s filesystem. If you
move your Jenkins to another host or backup your Jenkins data, read this page.

Add a job to Jenkins

We need to enable Jenkins to hook Pull Requests when some developer does it.

Below settings on Jenkins.

Add a credential of GitHub enterprise

Because we use GitHub enterprise our development.

Credentials -> Jenkins -> Global credentials -> Add Credentials

key value
Kind Username with password
Scope Global
Username ci
Password ****

Add our GitHub enterprise

Configure System -> GitHub Enterprise Servers

key value
API endpoint http://***/api/v3
Name GitHub Enterprise

Create a job

New Item -> GitHub Organization -> OK

Configure the job’s settings

<Job> -> Configure -> Projects

key value
API endpoint GitHub Enterprise (http://***/api/v3)
Credentials ci/****
Owner some-repogitory
Script Path Jenkinsfile

<Job> -> Configure -> Projects -> Behaviours

key value
Filter by name (with regular expression) some-repogitory
Discover pull request from forks – Strategy Merging the pull request with the current target branch revision
Discover pull request from forks – Trust Everyone

Create a webhook in GitHub

To hook PR in Jenkins, We need to create a webhook in GitHub. Note that we must use the user has right permission.

<your repository> -> Settings -> Hooks

key value
Payload URL http://***/github-webhook/
Content type application/json
Which events would you like to trigger this webhook? Send me everything
Active true

Disable Jenkins’ authentication

Because we use Jenkins in a secure place, there are no incoming packets from the internet.

Manage Jenkins -> Configure Global Security -> Access Control -> Authorization -> check Anyone can do anything

Upgrade Jenkins

Since jenkins_home Docker volume has all Jenkins’ setting files, We pull a latest Docker image and relaunch Docker container, that’s it!

$ sudo docker stop jenkins
$ sudo docker rm jenkins
$ sudo docker pull jenkins/jenkins:lts
$ cd app/docker/dockerfiles/jenkins
$ docker build --rm --tag jenkins-docker:latest .
$ sudo docker run --env JAVA_OPTS=-Dorg.apache.commons.jelly.tags.fmt.timeZone=Asia/Tokyo -v /var/run/docker.sock:/var/run/docker.sock --name jenkins -d -p 80:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins-docker:latest

Jenkinsfile template

The Jenkinsfile we use, almost same, like this;

pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                step($class: 'GitHubSetCommitStatusBuilder')
                checkout scm
            }
        }

        stage('Start up containers') {
            steps {
                sh "sudo docker network create ci${env.EXECUTOR_NUMBER}"

                sh "sudo docker run -d --name mysql${env.EXECUTOR_NUMBER} --network ci${env.EXECUTOR_NUMBER} -p 3306${env.EXECUTOR_NUMBER}:3306 circleci/mysql:5.7"
                sleep(10)
                sh "sudo docker run -d --name redis${env.EXECUTOR_NUMBER} --network ci${env.EXECUTOR_NUMBER} redis:4.0"

                script {
                    if (sh (
                            script: "sudo docker create --name golang${env.EXECUTOR_NUMBER} --network ci${env.EXECUTOR_NUMBER} golang:latest bash /go/src/app/docker/test/test.sh",
                            returnStatus: true
                    ) == 0) {
                        sh "sudo docker cp ${env.WORKSPACE} golang${env.EXECUTOR_NUMBER}:/go/src/leo-server"
                    }
                }
            }
        }

        stage('Initialize containers') {
            steps {
                // Initialize something like DB
            }
        }

        stage('Unit test') {
            steps {

                script {
                    if (sh (
                            script: "sudo docker start -a golang${env.EXECUTOR_NUMBER}",
                            returnStatus: true
                    ) != 0) {
                        currentBuild.result = 'FAILURE'
                    }
                }

                // Copy test report and convert it into junit xml report
                sh "sudo docker cp golang${env.EXECUTOR_NUMBER}:/go/src/app/report.xml ."

                step([$class: 'JUnitResultArchiver', testResults: 'report.xml'])
            }
        }
    }

    post {
        always {
            sh script: "sudo docker stop mysql${env.EXECUTOR_NUMBER}", returnStatus: true
            sh script: "sudo docker stop redis${env.EXECUTOR_NUMBER}", returnStatus: true

            sh script: "sudo docker rm mysql${env.EXECUTOR_NUMBER}", returnStatus: true
            sh script: "sudo docker rm redis${env.EXECUTOR_NUMBER}", returnStatus: true
            sh script: "sudo docker rm golang${env.EXECUTOR_NUMBER}", returnStatus: true

            sh script: "sudo docker network rm ci${env.EXECUTOR_NUMBER}", returnStatus: true
        }
    }
}

Our test script, test.sh, like this;

#!/bin/bash

sudo chown -R circleci:circleci /go/src

cd /go/src/leo-server

echo 'Installing go-packages...'
glide i

echo 'Migrating DBs...'
go get bitbucket.org/liamstask/goose/cmd/goose
goose -env=ci -path=database/user up

echo 'Installing testing libraries...'
go get -u github.com/jstemmer/go-junit-report

echo 'Testing...'
go test -v ./... 2>&1 > tmp
status=$?
go-junit-report < tmp > report.xml

exit ${status}

Golangでユニットテスト書くテクニック

Goは他のフレームワークにあるような大きなアサーションツールを持っていません。Goでは testing.T オブジェクトのメソッドがテストに使われます。

  • T.Error(args ...interface{}) または T.Error(msg string, args interface{}) はメッセージを受け取ってテストを失敗させるために使用されます
  • T.Fatal(args ...interface{}) または T.Fatal(mst string, args interface{})T.Error() と似ていますがテストが失敗すると、それ以降のテストは実行されません。テストが失敗した時それ以降のテストも失敗する場合、 T.Fatal() を使うべきです

以下ではGoのテスト使用される2つのテクニックを紹介します。

モックとスタブにインターフェースを使用する

外部ライブラリに依存したコードを書いていて、その外部ライブラリが正しく利用されているかテストしたいときを考えます。

Goのインターフェースはメソッドの期待する動作を表しています。 例として io.Writer を見てみます。

type Writer interface {
    Write(p []byte) (n int, err error)
}

io.Writer インターフェースは引数で受け取ったバイト列を書き込みますが、このインターフェースは os.Fileなどで実装されています。Goのtypeシステムではどのインターフェースを使うか明示する必要がありません。既存のtypeのプロパティと一致するインターフェースを宣言することで、外部ライブラリの動作を変更することができます。

例を見ていきましょう。

以下のようなメッセージを送信する外部ライブラリがあります。

type Message struct {
     // ...
}

func (m *Message) Send(email, subject string, body []byte) error {
     // ...
     return nil
}

これをそのまま使うのではなくMessageを使うMessagerインターフェースを作成します。

type Messager interface {
    Send(email, subject string, body []byte) error
}

Alertメソッドでメッセージを送信することを考えます。Message typeを直接渡すのではなくMessager引数で受け取って、インターフェースのSendメソッドを呼び出すようにします。

func Alert(m Messager, problem []byte) error {
    return m.Send("example@example.com", "Critical Error", problem)
}

このようにMessageを抽象化したmessagerを使うことで簡単にモックを作成してテストすることができます。

具体的には以下のようになります。

package msg

import (
    "testing"
)

type MockMessage struct {
    email, subject  string
    body            []byte
}

func (m *MockMessage) Send(email, subject string, body []byte) error {
    m.email = email
    m.subject = subject
    m.body = body
    return nil
}

func TestAleart(t *testing.T) {
    msgr := new(MockMessage) // モックのメッセージを作成します
    body := []byte("Critical Error")

    Alert(msgr, body) // Aleartメソッドを実行します

    if msgr.subject != "Critical Error" {
        t.Errorf("Expected 'critical Error', Got '%s'", msgr.subject)
    }
}

Messagerインターフェースを実装するためにMockMessage typeを作成します。MockeMessageではMessagerと同じSend()が実装されています。このSend()はメーセージを実際に送信するのではなくデータをオブジェクトに保存しておくことでテストしやすくなります。

また、このようにインターフェースを使った抽象化をすることで、後にSend()の動作を変えなければいけなくなった時に簡単に変えられるようになります。

カナリアテスト

外部ライブラリを使っているとメジャーバージョンアップの時などにメソッドの引数が変わることがあります。

例えば、io.Writerを新しく実装していたとします。これをライブラリとして公開していて、他のコードがこれを使用しています。以下のようなコードです。

type MyWriter struct{
     // ...
}

func (m *MyWriter) Write([]byte) error {
     // どこかにデータを書き出す
     return nil
}

ぱっと見io.Writeを実装しているように見えますが、正しくはWrite(p []byte) (n int, err error)です。なのでio.Writeを実装できていません。

次に、type assertionを使ってコードを書いてみます。

func main() {
    m := map[string]interface{}{
        "w": &MyWriter(),
    }
}

func doSomething(m map[string]interface{}) {
    w := m["w"].(io.Writer) // runtime exceptionになる
}

このコードはコンパイルとは通りますが、runtimeでexceptionになります。

これを防ぐために以下のようなカナリアテストを追加します。(ちなみにカナリアテストは”canary in the coal mine”から来ているようです)

func TestWriter(t *testing.T) {
    var _ io.Writer = &MyWriter{} // コンパイラにtype assertionをやってもらう
}

このテストはもちろん失敗します。このようにtype assertionを使ってテストすることで、インターフェースを正しく実装できているか確認することができます。また、外部ライブラリのシグネチャの変更にも気づくことができます。

Lenear algebra for machine learning

I’ve been reviewing linear algebra, Mathematics for Machine Learning: Linear Algebra on Coursera. I finished the Week 2 module. This course is easy to understand as far. And I memorize what I did in week one and week two modules.

The three properties of dot product

Commutative

\[
r \cdot s = r_i s_i + r_j s_j \\
= 3 \times -1 + 2 \times 2 = 1 \\
= s \cdot r
\]

Distributive

\[
r \cdot (s + t) = r \cdot s + r \cdot t
\] \[
r =
\begin{bmatrix}
r_1 \\
r_2 \\
\vdots \\
r_n \\
\end{bmatrix}
s =
\begin{bmatrix}
s_1 \\
s_2 \\
\vdots \\
s_n \\
\end{bmatrix}
t =
\begin{bmatrix}
t_1 \\
t_2 \\
\vdots \\
t_n \\
\end{bmatrix} \\
s \cdot (s + t) = r_1(s_1 + t_1) + r_2(s_2 + t_2) + \cdot s + r_n (s_n + t_n) \\
= r_1s_1 + r_1t_1 + r_2s_2 + r_2t_2 + \cdot s + r_ns_n + r_nt_n \\
= r \cdot s + r \cdot t
\]

Associative over scalar multiplication

\[
r \cdot (as) = a(r \cdot s) \\
r_i(as_i) + r_j(a s_j) = a(r_is_i + r_js_j)
\]

And r dot r is equal to the size of r squared.

\[
r \cdot r = r_ir_i + r_jr_j \\
= r_i^2 + r_j^2 \\
r \cdot r = |r|^2
\]

Cosine and dot product

cosine rule

\[
c^2 = a^2 + b^2 – 2ab \cos\theta
\] \[
|r – s|^2 = |r|^2 + |s|^2 – 2|r||s|\cos\theta \\
(r-s) \cdot (r-s) = r \cdot r -s \cdot r -s \cdot r -s \cdot -s \\
= |r|^2 – 2s \cdot r + |s|^2 \\
-2s \cdot r = -2|r||s|\cos\theta \\
2s \cdot r = 2|r||s|\cos\theta \\
r \cdot s = |r||s|\cos\theta
\]

It takes the size of the two vectors and multiplies by cos of the angle between them. It tells us something about the extent to which the two vectors go in the same direction.

\(\cos 0 = 1\), \(r \cdot s = |r||s|\).
Two vectors are orthogonal to each other, \(\cos 90 = 0\), \(r \cdot s = |r||s| \times 0 = 0\).
\(\cos 180 = -1\), \(r \cdot s = -|r||s|\).

Projection

A light coming down from s. It’s the shadow of s on r. This is called the projection.

\[
\cos = \frac{adjecent}{hypotenuse} = \frac{adjecent}{|s|} \\
r \cdot s = |r| \underbrace{|s| \cos \theta}_{adjecent(|r| \times projection)}
\]

Scalar projection

\[
\frac {r \cdot s}{|r|} = |s| \cos \theta
\]

Vector projection

The scalar projection also encoded with something about the direction of r a unit vector.

\[
\frac {r \cdot s}{|r||r|}r = \frac {r \cdot s}{r \cdot r}r
\]

Changing Basis

If you do the projection, two vectors must be orthogonal.

Convert from the e set of basis vectors to the b set of bases vectors.

This projection is of length 2 time \(b_1\)

\[
\frac {r_e \cdot b_1}{|b_1|^2} = \frac {3 \times 2 + 4 \times 1}{2^2 + 1^2} = \frac {10}{5} = 2
\] \[
\frac {r_e \cdot b_1}{|b_1|^2} b1 = 2 \begin{bmatrix}2\\1 \end{bmatrix} = \begin{bmatrix}4\\2 \end{bmatrix}
\]

This projection is of length \(\frac{1}{2}\) time \(b_2\)

\[
\frac {r_e \cdot b_2}{|b_2|^2} = \frac {3 \times -2 + 4 \times 4}{-2^2 + 4^2} = \frac {10}{20} = \frac {1}{2}
\] \[
\frac {r_e \cdot b_2}{|b_2|^2} b2 = \frac {1}{2} \begin{bmatrix}-2\\4 \end{bmatrix} = \begin{bmatrix}-1\\2 \end{bmatrix}
\]

We get the original vector r from above.

\[
\begin{bmatrix}4\\2\end{bmatrix} + \begin{bmatrix}-1\\2\end{bmatrix} = \begin{bmatrix}3\\4\end{bmatrix}
\]

In the basis b, it’s going to be
\[
r_b =
\begin{bmatrix}
2 \\
\frac{1}{2} \\
\end{bmatrix}
\]

We can redescribe original axis using some other axis, some other basis vectors. The basis vectors we use to describe the space of data.

Basis, vector, and linear independence

Basis is a set of n vectors that:

  • are not linear combinations of each other (linearly independent)
  • span the space
  • The space is then n-dimensional

Applications of changing basis

We get minimus possible number for the noisiness.

Proposal of CEDEC 2018

I proposed the automatic reply system for our customer support to CEDEC 2018. Last week, CEDEC 2018 committee announced proposals adoptions. My proposal was not adopted, I am afraid. The causes I thought is that I just created an automatic reply system so I should have included about applying the system to our customer support and operation and feedback from our customer support on my proposal, but I did not finish these tasks yet. I will propose again what include considerations about above causes next year!

LSTMの文の理解能力

English

LSTMの文の理解能力について、個人的に面白いと思ったので紹介したいと思います。今回使用した学習済みモデルはこちらの記事で紹介しています。

以下の動画は2つの質問を学習済みモデルにしたものです。A(上の質問)は課金に関する質問で、B(下の質問)はアカウント消失に関する質問です。両方は2つのカテゴリー(“課金”と”アカウント”)が混在する質問で、前後のカテゴリーを入れ替えただけのテキストです。

Aの文

この前はアカウントの引き継ぎの問題解決ありがとうございました。今回の不具合はアイテムを購入したのに反映されません。このようなことが続くのは悲しいです。

Bの文

この前はアイテム購入の問題解決ありがとうございました。今回の不具合はアカウントの引き継ぎができない問題です。このようなことが続くのは悲しいです。

これらは先に説明した通り、前後のカテゴリーを入れ替えて意味が逆になるようにしています。このモデルでは両方の質問に対してカテゴリーの分類に成功しています。動画の下の”predictions”の部分が各カテゴリーのスコア(確信度と呼ぶことにします)になっていて、この値が高いカテゴリーほどそのカテゴリーであるということを確信していることになります。

確信度は0はじまりのカンマ区切りで、1列は”その他”、2列目は”アカウント”、3列目は”課金”のカテゴリーであることを表しています。Aのテキストの確信度は以下の通りです。3列目が一番高い確信度になっていることがわかります。つまり課金のカテゴリーに分類していることがわかります。

Aの文

predictions
etc, other, account, payment
0.0038606818, 0.036638796, 0.04247639, 0.46222764

Bのテキストの確信度は以下の通りです。こちらは2列が一番高い確信度が高いことからアカウントのカテゴリーに分類していることがわかります。

Bの文

predictions
etc, other, account, payment
0.0007114554, 0.04938373, 0.72704375, 0.0038164733

これらの一番確信度が高いカテゴリーは、他の確信度より大きな差をつけています。この結果から、LSTMが単純に単語からカテゴリーを分類するのではなく、文からカテゴリーを分類できているのではないかと思います。

今後検証したいこと

  • サンプル数を増やす
  • LSTMの代わりに1-D convolutional networkを使う
  • 学習済みのword embeddingを使う

Understanding sentence with LSTM

I am going to demonstrate LSTM understand a sentence. The model I used explained this blog post.

Below video gives an example classifies the two questions that A is about payment and B is about an account. Both texts are what mix these two categories up and also reverse these sentence before and after each other.

The A (upper question) means in English “Thank you for helping a problem with an account. But, today, I get another problem about payment. I am sad about this happening.”

The B (lower question) means in English “Thank you for helping a problem with payment. But, today, I get another problem about an account. I am sad about this happening.”

These examples flip these means each other. And the A and B succeeded to classify categories. The model is sure of the categories because the score gets higher than the other scores. Let’s look at the score on the video. Below the predictions on the video shows the score, higher is better.
The 1st column (zero-based) express “other” category, 2nd is “account,” and 3rd is “payment.” The score like this:

Sentence A

predictions
etc, other, account, payment
0.0038606818, 0.036638796, 0.04247639, 0.46222764

Sentence B

predictions
etc, other, account, payment
0.0007114554, 0.04938373, 0.72704375, 0.0038164733

In the A, 3rd column is higher more than the other columns. It means the model is sure the A is about “payment” category. B is the same as A; it is certain of “account” category.

Thus, I found this model which uses LSTM may understand the sentence of a text.

Future tasks

  • Use more samples
  • Use 1-D convolutional network instead of LSTM
  • Use pre-trained word embedding

LSTMを使ってテキストの多クラス分類をする

English

Kerasを使ってテキスト分類をするWebアプリケーションのプロトタイプを作ってみました。このプロトタイプはカスタマーサービスで利用することを想定してカスタマーからの質問に自動で返答することを考えます。質問はいくつかのカテゴリーに属していて、アプリケーションがそのカテゴリーを分類できるようにします。

サンプルのソースコードはGitHubを参照してください。

データを集める

分類モデルを作る前にデータセットを集める必要があります。インターネット上にある記事などを見るとIMDBの映画レビューのデータセットを使っていることが多いように思います。今回はこのデータセットではなく質問と回答のデータセットを別で用意しました。

ファイルフォーマット

ファイルはTSVで質問ID、質問テキスト、返答テキスト、カテゴリーを含んでいます。質問と返答テキストは日本語です。以下のような形式です。

id question answer category

このデータセットは約9000サンプルで、カテゴリーの種類は約15です。

データをロードする

TSVファイルから読み込みます。

import json
import numpy as np
import csv

issues = []

with open("data/issues.tsv", 'r', encoding="utf-8") as tsv:
    tsv = csv.reader(tsv, delimiter='\t')

    for row in tsv:
        row = []
        row.append(row[1]) # question
        row.append(row[2]) # answer
        row.append(row[3]) # category

        issues.append(row)

テキストの前処理

使わない文字を削除

データセットのテキストデータにはe-mailのアドレスや記号など今回使用しない文字列が含まれているのでそれらを削除します。

以下のようなテキストの例を考えます。削除する文字列は単純に正規表現で空文字に置換しています。

filtered_text = []
text = ["お時間を頂戴しております。version 1.2.3 ----------------------------------------"]

for t in issues:
    result = re.compile('-+').sub('', t)
    result = re.compile('[0-9]+').sub('0', result)
    result = re.compile('\s+').sub('', result)
    # ... このような置換処理が複数繋がっています

    # 質問テキストが空文字になることがあるのでその行は含めないようにします
    if len(result) > 0:
        sub_texts.append(result)

    filtered_text.append(result)
    print("text:%s" % result)
    # text:お時間を頂戴しております。

サンプルとラベルを作成します

データセットからサンプルとラベルを作成します。今回は全て使うのではなく15カテゴリーの中から例として”Account”と”Payment”の2カテゴリのみ使用します。それ以外は”その他”としてラベルづけします。サンプルはこの3
つのラベルで同じサイスである必要があります。データ数が偏ってしまうとLSTMでうまく分類できなくなってしまいます。今回は”Payment”のラベルが688サンプルしかなかったので、約700のサンプル数に揃えました。

サンプルとラベルを作成する

labels = []
samples = []
threshold = 700
cnt1 = 0
cnt2 = 0
cnt3 = 0

for i, row in enumerate(filtered_samples):
    if 'Account' in row[2]:
        if cnt2 < threashold:
            cnt1 += 1
            labels.append(2)
            samples.append(row[0])
    elif 'Payment' in row[2]:
        if cnt3 < threashold:
            cnt3 += 1
            labels.append(3)
            samples.append(row[0])
    else:
        if cnt1 < threashold:
            cnt1 += 1
            labels.append(1)
            samples.append(row[0])

filtered_samplesは事前に記号などを削除したデータセットです。

MeCabを使って分かち書きにする

質問テキストは日本語なので分かち書きにする必要があります。例えば以下のようなテキストがあるとします。

お時間を頂戴しております

このテキストをMeCabで分かち書きに変換します。

import MeCab
import re

def tokenize(text):
    wakati = MeCab.Tagger("-O wakati")
    wakati.parse("")
    words = wakati.parse(text)

    # Make word list
    if words[-1] == u"\n":
        words = words[:-1]

    return words

texts = [tokenize(a) for a in samples]

以下のようにスペースで区切られたテキストになります。

お 時間 を 頂戴 し て おり ます

サンプルとラベルを分割する

サンプルとラベルとトレーニングデータと検証データに分割します。

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
from keras.utils.np_utils import to_categorical

maxlen = 1000
training_samples = 1600 # training data 80 : validation data 20
validation_samples = len(texts) - training_samples
max_words = 15000

# word indexを作成
tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)

word_index = tokenizer.word_index
print("Found {} unique tokens.".format(len(word_index)))

data = pad_sequences(sequences, maxlen=maxlen)

# バイナリの行列に変換
categorical_labels = to_categorical(labels)
labels = np.asarray(categorical_labels)

print("Shape of data tensor:{}".format(data.shape))
print("Shape of label tensor:{}".format(labels.shape))

# 行列をランダムにシャッフルする
indices = np.arange(data.shape[0])
np.random.shuffle(indices)
data = data[indices]
labels = labels[indices]

x_train = data[:training_samples]
y_train = labels[:training_samples]
x_val = data[training_samples: training_samples + validation_samples]
y_val = labels[training_samples: training_samples + validation_samples]

data は以下のような整数のシーケンスなデータになっています。

[0, 0, 0, 10, 5, 24]

0以外の整数は分かち書きにした各単語と一致しています。0は単語がないことを意味します。上記の例だと3単語のため左の3列は0で埋められています。

モデルの作成と学習

学習にはKerasを使用しています。KerasにはLSTMとword embeddingが用意されているので、それを使います。LSTMは時系列データの分類や回帰問題などに利用されます。

モデルの作成

from keras.models import Sequential
from keras.layers import Flatten, Dense, Embedding
from keras.layers import LSTM

model = Sequential()
model.add(Embedding(15000, 100, input_length=maxlen))
model.add(LSTM(32))
model.add(Dense(4, activation='sigmoid'))
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])
model.summary()

このモデルはLSTMの学習の他にEmbedding()を使ってword embeddingも同時に学習します。

学習する

model.fit()を呼ぶだけです。

history = model.fit(x_train, y_train, epochs=15, batch_size=32, validation_split=0.2, validation_data=(x_val, y_val))

結果をプロットする

%matplotlib inline

import matplotlib.pyplot as plt

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()

plt.figure()

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()

plt.show()

以下のような結果になりました。

最終的にvalidation accuracyが約90%になりました。

モデルを保存する

モデルと学習した重みを保存します。

model.save('pre_trained_model.h5')

Webアプリケーションを作成する

学習済みモデルをWebアプリケーションに組み込みます。Kerasと同じ言語の方が扱いやすかったのでWebフレームワークにはFlaskを使いました。このアプリケーションをテキストは受け取って、そのテキストのカテゴリーを予測した結果をユーザーに返すだけです。以下のようにテキストエリアと質問ボタンがあり、予測した結果が表示されます。

質問を予測する

カテゴリーを予測する前にword indexを作成する必要があります。このword indexはモデルを作成した時と同じものです。

app.py

# 学習済みモデルをロードする
model = load_model('../pre_trained_model.h5')

# padded_seqは2次元の行列で渡す必要があります
result = model.predict([padded_seq])

予測の結果を取得する。

np.argmax(res[0])

ソースコードはこちらのリポジトリを参照してください。

参考文献

Deep Learning with Python こちらの書籍がとても参考になりました!Keras作者のCholletさんによって書かれているのでとてもオススメです。

Multi-categorical text classification with LSTM

I created the prototype of a web application for customer service that uses sequence classification with Keras. This prototype’s purpose is to reply the proper response of some categories to our customer are based on the questions customer sent to us. The questions relate to some categories, and then the application predicts to which category a question belongs.

If you are looking for the same situation, this sample might be helpful for you.

You can see the whole source code in GitHub.

Collect text data

Before creating a classification model, collect data set for creating it. Many classification’s articles on the internet use the IMDB movie review data set, I think. Instead, I use customer services’ question and its categories in our product. I collected this data and store as TSV file.

File format

The format is TSV, and it consists id, question, answer, and the category of question like this:

id question answer category

This raw data set has about 9000 samples. But they include unusable data and have about 15 categories of question.

Load data

Load data from TSV formatted file.

import json
import numpy as np
import csv

issues = []

with open("data/issues.tsv", 'r', encoding="utf-8") as tsv:
    tsv = csv.reader(tsv, delimiter='\t')

    for row in tsv:
        row = []
        row.append(row[1]) # question
        row.append(row[2]) # answer
        row.append(row[3]) # category

        issues.append(row)

Pre-process text

Remove unnecessary characters

These samples are rough for learning. It means that some sample has no question text, and has an e-mail address and symbol like a hyphen. So We have to remove these unnecessary characters.

I removed these with just regular expression and the
question which is an empty string like this:

filtered_text = []
text = ["長らくお時間を頂戴しております。version: 1.2.3 ----------------------------------------"]

for t in issues:
    result = re.compile('-+').sub('', t)
    result = re.compile('[0-9]+').sub('0', result)
    result = re.compile('\s+').sub('', result)
    # ... and many regular expression substitutions

    # remove empty string question
    if len(result) > 0:
        sub_texts.append(result)

    filtered_text.append(result)
    print("text:%s" % result)
    # text:長らくお時間を頂戴しております。

Create samples and labels

Create samples and labels from the data set. It has about 15 categories of labels. And I select two label types, ‘Account’ as two and ‘Payment’ as three; they are question’s categories. And add the other all labels as one which includes the other categories excepts Account, Payment. The samples and labels have to be the same size roughly because LSTM learning wouldn’t work well if one of these is more or less. In this case, cap the samples’ size it’s 700 samples because the payment label has only 688 samples.

Create samples and labels

labels = []
samples = []
threshold = 700
cnt1 = 0
cnt2 = 0
cnt3 = 0

for i, row in enumerate(filtered_samples):
    if 'Account' in row[2]:
        if cnt2 < threashold:
            cnt1 += 1
            labels.append(2)
            samples.append(row[0])
    elif 'Payment' in row[2]:
        if cnt3 < threashold:
            cnt3 += 1
            labels.append(3)
            samples.append(row[0])
    else:
        if cnt1 < threashold:
            cnt1 += 1
            labels.append(1)
            samples.append(row[0])

filtered_samples is what we removed some symbols, e-mail address or something like these from the samples.

Separate the words by MeCab

The questions in the samples written in Japanese. So have to separate words into each word with space. Below is a question text in Japanese:

長らくお時間を頂戴しております

I used MeCab to get space-separated words:

import MeCab
import re

def tokenize(text):
    wakati = MeCab.Tagger("-O wakati")
    wakati.parse("")
    words = wakati.parse(text)

    # Make word list
    if words[-1] == u"\n":
        words = words[:-1]

    return words

texts = [tokenize(a) for a in samples]

This tokenize function returns space-separated words:

長らく お 時間 を 頂戴 し て おり ます

Divde the samples and labels

Divide the samples and labels into training data and validation data:

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
from keras.utils.np_utils import to_categorical

maxlen = 1000
training_samples = 1600 # training data 80 : validation data 20
validation_samples = len(texts) - training_samples
max_words = 15000

# create word index
tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)

word_index = tokenizer.word_index
print("Found {} unique tokens.".format(len(word_index)))

data = pad_sequences(sequences, maxlen=maxlen)

# to binary class matrix
categorical_labels = to_categorical(labels)
labels = np.asarray(categorical_labels)

print("Shape of data tensor:{}".format(data.shape))
print("Shape of label tensor:{}".format(labels.shape))

# shuffle indices
indices = np.arange(data.shape[0])
np.random.shuffle(indices)
data = data[indices]
labels = labels[indices]

x_train = data[:training_samples]
y_train = labels[:training_samples]
x_val = data[training_samples: training_samples + validation_samples]
y_val = labels[training_samples: training_samples + validation_samples]

The data is integer sequese like this:

[0, 0, 0, 10, 5, 24]

Each non-zero integer relates to a word and the zero stands for “empty word.” Therefore, this words size is just three and the rest of the sequence will be filled with zero.

Create a model and learn features

I used Keras for learning features. It includes LSTM and Word embedding. LSTM is used for a sequence classification problem, sequence regression problem and so on.

Create a model

from keras.models import Sequential
from keras.layers import Flatten, Dense, Embedding
from keras.layers import LSTM

model = Sequential()
model.add(Embedding(15000, 100, input_length=maxlen))
model.add(LSTM(32))
model.add(Dense(4, activation='sigmoid'))
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])
model.summary()

This model learns with LSTM and also word embedding with Embedding(...) at the same time. We can also use pre-trained word embedding instead learning word embedding.

Learn features

Just call model.fit()

history = model.fit(x_train, y_train, epochs=15, batch_size=32, validation_split=0.2, validation_data=(x_val, y_val))

Plot the result

%matplotlib inline

import matplotlib.pyplot as plt

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()

plt.figure()

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()

plt.show()

The result is like this:

Finally, the validation accuracy becomes about 90 percent.

Save the model

Save the model and weights learned.

model.save('pre_trained_model.h5')

Create a web application

I wanted to use the pre-trained model with a web application. So I used Flask this time because its language is the same as Keras. And this application is simple, receives a text, predicts and then responses its category to the user. This application has a text area, an ask button and the result of a prediction.

Predict a certain question

Before predicting a text, we have to calculate the word index the same as we created for creating the pre-trained model.

app.py

# load the pre traind model
model = load_model('../pre_trained_model.h5')

# we have to pass padded_seq as 2-dimentional array
result = model.predict([padded_seq])

Get the classified result:

np.argmax(res[0])

Please see the whole source code in my repository.

Reference

Deep Learning with Python This book helpful for me!

Use Mono 2.X on Ubuntu 14.04 LTS

Unfortunately, I had to use the Mono which version is 2.X in my project. It’s very old, released in 2012! So I installed it on Ubuntu 16.04 LTS from source and do make. Then the error occurred in doing make like this:

./.libs/libmini-static.a(libmini_static_la-mini.o): In function `mono_get_jit_tls_offset':
/home/vagrant/mono-2.11.4/mono/mini/mini.c:2506: undefined reference to `mono_jit_tls'
/home/vagrant/mono-2.11.4/mono/mini/mini.c:2506: undefined reference to `mono_jit_tls'
collect2: error: ld returned 1 exit status
Makefile:1351: recipe for target 'mono' failed
make[4]: *** [mono] Error 1
make[4]: Leaving directory '/home/vagrant/mono-2.11.4/mono/mini'
Makefile:1209: recipe for target 'all' failed
make[3]: *** [all] Error 2
make[3]: Leaving directory '/home/vagrant/mono-2.11.4/mono/mini'
Makefile:344: recipe for target 'all-recursive' failed
make[2]: *** [all-recursive] Error 1
make[2]: Leaving directory '/home/vagrant/mono-2.11.4/mono'
Makefile:419: recipe for target 'all-recursive' failed
make[1]: *** [all-recursive] Error 1
make[1]: Leaving directory '/home/vagrant/mono-2.11.4'
Makefile:344: recipe for target 'all' failed
make: *** [all] Error 2

So I ended up using Ubuntu 14.04 LTS for Mono 2.X.

The error might occur by the libraries that are gcc or something related to compilation.