のんびりしているエンジニアの日記

ソフトウェアなどのエンジニア的な何かを書きます。

クリスマスにChainerを使って妄想力を可視化した。

皆さんこんにちは
お元気ですか。やっと書き切りました。

実は今年ももう少しです。
昨年度はカノジョを作成し、その前は友利奈緒を真面目に解析しています。

いやぁ時の流れは早いものです。
これを踏まえ、今年は何をしようか考えました。

Chainer Advent Calendar 25日目で、皆様の妄想力を具現化したいと思います。

qiita.com

妄想について

さて、考えてみて欲しい。妄想というものを
画像に不自然に暗い箇所、何か見にくいなぁと思う箇所。
ここはこんな感じになっていると推測しているのではないでしょうか。

そう、推測、いや、補完です。
さて、本題ですが、部分的にモザイクがかかった画像を見るとここにはこれがあると妄想するでしょう。
そんなわけで、本日、皆様の妄想を具現化する、つまり、モザイクを外すことを試みます。

モザイク処理外し

モザイク処理とは

モザイク処理は次のように定義されているようです。(Wikipedia

モザイク処理(モザイクしょり)(英語: mosaic processing)・ピクセル化 (英語: pixelization)とは写真・画像・静止画・映像・動画において表示したくない部分をピクセル単位で見えにくくする映像処理。(by Wikipedia

要は見えにくい部分を加工する処理です。モザイク処理自体は後で詳細を述べます。

モザイク処理の種類

モザイク処理は大別して2種類の方式があります。
モザイクは、非可逆圧縮可逆圧縮の手法です。

非可逆圧縮は元に戻すことができない圧縮方式であり、モザイク画像から元画像を完全に復元することができません。
それに対し、可逆圧縮は元に戻すことが可能な方式であり、現在は非可逆圧縮が主流となっているそうです。
可逆圧縮の代表例としてFLMASKと呼ばれるツールが昔あったらしい、同じ会社の人に教えてもらった。)

現在は、非可逆圧縮の方式が主流のため、本実験でも同様の圧縮方式をベースに実現します。
本手法で選択したモザイクの手法は次のとおりです。

  1. 黒いモザイク・・・画面の一部が黒いモザイクとなる。
  2. 中央値を用いたモザイク・・・ぼかしたい箇所をmedian filterにする。
  3. Gaussian Filterを使ったモザイク・・・ぼかしたい箇所にGaussian Filterを使う。

今回は実用性を重視するため、部分画像への適用も試みます。
これは、全体を隠さなければならないケースは少なく
部分的に見てはいけないものとして隠していることもあるからです。

乱数による埋込も画像に対し、完成品があまりに不自然なので利用しません。

モザイク処理アルゴリズムの実装

本処理はPythonで実装します。

ランダムで64枚出力した画像は次の通りです。
f:id:tereka:20171108212215p:plain

データセットの収集

本画像処理で用いるデータセットを収集します。
今回はラブライブのデータを利用してモザイク除去の実験を行います。

Googliser

GoogliserはGoogle画像検索を用いて、画像を取得するソフトウェアです。
このソフトウェアを利用してラブライブのデータを集めます。

github.com

googliserはcloneして内部にあるgoogliser.shを動作させれば実行可能です。

./googliser.sh -p "矢澤にこ" --number 1000

モザイク処理外しのアルゴリズム

モザイク処理外し

はじめの方で一般的なモザイクが非可逆圧縮であると説明しました。
そのため、厳密にはモザイク処理を外すのではなく、モザイクがかかった箇所を補完する処理を行います。

この補完処理ですが、生成モデルで利用されるGANとSemantic Segmentationの技術を応用して実現します。
SIGGRAPH 2017で発表のあった「Globally and Locally Consistent Image Completion」を参考に実装します。

Globally and Locally Consistent Image Completion

Globally and Locally Consistent Image Completionは
Deep Learningを利用した画像補完アルゴリズムです。

f:id:tereka:20171216155459p:plain

最初にGeneratorを学習し、次にDiscriminatorを学習し、
最後にGANの方式でGenerator, Discriminatorの両方を学習し、
高速マーチング法と呼ばれるアルゴリズムで周囲を補完します。

内部でいくつか細かい手法はあるのですが、ネットワークの構造をそのまま利用し、
諸々の処理の実装をしていません。(高速マーチング法)

Generatorを学習する際には復元画像を生成し、Mask部の誤差により更新します。
解像度を落とさず、DilatedConvolutionで大域的な特徴を利用する箇所と後段のDiscriminatorでは、
全体の画像と部分画像(マスク)を入力とし、判定しています。

Chainerで構築したモザイク外しアルゴリズム

さて、作ってみました。結構長くなったので全体は後ほどgithubへ置いておきます。
モデルとアップロード部については次で記述します。
コードはあまりきっちり記載していないので、綺麗にするためにはもう少し改良が必要です。

画像は128x128で入力しています。(処理の都合)

Generator

まずは、Generatorのコードです。
ここで肝となるのは、Dilated Convolutionを使い、大域的な特徴を見ていること
そして、誤差計算部(__call__)の引数にmskを入れています。
マスクを共に入力とした場合にモザイク領域以外の誤差を0にしています。

class GLCICGenerator(chainer.Chain):
    def __init__(self):
        super(GLCICGenerator, self).__init__()
        with self.init_scope():
            self.conv0 = L.Convolution2D(4, 64, ksize=3, stride=1, pad=1)
            self.bn0 = L.BatchNormalization(64)

            self.conv1_1 = L.Convolution2D(64, 128, ksize=3, stride=2, pad=1)
            self.bn1_1 = L.BatchNormalization(128)
            self.conv1_2 = L.Convolution2D(128, 128, ksize=3, stride=1, pad=1)
            self.bn1_2 = L.BatchNormalization(128)

            self.conv2_1 = L.Convolution2D(128, 256, ksize=3, stride=2, pad=1)
            self.bn2_1 = L.BatchNormalization(256)
            self.conv2_2 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1)
            self.bn2_2 = L.BatchNormalization(256)
            self.conv2_3 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1)
            self.bn2_3 = L.BatchNormalization(256)
            self.conv2_4 = L.DilatedConvolution2D(256, 256, ksize=3, stride=1, pad=2, dilate=2)
            self.bn2_4 = L.BatchNormalization(256)
            self.conv2_5 = L.DilatedConvolution2D(256, 256, ksize=3, stride=1, pad=4, dilate=4)
            self.bn2_5 = L.BatchNormalization(256)
            self.conv2_6 = L.DilatedConvolution2D(256, 256, ksize=3, stride=1, pad=8, dilate=8)
            self.bn2_6 = L.BatchNormalization(256)
            self.conv2_7 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1)
            self.bn2_7 = L.BatchNormalization(256)
            self.conv2_8 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1)
            self.bn2_8 = L.BatchNormalization(256)

            self.deconv2_1 = L.Deconvolution2D(256, 128, ksize=4, stride=2, pad=1)
            self.debn2_1 = L.BatchNormalization(128)
            self.deconv2_2 = L.Convolution2D(128, 128, ksize=3, stride=1, pad=1)
            self.debn2_2 = L.BatchNormalization(128)

            self.deconv1_1 = L.Deconvolution2D(128, 128, ksize=4, stride=2, pad=1)
            self.debn1_1 = L.BatchNormalization(128)
            self.deconv1_2 = L.Convolution2D(128, 64, ksize=3, stride=1, pad=1)
            self.debn1_2 = L.BatchNormalization(64)

            self.deconv0 = L.Convolution2D(64, 3, ksize=3, stride=1, pad=1)

    def predict(self, x):
        h = F.relu(self.bn0(self.conv0(x)))
        h = F.relu(self.bn1_1(self.conv1_1(h)))
        h = F.relu(self.bn1_2(self.conv1_2(h)))

        h = F.relu(self.bn2_1(self.conv2_1(h)))
        h = F.relu(self.bn2_2(self.conv2_2(h)))
        h = F.relu(self.bn2_3(self.conv2_3(h)))
        h = F.relu(self.bn2_4(self.conv2_4(h)))
        h = F.relu(self.bn2_5(self.conv2_5(h)))
        h = F.relu(self.bn2_6(self.conv2_6(h)))
        h = F.relu(self.bn2_7(self.conv2_7(h)))
        h = F.relu(self.bn2_8(self.conv2_8(h)))

        h = F.relu(self.debn2_1(self.deconv2_1(h)))
        h = F.relu(self.debn2_2(self.deconv2_2(h)))
        
        h = F.relu(self.debn1_1(self.deconv1_1(h)))
        h = F.relu(self.debn1_2(self.deconv1_2(h)))

        return F.sigmoid(self.deconv0(h))

    def __call__(self, x, msk=None, t=None):
        h = self.predict(x)
        if msk is not None:
            h = msk * h
            t = msk * t
            loss = F.mean_squared_error(h, t)
            chainer.report({'loss': loss}, self)
            return loss
        else:
            return h
Discriminator

次にDiscriminatorです。特徴は入力が全体の画像とモザイク画像を中心とする
64x64の画像を入力としています。最後に結合し、出力を算出しています。

class GLCICDiscriminator(chainer.Chain):
    def __init__(self):
        super(GLCICDiscriminator, self).__init__()
        with self.init_scope():
            self.c0_l = L.Convolution2D(3, 32, 3, 2, 1)
            self.bn0_l = L.BatchNormalization(32)
            self.c1_l = L.Convolution2D(32, 64, 3, 2, 1)
            self.bn1_l = L.BatchNormalization(64)
            self.c2_l = L.Convolution2D(64, 128, 3, 2, 1)
            self.bn2_l = L.BatchNormalization(128)
            self.c3_l = L.Convolution2D(128, 256, 3, 2, 1)
            self.bn3_l = L.BatchNormalization(256)
            self.c4_l = L.Convolution2D(256, 512, 3, 2, 1)
            self.bn4_l = L.BatchNormalization(512)

            self.c0_g = L.Convolution2D(3, 16, 3, 2, 1)
            self.bn0_g = L.BatchNormalization(16)
            self.c1_g = L.Convolution2D(16, 32, 3, 2, 1)
            self.bn1_g = L.BatchNormalization(32)
            self.c2_g = L.Convolution2D(32, 64, 3, 2, 1)
            self.bn2_g = L.BatchNormalization(64)
            self.c3_g = L.Convolution2D(64, 128, 3, 2, 1)
            self.bn3_g = L.BatchNormalization(128)
            self.c4_g = L.Convolution2D(128, 256, 3, 2, 1)
            self.bn4_g = L.BatchNormalization(256)
            self.c5_g = L.Convolution2D(256, 512, 3, 2, 1)
            self.bn5_g = L.BatchNormalization(512)

            self.fc = L.Linear(None, 1)

    def __call__(self, x1, x2):
        h1 = F.leaky_relu(self.bn0_l(self.c0_l(x1)))
        h1 = F.leaky_relu(self.bn1_l(self.c1_l(h1)))
        h1 = F.leaky_relu(self.bn2_l(self.c2_l(h1)))
        h1 = F.leaky_relu(self.bn3_l(self.c3_l(h1)))
        h1 = F.leaky_relu(self.bn4_l(self.c4_l(h1)))

        h2 = F.leaky_relu(self.bn0_g(self.c0_g(x2)))
        h2 = F.leaky_relu(self.bn1_g(self.c1_g(h2)))
        h2 = F.leaky_relu(self.bn2_g(self.c2_g(h2)))
        h2 = F.leaky_relu(self.bn3_g(self.c3_g(h2)))
        h2 = F.leaky_relu(self.bn4_g(self.c4_g(h2)))
        h2 = F.leaky_relu(self.bn5_g(self.c5_g(h2)))

        concat_h = F.concat([h1, h2])
        return self.fc(concat_h)
Updater

最後に更新用のUpdaterです。
このUpdaterはDiscriminator更新とGAN更新用です。
本体はupdate_core関数になります。update_core部では次のことをしています。

  1. Discriminatorの誤差に必要な情報を計算(オリジナル画像)
  2. Generatorで画像を生成
  3. Discriminatorの誤差に必要な情報を計算(生成画像)
  4. updateで更新

メソッド名とその説明を次に掲載します。

メソッド名 説明
loss_dis 識別器(Discriminator)を更新
loss_gen 生成器(Generator)を更新
extract_img モザイク部近辺の画像を切り取るメソッド
extract_mosaic_area モザイク部近辺の画像を切り取るメソッド(バッチ的に処理する部分)
update_core 更新用の関数を呼び出すコア部分
class GLCICUpdater(chainer.training.StandardUpdater):
    def __init__(self, is_gen_training=True, alpha=4e-4, *args, **kwargs):
        self.gen, self.dis = kwargs.pop('models')
        self.is_gen_training = is_gen_training
        self.alpha = alpha
        super(GLCCICUpdater, self).__init__(*args, **kwargs)

    def loss_dis(self, dis, y_fake, y_real):
        batchsize = len(y_fake)
        L1 = F.sum(F.softplus(-y_real)) / batchsize
        L2 = F.sum(F.softplus(y_fake)) / batchsize

        loss = (L1 + L2) * self.alpha
        chainer.report({'loss': loss}, dis)
        return loss

    def loss_gen(self, gen, y_fake, x_fake, img_batch_variable, masks):
        batchsize = len(y_fake)
        h = masks * x_fake
        t = masks * img_batch_variable
        abs_pixel_loss = F.mean_squared_error(h, t)
        loss = (F.sum(F.softplus(-y_fake)) * self.alpha) / batchsize + abs_pixel_loss
        chainer.report({'loss': loss, 'pixel_loss': abs_pixel_loss}, gen)
        return loss

    def extract_img(self, img, bbox):
        while True:
            min_h = max(min(bbox[3], 127) - 64, 0)
            max_h = min(bbox[2], 63)

            min_w = max(min(bbox[1], 127) - 64, 0)
            max_w = min(bbox[0], 63)

            start_h = random.randint(min_h, max_h)
            end_h = start_h + 64
            start_w = random.randint(min_w, max_w)
            end_w = start_w + 64

            if start_h >= 0 and start_w >= 0 and end_w < img.shape[1] and end_h < img.shape[2]:
                return img[:, start_h: end_h, start_w: end_w]

    def extract_mosaic_area(self, images, bboxs):
        mosaic_region_imgs = []
        for fake_variable, bbox_variable in zip(images.data, bboxs):
            fake = chainer.cuda.to_cpu(fake_variable)
            bbox = chainer.cuda.to_cpu(bbox_variable)
            mosaic_region_img = self.extract_img(fake, bbox).transpose((1, 2, 0))
            mosaic_region_imgs.append(cv2.resize(mosaic_region_img, (64, 64)).transpose((2, 0, 1)))
        return mosaic_region_imgs

    def update_core(self):
        if self.is_gen_training:
            gen_optimizer = self.get_optimizer('gen')
        dis_optimizer = self.get_optimizer('dis')

        batch = self.get_iterator('main').next()
        img_batch, mosaic_batch_imgs, img_with_mask_batch, bbox_batch, masks = self.converter(batch, self.device)
        img_batch_variable = Variable(img_batch)
        x_real = Variable(img_with_mask_batch)
        xp = chainer.cuda.get_array_module(x_real.data)

        gen, dis = self.gen, self.dis

        region_real_images = self.extract_mosaic_area(img_batch_variable, bbox_batch)
        region_real_images_variable = Variable(xp.asarray(region_real_images))
        y_real = dis(region_real_images_variable, img_batch_variable)  # cut off image
        x_fake = gen(x_real)

        region_fake_images = self.extract_mosaic_area(x_fake, bbox_batch)
        region_fake_images_variable = Variable(xp.asarray(region_fake_images))
        y_fake = dis(region_fake_images_variable, x_fake)

        dis_optimizer.update(self.loss_dis, dis, y_fake, y_real)
        if self.is_gen_training is True:
            gen_optimizer.update(self.loss_gen, gen, y_fake, x_fake, img_batch_variable, masks)

結果

Generator

まずは、Generator部を利用しました。
Googliserで画像は収集し、その中から一部をテスト用としたので、検索が被っていれば重複の可能性があります。ご了承ください。

1epochの画像 何も表現できていません。
f:id:tereka:20171225212515j:plain:w640,h640

150epoch 少しずつ表現ができてきた?
f:id:tereka:20171225212923j:plain:w640,h640

400epoch あんまり変わらない。
f:id:tereka:20171225212953j:plain:w640,h640

GAN

そして、GANを利用した生成処理を実施します。
1 epoch 表現が残念なところからスタート
f:id:tereka:20171225213334j:plain:w640,h640

150epoch
f:id:tereka:20171225213434j:plain:w640,h640

おまけ

少しおもしろいのがデバッグ用画像です。
このデバッグ用画像はGeneratorの出力をそのまま表示している画像で、
元画像での上書きも何もしていません。

Generatorのみ学習した場合
f:id:tereka:20171225213716j:plain:w640,h640

GANの場合
f:id:tereka:20171225220845j:plain:w640,h640

入力されていないと思われるラブライブ画像(サンシャインから取ってきた)

元画像1
f:id:tereka:20171225233213j:plain:w256,h256
大量に生成したモザイク+復元画像1
f:id:tereka:20171225233204j:plain:w640,h640

元画像2
f:id:tereka:20171225233532j:plain:w256,h256

大量に生成したモザイク+復元画像2
f:id:tereka:20171225233521j:plain:w640,h640

思ったよりも綺麗に生成されていますね。

最後に

妄想力を完全に可視化するにはまだまだかかるようです。
結構ネタとして面白かったのでちょっと画像大きくしてやってみるのも面白いかなぁと思いました。
※何かバグや違い、こうすれば良い等あれば教えてください。

画像のDataAugmentationで最速のライブラリを探してみた

皆さんこんにちは
お元気ですか。年末に向けて燃え尽きようとしています。

OpenCVアドベントカレンダー第22日です。

qiita.com

今回、PythonのDataAugmentationで最速の方法を探してみます。
画像処理のDeepLearningでは、頻繁にDataAugmentationが使われています。

このData Augmentationは画像に結果がない程度に変換を加え、
ニューラルネットワークに入力する手法です。

以前、こんな資料を作りました。

www.slideshare.net

DataAugmentationにも様々な手法がありますが、次の処理する場合が非常に多いです。

  1. 画像をファイルから取得する。
  2. リサイズ
  3. アフィン変換
  4. 左右反転

この処理ですが、入力時に一定の確率で実行されます。
そのため、この処理が遅い場合には性能のボトルネックになります。
そのため、実装を高速化することは学習時間の短縮に非常に有用となります。

GPUが関わる処理で学習を高速化したい場合はCPU部も高速化することが必要でしょう。

速度を計測するにあたり、使用したライブラリをご紹介

OpenCV

当記事のアドベントカレンダーの掲載先となるフレームワーク
かつ、最も画像処理で有名なライブラリである言わずもがなOpenCVです。
Wikipediaの概要では、次のように記載されています。

画像処理・画像解析および機械学習等の機能を持つC/C++JavaPythonMATLAB用ライブラリ

opencv.org

Scikit-image

私個人はこれを推しています。
Pythonで完結するため、非常にインストールが楽です。
こちらも相当の人が使っており、サンプルも非常に多いです。

scikit-image: Image processing in Python — scikit-image

Pillow

このライブラリのサンプルを見たことある人はかなりいるのではないでしょうか?
Pythonの画像処理ライブラリで、かつて存在したPython Imaging Library (PIL)の fork プロジェクトです。

普段、Scikit-imageを利用している私は殆ど使ったことがありませんが、今回試しに使ってみました。

python-pillow.org

ぶっちゃけ全部画像処理ライブラリとしかいっていない

計測

では、早速計測を行います。
本手法における計測はtimeitを利用して実施します。

対象となる画像は皆さん大好きLennaさん(高225x幅225)です。
f:id:tereka:20171004005907j:plain

※ライブラリによって実装方法が異なるので、結果が多少ことなることがあるかもしれません。
 その点は確認して、利用してください。

画像読み込み

画像読み込みとすると非常に曖昧のため、今回は次の定義とします。

  1. 画像をファイルから読み込む
  2. 0-1へ画像を正規化
  3. float32に変換する
OpenCV

ソースコード

%timeit cv2.imread("./lenna.jpeg").astype(np.float32) / 255.0
2.06 ms ± 39.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
Scikit-Image

ソースコード

import skimage.io
%timeit skimage.io.imread("./lenna.jpeg")
2.1 ms ± 40.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
PIL

ソースコード

from PIL import Image
def load_img(path):
    with open(path, 'rb') as f:
        with Image.open(f) as img:
            return img.convert('RGB')

%timeit load_img("./lenna.jpeg")
2.02 ms ± 61.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

画像のリサイズ

続いて画像のリサイズです。
ニューラルネットワークの入力は固定長になる場合が多いので、基本的にはどこかでリサイズ処理が必要になり、
ImageNetを利用する場合は必須に近い技術となるでしょう。
そのため、この部分の速度を改善できるとDataAugmentationに非常に有用な手法となります。

f:id:tereka:20171221233331j:plain

OpenCV

ソースコード

%timeit cv2.resize(img,(128,128))
271 µs ± 4.26 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Scikit-image

ソースコード

%timeit skimage.transform.resize(img, (128,128))
4.32 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
PIL

ソースコード

%timeit p_img.resize((128,128))
23.2 µs ± 850 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

アフィン変換を行う

アフィン変換を実施します。
回転、平行移動、スケール変化、引き伸ばしをこのアフィン変換で実現できます。
DataAugmentationにおいても非常にメジャーな技術と言えるでしょう。
時間の都合もあり、条件が若干ばらばらですが、アフィン変換の計測をしました。

全て微妙に違う画像ですが、こんな感じで変換を行っています。

f:id:tereka:20171222005403j:plain

OpenCV
import cv2
def transform_opencv(img):
    size = int(img.shape[0] / 2)
    affine = cv2.getRotationMatrix2D((size, size), 45,  0.8)
    affine[0][2] += 10
    affine[1][2] += 15
    img_afn = cv2.warpAffine(img, affine, img.shape[0:2],flags=cv2.INTER_LINEAR)

%timeit transform_opencv(img)
771 µs ± 139 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Scikit-Image
def tranform_skimage(img):
    rotation = 45
    rotation = np.deg2rad(rotation)
    tform = AffineTransform(scale=(1.3, 1.3), rotation=rotation,
                            shear=1.0,
                            translation=(3, 3))
    warped_img = warp(img, tform)

%timeit tranform_skimage(img)
4.69 ms ± 72.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
PIL
from PIL import Image

def load_img(path):
    with open(path, 'rb') as f:
        with Image.open(f) as img:
            return img.convert('RGB')

def ScaleRotateTranslate(image, angle, center = None, new_center = None, scale = None,expand=False):
    if center is None:
        return image.rotate(angle)
    angle = -angle/180.0*math.pi
    nx,ny = x,y = center
    sx=sy=1.0
    if new_center:
        (nx,ny) = new_center
    if scale:
        (sx,sy) = scale
    cosine = math.cos(angle)
    sine = math.sin(angle)
    a = cosine/sx
    b = sine/sx
    c = x-nx*a-ny*b
    d = -sine/sy
    e = cosine/sy
    f = y-nx*d-ny*e
    return image.transform(image.size, Image.AFFINE, (a,b,c,d,e,f), resample=Image.BICUBIC)

def scale():
    image =load_img("./lenna.jpeg")
    transformed = ScaleRotateTranslate(image, 15, None, (0, 0), scale=0.9)

%timeit scale()
3.03 ms ± 83 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

左右反転

左右反転を行います。処理後の画像は次の通り

f:id:tereka:20171221232633j:plain

OpenCV
%timeit cv2.flip(img,0)
13 µs ± 162 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
Numpyの方式
%timeit img[:, ::-1]
404 ns ± 12.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
PIL
%timeit img.transpose(p_img.FLIP_LEFT_RIGHT)
56.5 µs ± 4.97 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

まとめ

OpenCV強いと書こうと思ったらPILの方が速い場面があった。
OpenCVの方が使いやすいのですが・・・

ライブラリ 画像の読み込み リサイズ アフィン変換 フリップ
OpenCV 2.06ms 271 µs 771 µs 13 µs
Scikit-image 2.1 ms 4.32 ms 4.69 ms なし(numpyで実施)
PIL 2.02ms 23.2 µs 3.03 ms 56.5 µs
Numpy(一部) なし なし なし 404 ns

最後に

OpenCVが想像以上にScikit-imageより速いがPILの方が速い。そのため、もしこの処理で困っているならば
OpenCV、もしくは、PILを利用すると高速化できそうです。

もちろん、状況次第によって変化するかもしれませんが、
この結果を参考に良い実装をしてみてください。

日本語自然言語処理のData Augmentation

皆さんこんにちは
お元気ですか。週末の発表資料も作っています。

本記事は自然言語処理アドベントカレンダー第13日です。

qiita.com

画像処理ではデータをアフィン変換などで変形して、
画像を拡張する処理(=Data Augmentation)が知られています。
変換などをかけて過学習を防ぐ役割が1つとしてあります。

今回は、自然言語処理でもData Augmentationを実現したいと思います。

テキストのData Augmentationの意義

自分でデータセットを作る場合に、全てを網羅して1つ1つの単語が変わった場合を
作り上げるのは非常に困難で、時間がかかります。

そのため、一定の問題ない範囲(=結果が変わらない範囲)で
データを拡張する試みをすることで精度やロバストな学習ができる可能性があります。

WordNetの説明

Wikipediaより

WordNet(わーどねっと)は英語の概念辞書(意味辞書)である。WordNetでは英単語がsynsetと呼ばれる同義語のグループに分類され、簡単な定義や、他の同義語のグループとの関係が記述されている。 WordNetの目的は直感的に使うことのできる辞書とシソーラスが組み合わされた成果物を作ること、および自動的文書解析や人工知能のアプリケーションの実現を支援することにある。WordNetのデータベースやソフトウェアはBSDライセンスによって公開され、自由にダウンロードして用いることができる。データベースはオンラインで参照することもできる。

WordNetは日本語にもあり、国立研究開発法人情報通信研究機構NICT)が開発を進めています。
単語と単語の関係性、例えば、類義語や上位語などがこのWordNetからわかります。

類義語は病気と風邪、上位語の関係が牛乳と乳製品のような関係になります。

WordNetの環境を構築する。

まずは、WordNet(日本語)をダウンロードします。
http://nlpwww.nict.go.jp/wn-ja/

ダウンロードしたファイルを展開すると「wnjpn.db」が展開されるので
このファイルを使ってWordNetの中身を確認します。

WordNetを使ってデータを拡大する。

さて、ここからが本題です。WordNetを使ってデータセットを人工的に生成します。

文書拡張アルゴリズムの試み

まずはサンプルを用意します。元々のボットを拡張用に少し修正を加えている文章です。

そんな、とてもきつい風邪だから仕方ないよ。
名詞の類義語置換

まずは形態素解析で区切り、解析することを目指します。
そこで得られた単語をベースに他の単語で置換します。

そんな、とてもきつい風邪だから仕方ないよ。
そんな	連体詞,*,*,*,*,*,そんな,ソンナ,ソンナ
、	記号,読点,*,*,*,*,、,、,、
とても	副詞,助詞類接続,*,*,*,*,とても,トテモ,トテモ
きつい	形容詞,自立,*,*,形容詞・アウオ段,基本形,きつい,キツイ,キツイ
風邪	名詞,一般,*,*,*,*,風邪,カゼ,カゼ
だ	助動詞,*,*,*,特殊・ダ,基本形,だ,ダ,ダ
から	助詞,接続助詞,*,*,*,*,から,カラ,カラ
仕方	名詞,ナイ形容詞語幹,*,*,*,*,仕方,シカタ,シカタ
ない	助動詞,*,*,*,特殊・ナイ,基本形,ない,ナイ,ナイ
よ	助詞,終助詞,*,*,*,*,よ,ヨ,ヨ
。	記号,句点,*,*,*,*,。,。,。
EOS
類義語

上記データを類義語を使って置換します。
ただ、単純に全ての類義語を検索することに意味はなさそうなので絞ります。
名詞は非常に有効そうなので、名詞に絞込み別の単語に置き換えます。

WordNetから類義語を取得します。類義語は以下のコードを用いれば取得可能です。
wordテーブルからwordのidを取得します。
そして、次にsenseからwordが所属するsynset(類義語のネットワーク)を検索します。
最後に、senseから同じネットワークに存在する単語を取得し、類義語一覧を獲得しています。

def get_synonym_word(word):
    cur = conn.execute("select * from word where lemma=?", (word,))
    word_list = [row for row in cur]
    synonym_list = []
    for word in word_list:
        cur = conn.execute("select * from sense where wordid=?", (word[0],))
        synnet_list = [row for row in cur]
        for synnet in synnet_list:
            cur = conn.execute("select * from sense, word where synset = ? and word.lang = 'jpn' and sense.wordid = word.wordid;", (synnet[0],))
            synonym_list += [row for row in cur]
    return synonym_list

最初に取り上げた文章には「病気」の名詞があります。
その類義語は次のようになります。

感冒
風邪ひき
風邪
咳気
上位語への置換

WordNetは上位の言葉への言葉も登録されているため、その言葉を使う置換方式も可能そうに見えます。
上位語は次の方式で検索できます。因みに病気だと、'病み煩い', '疾病', '杜撰'が検出されます。難しい。
こちらの内容を参考にし、実装しています。

A frontend of WordNet-Ja database file (sqlite3 format) which is available on http://nlpwww.nict.go.jp/wn-ja/ · GitHub

from collections import namedtuple

Word = namedtuple('Word', 'wordid lang lemma pron pos')

def getWords(lemma):
  words = []
  cur = conn.execute("select * from word where lemma=?", (lemma,))
  row = cur.fetchone()
  while row:
    words.append(Word(*row))
    row = cur.fetchone()
  return words

def getWord(wordid):
  cur = conn.execute("select * from word where wordid=?", (wordid,))
  return Word(*cur.fetchone())
 
Sense = namedtuple('Sense', 'synset wordid lang rank lexid freq src')

def getSenses(word):
  senses = []
  cur = conn.execute("select * from sense where wordid=?", (word.wordid,))
  row = cur.fetchone()
  while row:
    senses.append(Sense(*row))
    row = cur.fetchone()
  return senses

def getSense(synset, lang='jpn'):
  cur = conn.execute("select * from sense where synset=? and lang=?",
      (synset,lang))
  row = cur.fetchone()
  if row:
    return Sense(*row)
  else:
    return None

SynLink = namedtuple('SynLink', 'synset1 synset2 link src')

def getSynLinks(sense, link):
  synLinks = []
  cur = conn.execute("select * from synlink where synset1=? and link=?", (sense.synset, link))
  row = cur.fetchone()
  while row:
    synLinks.append(SynLink(*row))
    row = cur.fetchone()
  return synLinks

def abstract_word(lemma):
    result = []
    for word in getWords(lemma):
        for sense in getSenses(word):
            if sense.src != 'hand': continue
            for synlink in getSynLinks(sense, 'hype'):
                abst_sense = getSense(synlink.synset2)
                if abst_sense and word.wordid != abst_sense.wordid:
                    result.append(getWord(abst_sense.wordid).lemma)
    return result
副詞・形容詞の削除

副詞と形容詞を削除します。
副詞と形容詞は強調する表現になるため削除してもあまり意味はなさそうです。
文章内だと、「とても」と「きつい」になります。

http://www.anlp.jp/proceedings/annual_meeting/2017/pdf_dir/P10-4.pdf

※自動的に付け加える方法は要検討ですね。

実際にどの程度データが増えるのかやってみた。

さて、実際に作ります。コードとしての手順は次の通りです。

  1. 形態素解析を行う。
  2. 品詞を抽出し適切な処理を行う。(これまでの処理)
  3. 全てのパタンを列挙する。

これらを使ったDataAugmentationのコードは次の通りです。

def data_augmentation_for_text(sentence):
    sentence_list_origin = []
    nodes = word_and_class(sentence)
    get_word(nodes,sentence_list=sentence_list_origin)
    return sentence_list_origin

def word_and_class(doc):
    doc_ex = doc
    doc_ex = doc
    print (doc_ex)

    # Execute class analysis
    
    result = tagger.parseToNode(doc_ex)

    # Extract word and class
    word_class = []
    while result:
        word = result.surface
        clazz = result.feature.split(',')[0]
        if clazz != u'BOS/EOS':
            word_class.append((word, clazz))
        result = result.next

    return word_class

def get_word(nodes, index=0,sentence="", sentence_list=[]):
    if len(nodes) == index:
        sentence_list.append(sentence)
        return None
    
    next_index = index + 1
    if nodes[index][1] == "副詞" or nodes[index][1] == "形容詞":
        get_word(nodes, index=next_index, sentence=sentence, sentence_list=sentence_list)
        get_word(nodes, index=next_index, sentence=sentence + nodes[index][0], sentence_list=sentence_list)
    
    elif nodes[index][1] == "名詞":
        candidate_words = get_synonym(nodes[index][0] )
        candidate_words += abstract_word(nodes[index][0] )
        get_word(nodes, next_index, sentence + nodes[index][0], sentence_list=sentence_list)
        for candidate_word in candidate_words:
            get_word(nodes, next_index, sentence + candidate_word, sentence_list=sentence_list)
    else:
        get_word(nodes, next_index, sentence + nodes[index][0], sentence_list=sentence_list)

結果

そんな、とてもきつい風邪だから仕方ないよ。
そんな、風邪だから仕方ないよ。
そんな、風邪だから流儀ないよ。
そんな、風邪だから遣り口ないよ。
そんな、風邪だから手ないよ。
そんな、風邪だから仕様ないよ。
そんな、風邪だから筆法ないよ。
そんな、風邪だからスタイルないよ。
そんな、風邪だから仕樣ないよ。
そんな、風邪だから様式ないよ。
そんな、風邪だからやり口ないよ。

なんか意味変わっていないか!?といった部分もありますね。

あなたのことが好き
あなたのことが好き
あなたのことが好み
あなたのことがお好
あなたのことが御好み
あなたのことがお好み
あなたのことが御好
あなたのことが好き
あなたのことが温かさ
あなたのことが慈しみ

少し近い気がします。何か日本語的にピンとこない内容もありますが、
若干誤字っぽければこうなるのでしょうか。

考察

意味が変わっている単語があり、もう少し検討の余地はありそうです。
もう少し単語の形を捉えることが必要でしょうか。

WebDNNのサンプルとコードの解説に挑戦

皆さんこんにちは。
お元気ですか。師走の12月らしく締め切りに追われています。

この記事は「Deep Learning フレームワークざっくり紹介 Advent Calendar 2017」第7日目です。

qiita.com

DeepLearningフレームワークの1つ、WebDNNのご紹介をします。
このフレームワークを調べたきっかけとして、「MakeGirls.moe」があります。
MakeGirls.moeは萌画像生成のWebサービスで、WebDNNを使用して提供しているようです。

make.girls.moe

WebDNN

WebDNNは東京大学 原田・牛久研究室が作成した深層学習モデル(DNN)を
ウェブブラウザ上で高速実行するためのオープンソースフレームワークです。

次のサイトのアワードに掲載されるほど、良いソフトウェアでもあります。

Open source software Award 2017 for WebDNN at ACM Multimedia 2017

DNNは顕著な成果を様々なタスクであげていますが、度々、計算コストが問題になります。
サーバ上でDNNの全ての計算を行う場合、様々なユーザが送信するリクエストは多数あります。
これを処理しきるにはそれなりのスペックのマシン及び台数が求められます。(多分、個人では無理)

WebDNNはウェブブラウザ上での実行を前提とし、様々な計算の最適化がされているようです。

github.com

WebDNNでWebサイトを構築するまでの手順

WebDNNはいくつかの有名なフレームワークに対応しています。
公式で確認ができているのはChainer, Kerasでしょうか。

KerasからWebDNN用のオブジェクトに変換してそれを利用し、Webサイトで動かすまでやってみます。

KerasからWebDNNへ変換する

まずは、Pretrainingで有名なResNet50を取得します。
KerasからResNet50を取得し、まずはディスクに保存します。
下記の実行は「example/resnet/」配下で行ってください。
(短いのでインタプリタでの実行で良いと思います)

from keras.applications import resnet50
model = resnet50.ResNet50(include_top=True, weights='imagenet')
model.save("resnet50.h5")

次にWebDNNで実行するモデル形式へ変換します。実行コマンドは次の通りです。

python ../../bin/convert_keras.py resnet50.h5 --input_shape '(1,224,224,3)' --out output_keras

Kerasを使い、Web上で実行する。

さて、ここからモデルを画面上で使います。
サンプルのサーバを立ち上げてみます。
サーバを起動します。setup.pyと同じ箇所で次のコマンドを実行します。

python -m http.server

実行後に次のURLにアクセスします。
(README.mdと異なることに注意、パスはexample配下をチェックして適切なパスを使いましょう)

http://localhost:8000/example/resnet/

アクセス後に次の画面が出てきます。
この画面でRunボタンを押すことで、WebDNNで変換されたモデルの実行が可能です。

f:id:tereka:20171203002625p:plain

さて、ここから先はWebDNNのjavascriptを見てみます。

ソースコード

Python(bin/convert_keras.py)

Kerasによる変換の解説になります。
まずは、KerasConverterを使います。このKerasConverterにより、
入力したモデルをWebDNN IR Graphへと変換します。

そして、この変換したWebDNN IR Graphとバックエンド(webgpu,webgl,webassembly,fallback)
とencodingを入力して与えると変換されたデータの出力を行います。
WebDNNのREADME曰く「--encoding eightbit」と引数に与えるとモデルが1/5サイズになるとのこと。

    backends = args.backend.split(",")
    for i, backend in enumerate(backends):
        console.stderr(f"[{path.basename(__file__)}] BackendName: {console.colorize(backend, console.Color.Cyan)}")
        try:
            graph_exec_data = generate_descriptor(backend, graph, constant_encoder_name=args.encoding)
            graph_exec_data.save(output_dir)
        except Exception as ex:
            if flags.DEBUG:
                raise ex

Javascript

ヘッダー

まずは、index.htmlを確認します。
ヘッダーとしてインポートされているスクリプトで必要なのは、
「../../dist/webdnn.js」と「script.js」です。
独自で開発する場合には「../../dist/webdnn.js」をインポートする必要があります。

<head>
    <title>ResNet-50 conversion WebDNN example</title>
    <meta charset="utf-8">
    <script src="../../lib/inflate.min.js"></script>
    <script src="../../dist/webdnn.js"></script>
    <script src="../data/imagenet_labels.js"></script>
    <script src="script.js"></script>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-beta/css/bootstrap.min.css">
</head>
scrpit.js

まず、実行時には次のコードが実行されます。
ここではモデルと画像を読み込み計算結果を返します。

prepare_runでモデルをファイルから読み込むような挙動をしています。
次にrunner#getInputViewsで計算する画像をセットします。

最後にrunner.run();で予測をする計算を行い、getOutputViewsで計算結果を取り出しています。
Chainerとその他でOrderを変化させているのは、
フレームワークによってCHW(Channel, Height,Width)とHWCの順番が異なることが理由です。

async function run() {
    let runner = await prepare_run();

    runner.getInputViews()[0].set(await WebDNN.Image.getImageArray(document.getElementById('input_image'), {
        order: getFrameworkName() === 'chainer' ? WebDNN.Image.Order.CHW : WebDNN.Image.Order.HWC,
        color: WebDNN.Image.Color.BGR,
        bias: [123.68, 116.779, 103.939]
    }));

    let start = performance.now();
    await runner.run();
    let elapsed_time = performance.now() - start;

    let out_vec = runner.getOutputViews()[0].toActual();
    let top_labels = WebDNN.Math.argmax(out_vec, 5);

    let predicted_str = 'Predicted:';
    for (let j = 0; j < top_labels.length; j++) {
        predicted_str += ` ${top_labels[j]}(${imagenet_labels[top_labels[j]]})`;
    }
    log(predicted_str);

    console.log('output vector: ', out_vec);
    log(`Total Elapsed Time[ms/image]: ${elapsed_time.toFixed(2)}`);
}

prepare_runでは、モデルをロードします。
backendとframeworkの名前で識別できるので、その名前を指定して読み込みます。
下記のコードでは非同期にモデルを読み込み、
既にモデルが存在する場合にはその読み込まれているモデルを返します。

async function prepare_run() {
    let backend_name = document.querySelector('input[name=backend]:checked').value;
    let framework_name = getFrameworkName();
    let backend_key = backend_name + framework_name;
    if (!(backend_key in runners)) {
        log('Initializing and loading model');
        let runner = await WebDNN.load(`./output_${framework_name}`, {backendOrder: backend_name});
        log(`Loaded backend: ${runner.backendName}, model converted from ${framework_name}`);

        runners[backend_key] = runner;
    } else {
        log('Model is already loaded');
    }
    return runners[backend_key];
}

最後にloadImageを紹介します。getImageArrayを使うことで、画像をurl(path)から読み込み、
画像データとして保持します。これによりCanvasに画像を埋め込みます。

async function loadImage() {
    let imageData = await WebDNN.Image.getImageArray(document.getElementById("image_url").value, {dstW: 224, dstH: 224});
    WebDNN.Image.setImageArrayToCanvas(imageData, 224, 224, document.getElementById('input_image'));

    document.getElementById('run_button').disabled = false;
    log('Image loaded to canvas');
}

最後に

これを使うとWebページでjavascriptを使い、モデルの実行ができます。
サーバ上で動作させるよりもユーザに提供しやすいので非常におすすめです。
これを使えばユーザにモデルの提供がしやすくなり、遊びで作ったツールを試してもらうことができます。

いつか、提供しよう。そうしよう

Pythonで自然言語処理のタスクをやってみる。

皆さんこんにちは
お元気ですか。アドベントカレンダー真っ盛りですね。
本日は「python Advent Calendar 2017」のアドベントカレンダー第5日です。

qiita.com

自然言語処理には様々なライブラリ(NLTKやCoreNLP)があります。
せっかくの機会として、本記事では紹介が少ないspaCyを紹介します。

spaCy

spaCyとは

spaCyはPythonの発展的な自然言語処理のライブラリです。
実際に使われていることを想定しており、英語、ドイツ語、フランス語、スペイン語に対応しています。
トークナイザーは日本語もあるとのこと(確かJanomeで動作します)。

github.com

次のリンク先には他の自然言語処理ライブラリの
アルゴリズムの観点や精度(Dependency parsing、Named entity comparison)が
載っており、他のライブラリとどのような点が違うのかを確認できます。

spacy.io

インストール

pip install spacy

spaCyで遊んでみる

spaCyですが、日本語対応が用意されています。
ただ、残念ながら日本語に対応したモデルがないため、
まだ本格的な日本語解析は難しいのかなと感じています。

それは置いておいて、本日はspaCyの機能紹介をしたいので、
既に準備されている英語のモデルを使います。

まずは、英語解析の準備をします。

import spacy
nlp = spacy.load('en')
doc1 = nlp(u"this is a pen.")

文章を単語ごとに区切る

文章を単語ごとに区切ることが可能です。

for token in doc1:
    print (token)

結果はスペースで区切られている次の通りです。

this
is
a
pen
.

文章を文ごとに分ける

簡単そうな例ですが、文章を文ごとに分解します。
英語だと、ピリオドによる分割になるでしょうか。

doc2 = nlp(u"This is a pen. That is an apple")
for sent in doc2.sents:
    print (sent)

出力結果です。「.」による分割ができています。

This is a pen.
That is an apple

固有表現抽出(Named Entity Recognizer)

固有表現抽出は文章の中から固有の表現を発見する技術です。

ent_doc = nlp("Rami Eid is studying at Stony Brook University in New York")
for ent in ent_doc.ents:
    print (ent, ent.label, ent.label_)

残念ながらNew Yorkが出力できていません。
固有表現が何かだけではなく、どんな固有表現(人なのか、組織なのか)かも抽出できています。

Rami Eid 377 PERSON
Stony Brook University 380 ORG

名詞フレーズの抽出

フレーズの抽出も可能です。

noun_chunk_test = nlp(u"Natural language processing (NLP) deals with the application of computational models to text or speech data.")
for noun_chunk in noun_chunk_test.noun_chunks:
    print (noun_chunk)

出力結果です。これもそれっぽいですね。

Natural language processing (NLP) deals
the application
computational models
text or speech data

文章間の距離を計算する。

文書のベクトルを計算します。
word2vecに類似したアルゴリズムです。実装は非常にシンプルで
apple.vectorをすれば、文書のベクトルを取得できます。
ベクトルを表示すると標準出力が長くなるので、代わりにshapeを実行してみます。

apple.vector.shape

また、2ベクトル間を計算し、類似度を算出できます。

udon = nlp(u"Udon and oranges are not similar.")
apple = nlp(u"Apples and oranges are similar. Boots and hippos aren't.")
udon.similarity(apple)

最後に

今回は自然言語処理のライブラリを紹介しました。
まだ、日本人向けには難しい状態でありますが、開発が進んでいるので、試しに使ってみてはいかがでしょうか。