カテゴリー: ソフトウェア

SONYのNeural Network Libraryを使ってみてのメモとか。

NNLで画像を読み込みたい場合

モデルに画像を読み込ませるには、nnabla.utils.data_source_loaderモジュールで読み込ませる事が出来ます。

# -*- coding: utf-8 -*-
import PIL.Image
import nnabla.utils.data_source_loader as nn_dsl

X_SIZE = 28
Y_SIZE = 28

# shapeに指定したサイズにリサイズされて読み込まれます。
# paddingはされません。
np_img = nn_dsl.load_image(
    "testdata0.png",
    shape=(3, X_SIZE, Y_SIZE),
    normalize=False
)

# 読み込んだ画像のshapeのままだと、Pillowで利用出来ませんので
# Pillowで活用したい場合は以下のようにします。

np_pil = np_img.transpose(1, 2, 0)
imp_pil = PIL.Image.fromarray(np_pil)
img_pil.save("testdata1.png")

Pillowで読み込んだ画像をNNLで扱える構造にしたい場合

numpyモジュールを使います。

# -*- coding: utf-8 -*-

import numpy as np
import PIL.Image

X_SIZE = 28
Y_SIZE = 28

img_pil = PIL.Image.open(pathname)
img_pil.thumbnail((X_SIZE, Y_SIZE))

img_target = PIL.Image.new("RGB", (X_SIZE, Y_SIZE))

x_src, y_src = o_image.size
x_pos = (X_SIZE - x_src) >> 1
y_pos = (Y_SIZE - y_src) >> 1

img_target.paste(img_pil, (x_pos, y_pos))

data = img_target.getdata()

np_img = np.array(data, dtype=np.float32)
np_img = np_img.reshape((X_SIZE, Y_SIZE, 3))
np_img = np_img.transpose(2, 0, 1)

# normalizeする場合は、 np_img /= 255.0

使用する機械はあまりなさそうでうけど、ISO-2022-JP-MS(JIS)からCP932(SHIFT-JIS)へ変換するコードを、以下のサイトに掲載されているプログラムを移植してみました。

http://www.geocities.jp/hoku_hoshi/TIPPRG/tipprg03.html

プログラム本体

# -*- coding: utf-8 -*-
"""
"""
# ------------------------------------------------------------------ import(s)
import sys
import array

# --------------------------------------------------------------- exception(s)
class CConvertError(Exception):
    """
    想定範囲外のJISコードエスケープを検出
    """
    pass

# ---------------------------------------------------------------- function(s)
# ============================================================================
# 0x1B([ESC]), 0x24($), 0x40(@)
# 0x1B([ESC]), 0x24($), 0x42(B)
# 0x1B([ESC]), 0x26(&), 0x40(@)
# 0x1B([ESC]), 0x28((), 0x42(B)
# 0x1B([ESC]), 0x28((), 0x4A(J)
# 0x1B([ESC]), 0x28((), 0x49(I)
def jis_to_sjis(jis_buffer):
    """
    与えられたバイト配列をJISコード文字列とみなして、SHIFT-JISへの変換を行います。

    args:
        jis_buffer (str):
            バイト配列

    returns:
        str: SHIFT-JIS文字列を戻します。
    """

    ary_src = array.array("B", jis_buffer)
    ary_dst = array.array("B")

    str_result = []

    n = 0
    kanji_mode = False
    while n < len(ary_src):
        c0 = ary_src[n]
        n += 1
        if c0 == 0x1B:
            c1 = ary_src[n]
            n += 1
            c2 = ary_src[n]
            n += 1
            if c1 == 0x24 and c2 in (0x40, 0x42):
                kanji_mode = True
            elif c1 == 0x26 and c2 == 0x40:
                kanji_mode = True
            elif c1 == 0x28 and c2 in (0x42, 0x49, 0x4A):
                kanji_mode = False
            else:
                raise CConvertError()
            continue

        if kanji_mode is True:
            c1 = ary_src[n]
            n += 1

            if c0 < 0x5F:
                irow_offset = 0x70
            else:
                irow_offset = 0xB0

            if c0 & 0x01:
                if c1 > 0x5F:
                    icell_offset = 0x20
                else:
                    icell_offset = 0x1F
            else:
                icell_offset = 0x7E

            ary_dst.append(((c0 + 1) >> 1) + irow_offset)
            ary_dst.append(c1 + icell_offset)

        else:
            ary_dst.append(c0)

    return ary_dst.tostring()


if __name__ == "__main__":

    with open("testdata.jis", "rb") as h_reader, open("testdata.conv", "wb") as h_writer:
        code_jis = h_reader.read()
        code_sjis = jis_to_sjis(code_jis)
        h_writer.write(code_sjis)
        print("cp932", code_sjis.decode("cp932"))

# [EOF]

テストデータ

ABCDE
あいうえお
FGHIJ
①②③④⑤
KLMNO
㈱㈲δ㌔㌧

テスト方法

上記の様なテストデータをUTF-8で作成して、iconvやnkfを使用してjis形式のファイルに変換します。

iconvの場合

iconv -f UTF-8 -t ISO-2022-JP-MS testdata.utf8 > testdata.jis
iconv -f UTF-8 -t CP932 > testdata.utf8 > testdata.cp932

nkfの場合

nkf -Wj testdata.utf8 > testdata.jis
nkf -Ws testdata.utf8 > testdata.cp932

.

データベースに文書を保存するまでが出来たので、やっと本題の類似度判定を。

データベースから文書を取り出して学習と判定を行う

# -*- coding: utf-8 -*-
# ------------------------------------------------------------------ import(s)
import sys
import os
import sqlite3
import gensim.models.doc2vec
import gensim.models.doc2vec


# ------------------------------------------------------------------- const(s)
# ------------------------------------------------------------------- class(s)
# ---------------------------------------------------------------- function(s)
def main():

    list_document = []

    o_conn = sqlite3.connect("dccol.db")
    o_cursor = o_conn.cursor()

    o_cursor.execute(
        """
        SELECT
            id_doc
        ,   word_pos
        ,   word_surface
        ,   word_feature
        FROM
            doc_collection
        WHERE
            LENGTH(word_surface) > 1
            AND
            word_feature = '名詞'
        ORDER BY
            id_doc, word_pos
        """
    )

    dict_document = {}

    for r in o_cursor.fetchall():
        id_doc = r[0]
        word_pos = r[1]
        word_surface = r[2]
        word_feature = r[3]

        if id_doc not in dict_document:
            dict_document[id_doc] = []
        dict_document[id_doc].append(word_surface.encode("utf-8"))

    list_tagged_document = []

    for id_doc, list_word in dict_document.items():

        with open(id_doc + ".wakati", "w") as h_writer:
            h_writer.write(" ".join(list_word))

        o_doc = gensim.models.doc2vec.TaggedDocument(
            words=list_word,
            tags=[id_doc]
        )

        list_tagged_document.append(o_doc)

    dvec_model = gensim.models.doc2vec.Doc2Vec(
        documents=list_tagged_document,
        min_count=1
    )

    list_word = ["ヴィヴィオ", "アインハルト","コロナ","リオ"]
    for similar_word in list_word:
        print u"指定した単語に関連するもの", similar_word.decode("utf-8")
        for r in dvec_model.wv.most_similar(positive=[similar_word]):
            print "\t", r[0].decode("utf-8"), r[1]
        print

    similar_doc = os.path.join("doc_source", "doc1.txt")
    print u"指定した文書に近いもの", similar_doc
    for r in dvec_model.docvecs.most_similar(positive=[similar_doc]):
        print "\t", r[0], r[1]
    print

if __name__ == "__main__":
    main()

# [EOF]

やっていることは、データベースから二文字以上の名詞を取り出して学習用データを生成して、与えたキーワード、文書に似ている（近いベクトルのもの）を取得しています。

実行すると以下のような結果が表示されます。

指定した単語に関連するもの ヴィヴィオ
        スタイル 0.404163241386
        状態 0.396886348724
        ため 0.391772806644
        アインハルト 0.378925800323
        リンネ・ベルリネッタ 0.374079525471
        結果 0.3656296134
        意味合い 0.356572329998
        デバイス 0.350234866142
        雪辱 0.344531387091
        兵器 0.343862652779

学習させた文書は、Pixiv百科事典からキャラクター名の項目をテキスト化したものを与えています。

ヴィヴィオに関連するものとして、

• アインハルト
• リンネ・ベルリネッタ

といったキーワードが出力されています。

与えた文書量が少なく、文書自体も短いためなんとなくうまくいっているようないないような。

まずはjanomeを使用して形態素解析を行います。

カスタム辞書を指定していますが、指定しなくても動作します。

janomeによる形態素解析

# -*- coding: utf-8 -*-
# http://www.mizunagi-works.com
# ------------------------------------------------------------------ import(s)
import sys
import os

import janome.tokenizer

# ------------------------------------------------------------------- const(s)
DB_FILENAME = "dccol.db"
CUSTOM_DIC = "./dic/nanoha_keyword.dic"
RAW_TEXT_DIR = "doc_source"


# ------------------------------------------------------------------- class(s)
# ---------------------------------------------------------------- function(s)
def main():

    o_tagger = janome.tokenizer.Tokenizer(CUSTOM_DIC)

    # 指定したフォルダ内の .txt 拡張子のファイルを読み込み
    for dirname, _, list_filename in os.walk(RAW_TEXT_DIR):
        for filename in list_filename:
            if os.path.splitext(filename)[1].lower() not in (".txt",):
                continue

            pathname = os.path.join(dirname, filename)

            with open(pathname, "r") as h_reader:

                # utf-8 to unicode
                raw_u_text = h_reader.read().decode("utf-8")

                for pos, r in enumerate(o_tagger.tokenize(raw_u_text)):
                    word_surface = r.surface
                    word_feature = r.part_of_speech.split(",")[0]

if __name__ == "__main__":
    main()

# [EOF]

word2vecを使用するには形態素解析したデータをもとに分かち書きを作成する必要があります。

毎回形態素解析をして生成しても良いですが、ここでは形態素解析をした結果をデータベースに一旦保存した後、必要な情報を取得できるようにしてみます。

janomeによる形態素解析とデータベースへの保存

前述のコードを修正してデータベース（ここではsqlite3）へ保存するようにしたもの。

# -*- coding: utf-8 -*-
# http://www.mizunagi-works.com
# ------------------------------------------------------------------ import(s)
import sys
import os
import sqlite3

import janome.tokenizer


# ------------------------------------------------------------------- const(s)
DB_FILENAME = "dccol.db"
CUSTOM_DIC = "./dic/nanoha_keyword.dic"
RAW_TEXT_DIR = "doc_source"


# ------------------------------------------------------------------- class(s)
# ---------------------------------------------------------------- function(s)
def main():

    o_tagger = janome.tokenizer.Tokenizer(CUSTOM_DIC)

    o_conn = sqlite3.connect(DB_FILENAME)
    o_cursor = o_conn.cursor()

    # テーブル生成
    o_cursor.execute(
        """
        CREATE TABLE IF NOT EXISTS doc_collection
        (
            id_doc text
        ,   word_pos int
        ,   word_surface text
        ,   word_feature text
        );
        """
    )

    # 指定したフォルダ内の .txt 拡張子のファイルを読み込んでDB化
    for dirname, _, list_filename in os.walk(RAW_TEXT_DIR):
        for filename in list_filename:
            if os.path.splitext(filename)[1].lower() not in (".txt",):
                continue

            pathname = os.path.join(dirname, filename)

            with open(pathname, "r") as h_reader:

                # utf-8 to unicode
                raw_u_text = h_reader.read().decode("utf-8")

                # 指定したドキュメントを削除
                o_cursor.execute(
                    """
                    DELETE FROM
                        doc_collection
                    WHERE
                        id_doc = ?;
                    """,
                    (pathname,)
                )

                for pos, r in enumerate(o_tagger.tokenize(raw_u_text)):

                    word_surface = r.surface
                    word_feature = r.part_of_speech.split(",")[0]

                    # 指定したドキュメントに単語を追加
                    o_cursor.execute(
                        """
                        INSERT INTO doc_collection
                        (
                            id_doc, word_pos, word_surface, word_feature
                        ) VALUES (?, ?, ?, ?);
                        """,
                        (pathname, pos, word_surface, word_feature,)
                    )

    o_conn.commit()

if __name__ == "__main__":
    main()

# [EOF]

.