私がわかりにくいと思った「Faster RCNN」のポイントの解説
皆さんこんにちは
お元気ですか。ちゃっかりKaggleで物体検出のコンペもはじまりました。
Deep Learningは相変わらず日進月歩で凄まじい勢いで進化しています。
特に画像が顕著ですが、他でも色々と進歩が著しいです。
ところで色々感覚的にやりたいことが理解できるものがありますが、
あまり勉強していなかった分野として物体検出系のアルゴリズムがあります。
所謂、Faster RCNN, SSD, Yolo、最近、Mask R-CNNが該当します。
ただ、今回は、個人的に物体検出のアルゴリズムで
なかなか調べても出てこない、あれここどうなってるんだっけ？と思った部分の解説をします。
そのため、案外変なところの解説かもしれません。
Faster RCNNの技術要素から説明しようかなとも思って作りました。
※数式、記号等の細かい説明は論文を参考にしてください。
3/7 15:15 Ancher→Anchorに修正しました
Faster RCNN
Faster RCNNは2015年に発表された論文です。
最近だと特許的な問題でも一時期盛り上がりを見せています。
Deep Learningを利用したEnd to Endで物体検出を
実施したニューラルネットワークです。
https://arxiv.org/pdf/1506.01497.pdf
※特許解説（日本語）
qiita.com
全体構成
Faster RCNNは特徴マップを抽出するConvolutional Layerと物体領域を抽出する
Region Proposal Networkに加え、分類、回帰の結果を出力するネットワークで構成されています。
※論文より引用
Conv Layerで得られた結果をRegion Proposal Networkを使い、領域を抽出し、分類しています。
特に重要なのはRegion Proposal Networkと記載されている部分で
ここが従来手法からのFaster RCNNの改善になる部分です。
Region Proposal Networkは次で説明します。
Region Proposal Network
概要・目的
Region Proposal Networkは画像内から物体領域の候補となる箇所を抽出します。
元々は「Fast RCNN」ではこの物体領域抽出にSelective Searchと呼ばれる手法を使っていたため、
物体候補領域の抽出に時間がかかっていました。
その箇所すらもEnd-to-Endで実施することで従来より高速・精度改善をしています。
全体的には次の処理があります。
- 物体の候補領域を見つけるAncherを作成する。
- （学習時）誤差を計算する。
- 候補の中からNMSなどを実施して、Region Proposal Networkでの物体の候補領域を抽出する。
その中で特に私が不明だった要素をいくつか紹介します。
Anchor
Anchorと呼ばれる領域を生成します。
一言で言えば、物体の領域を示している矩形です。
これらを画像内に一定間隔で生成します。これは後述のLoss Functionで利用されます。
Loss Function
RPN自身を更新するための誤差を計算し、
ニューラルネットワークの全体の誤差と併せて更新します。論文中の式は次の通り。
RPNの誤差は基本的には２つの要素で成り立っています。
①その領域は物体か背景であるか、②どこに領域があるかの領域の位置（詳細）を計算します。
特に私が勉強するまでイメージを持てなかったのは「そもそも教師信号をどうやってこの式に当てはめるのか」です。そもそも与えてるのバウンディングボックスとクラスだけなのですが・・といった疑問です。
教師信号の決め方ですが、物体の有無はAncherと物体のIoU（Intersection over Union）が
0.7（論文中）以上の場合、物体が存在することを示します。（positive anchor）
また、IoUが0.3以下を物体が存在しないこと（negative anchor）を示します。
平たく言ってしまえば、ある程度重なっているAncherに物体が存在するラベルが振られ、
存在しないAncherに物体が存在しないラベルが振られます。
それ以外は学習に貢献しません。
Ancherは回帰を行います。
Ancherのデータの回帰ですが、次の通り計算を行って、スケールの調整を行っています。
（細かい記号は元論文を見てください）
この値からsmooth L1と呼ばれる誤差関数を用いて最適化します。
Non-Maximum Suppression
後処理としてあるのがNon-Maximum Suppression（NMS）です。
これは同じ物体を示している矩形を抽出する手法です。
本手法を利用して、１つの矩形を残し、残りの出力を抑制します。
詳細は次のサイトが詳しいのでこちらに任せます。
これらによって得られた結果に対して、RoI Poolingを行い、分類、回帰を行うネットワークに接続します。
RoI Pooling
RoI Poolingは分類を行う層への入力を固定次元にする役割があります。
物体検出の領域は非常に可変長です。同じ画像から検出された椅子とりんごが同じサイズではないのと
同じようなものです。その得られた領域を次の分類のネットワークで処理するため、
固定次元に縮小する処理を行います。
処理の概要はこちらのサイトがわかりやすいです。
実装
実装サイトはいくつかあります。さくっと検索して発見できたサイトを掲載します。
GitHub - mitmul/chainer-faster-rcnn: Object Detection with Faster R-CNN in Chainer
GitHub - longcw/faster_rcnn_pytorch: Faster RCNN with PyTorch
GitHub - endernewton/tf-faster-rcnn: Tensorflow Faster RCNN for Object Detection
最後に
なんとなく自分が疑問に思った所を中心にまとめてみました。
ちょっとすっきりしました。間違っているところあれば、教えてください。
Jupyter Labのbetaが公開されました。操作性が向上していい感じ！
皆さんこんにちは。
お元気ですか。Advent Calendar執筆して以来、久々です。
今更ですが、あけましておめでとうございます。今年もよろしくお願いいたします。
いつものようにTwitterを見ていると
以前紹介したJupyter Labのbetaがリリースとのことで、次の記事が回ってきました。
せっかくなのでまた、お試しで使ってみました。
※Alpha版を試した記事はこちら
nonbiri-tereka.hatenablog.com
使ってみた
インストール
インストールは簡単にできます。
condaの場合
conda install -c conda-forge jupyterlab
pipの場合
pip install jupyterlab
起動
起動します。起動方法も簡単です。
jupyter lab
デフォルトの設定であれば、http://localhost:8888/labへアクセスします。
アクセスをすると若干のロードを待ちます。その後、次の画面になります。
過去のと比べてだいぶリッチに進化しており、非常に見やすい感じになっています！
最後に
便利そうなので、より、使ってみます！
クリスマスにChainerを使って妄想力を可視化した。
皆さんこんにちは
お元気ですか。やっと書き切りました。
実は今年ももう少しです。
昨年度はカノジョを作成し、その前は友利奈緒を真面目に解析しています。
いやぁ時の流れは早いものです。
これを踏まえ、今年は何をしようか考えました。
Chainer Advent Calendar 25日目で、皆様の妄想力を具現化したいと思います。
妄想について
さて、考えてみて欲しい。妄想というものを
画像に不自然に暗い箇所、何か見にくいなぁと思う箇所。
ここはこんな感じになっていると推測しているのではないでしょうか。
そう、推測、いや、補完です。
さて、本題ですが、部分的にモザイクがかかった画像を見るとここにはこれがあると妄想するでしょう。
そんなわけで、本日、皆様の妄想を具現化する、つまり、モザイクを外すことを試みます。
モザイク処理外し
モザイク処理とは
モザイク処理は次のように定義されているようです。（Wikipedia）
モザイク処理（モザイクしょり）(英語: mosaic processing)・ピクセル化 (英語: pixelization)とは写真・画像・静止画・映像・動画において表示したくない部分をピクセル単位で見えにくくする映像処理。（by Wikipedia）
要は見えにくい部分を加工する処理です。モザイク処理自体は後で詳細を述べます。
モザイク処理の種類
モザイク処理は大別して2種類の方式があります。
モザイクは、非可逆圧縮、可逆圧縮の手法です。
非可逆圧縮は元に戻すことができない圧縮方式であり、モザイク画像から元画像を完全に復元することができません。
それに対し、可逆圧縮は元に戻すことが可能な方式であり、現在は非可逆圧縮が主流となっているそうです。
（可逆圧縮の代表例としてFLMASKと呼ばれるツールが昔あったらしい、同じ会社の人に教えてもらった。）
現在は、非可逆圧縮の方式が主流のため、本実験でも同様の圧縮方式をベースに実現します。
本手法で選択したモザイクの手法は次のとおりです。
- 黒いモザイク・・・画面の一部が黒いモザイクとなる。
- 中央値を用いたモザイク・・・ぼかしたい箇所をmedian filterにする。
- Gaussian Filterを使ったモザイク・・・ぼかしたい箇所にGaussian Filterを使う。
今回は実用性を重視するため、部分画像への適用も試みます。
これは、全体を隠さなければならないケースは少なく
部分的に見てはいけないものとして隠していることもあるからです。
乱数による埋込も画像に対し、完成品があまりに不自然なので利用しません。
データセットの収集
モザイク処理外しのアルゴリズム
モザイク処理外し
はじめの方で一般的なモザイクが非可逆圧縮であると説明しました。
そのため、厳密にはモザイク処理を外すのではなく、モザイクがかかった箇所を補完する処理を行います。
この補完処理ですが、生成モデルで利用される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を利用した画像補完アルゴリズムです。
最初に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部では次のことをしています。
- Discriminatorの誤差に必要な情報を計算（オリジナル画像）
- Generatorで画像を生成
- Discriminatorの誤差に必要な情報を計算（生成画像）
- 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の画像 何も表現できていません。
150epoch 少しずつ表現ができてきた？
400epoch あんまり変わらない。
GAN
そして、GANを利用した生成処理を実施します。
1 epoch 表現が残念なところからスタート
150epoch
おまけ
少しおもしろいのがデバッグ用画像です。
このデバッグ用画像はGeneratorの出力をそのまま表示している画像で、
元画像での上書きも何もしていません。
Generatorのみ学習した場合
GANの場合
入力されていないと思われるラブライブ画像（サンシャインから取ってきた）
元画像１
大量に生成したモザイク＋復元画像１
元画像２
大量に生成したモザイク＋復元画像２
思ったよりも綺麗に生成されていますね。
最後に
妄想力を完全に可視化するにはまだまだかかるようです。
結構ネタとして面白かったのでちょっと画像大きくしてやってみるのも面白いかなぁと思いました。
※何かバグや違い、こうすれば良い等あれば教えてください。
画像のDataAugmentationで最速のライブラリを探してみた
皆さんこんにちは
お元気ですか。年末に向けて燃え尽きようとしています。
OpenCVアドベントカレンダー第22日です。
今回、PythonのDataAugmentationで最速の方法を探してみます。
画像処理のDeepLearningでは、頻繁にDataAugmentationが使われています。
このData Augmentationは画像に結果がない程度に変換を加え、
ニューラルネットワークに入力する手法です。
以前、こんな資料を作りました。
www.slideshare.net
DataAugmentationにも様々な手法がありますが、次の処理する場合が非常に多いです。
- 画像をファイルから取得する。
- リサイズ
- アフィン変換
- 左右反転
この処理ですが、入力時に一定の確率で実行されます。
そのため、この処理が遅い場合には性能のボトルネックになります。
そのため、実装を高速化することは学習時間の短縮に非常に有用となります。
GPUが関わる処理で学習を高速化したい場合はCPU部も高速化することが必要でしょう。
速度を計測するにあたり、使用したライブラリをご紹介
OpenCV
当記事のアドベントカレンダーの掲載先となるフレームワーク、
かつ、最も画像処理で有名なライブラリである言わずもがなOpenCVです。
Wikipediaの概要では、次のように記載されています。
計測
では、早速計測を行います。
本手法における計測はtimeitを利用して実施します。
対象となる画像は皆さん大好きLennaさん（高225x幅225）です。
※ライブラリによって実装方法が異なるので、結果が多少ことなることがあるかもしれません。
その点は確認して、利用してください。
画像読み込み
画像読み込みとすると非常に曖昧のため、今回は次の定義とします。
- 画像をファイルから読み込む
- 0-1へ画像を正規化
- 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に非常に有用な手法となります。
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においても非常にメジャーな技術と言えるでしょう。
時間の都合もあり、条件が若干ばらばらですが、アフィン変換の計測をしました。
全て微妙に違う画像ですが、こんな感じで変換を行っています。
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)
左右反転
左右反転を行います。処理後の画像は次の通り
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)
日本語自然言語処理のData Augmentation
皆さんこんにちは
お元気ですか。週末の発表資料も作っています。
本記事は自然言語処理アドベントカレンダー第13日です。
画像処理ではデータをアフィン変換などで変形して、
画像を拡張する処理（＝Data Augmentation）が知られています。
変換などをかけて過学習を防ぐ役割が１つとしてあります。
今回は、自然言語処理でもData Augmentationを実現したいと思います。
テキストのData Augmentationの意義
自分でデータセットを作る場合に、全てを網羅して１つ１つの単語が変わった場合を
作り上げるのは非常に困難で、時間がかかります。
そのため、一定の問題ない範囲（＝結果が変わらない範囲）で
データを拡張する試みをすることで精度やロバストな学習ができる可能性があります。
WordNetの説明
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は上位の言葉への言葉も登録されているため、その言葉を使う置換方式も可能そうに見えます。
上位語は次の方式で検索できます。因みに病気だと、'病み煩い', '疾病', '杜撰'が検出されます。難しい。
こちらの内容を参考にし、実装しています。
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
※自動的に付け加える方法は要検討ですね。
実際にどの程度データが増えるのかやってみた。
さて、実際に作ります。コードとしての手順は次の通りです。
- 形態素解析を行う。
- 品詞を抽出し適切な処理を行う。（これまでの処理）
- 全てのパタンを列挙する。
これらを使った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)
結果
そんな、とてもきつい風邪だから仕方ないよ。
そんな、風邪だから仕方ないよ。 そんな、風邪だから流儀ないよ。 そんな、風邪だから遣り口ないよ。 そんな、風邪だから手ないよ。 そんな、風邪だから仕様ないよ。 そんな、風邪だから筆法ないよ。 そんな、風邪だからスタイルないよ。 そんな、風邪だから仕樣ないよ。 そんな、風邪だから様式ないよ。 そんな、風邪だからやり口ないよ。
なんか意味変わっていないか！？といった部分もありますね。
あなたのことが好き
あなたのことが好き あなたのことが好み あなたのことがお好 あなたのことが御好み あなたのことがお好み あなたのことが御好 あなたのことが好き あなたのことが温かさ あなたのことが慈しみ
少し近い気がします。何か日本語的にピンとこない内容もありますが、
若干誤字っぽければこうなるのでしょうか。
考察
意味が変わっている単語があり、もう少し検討の余地はありそうです。
もう少し単語の形を捉えることが必要でしょうか。
