はじめに

ディープラーニング技術が身近になり、ググってみると色々なものを画像認識させるサンプルがたくさん見つかるようになりました。
結果が分かりやすくて見ていて楽しいので、n番煎じながら自分も何か認識させてみたくなったのですが、動物とか好きな女優さんとかを認識させるのはみんなやってるので、別のネタでやりたい。

ということで、鉄道車両の画像を学習データとして、入力画像に写っている車両の形式をディープラーニング技術で当てさせてみました。もっとも、レベル感は電車に興味を持ち始めた小さい子供と同程度だと思いますが。

↓このような車両の画像を入力して「E231系500番台」と当てさせることを目指します。

開発環境

• Ubuntu 18.04
• Python 3.6.9
• TensorFlow 2.1.0 (CPU)

問題設定

与えられた鉄道車両の外装写真に対して、5つの選択肢の中から1つを当てるようなニューラルネットワークのモデルを学習してみましょう！
今回はJR東日本の車両形式のうち、東京近郊で走っている5種類を対象とします。人間が見れば帯の色などでパッと判別できますが、どの部分が車両なのかを計算機に分からせるのは大変かもしれません。

車両画像の例

ここの画像は自前です。

(1) E231系500番台（山手線）

(2) E233系0番台（中央線快速・青梅線・五日市線）

(3) E233系1000番台（京浜東北・根岸線）

(4) E233系8000番台（南武線）

(5) E235系0番台（山手線の新型車）

データ集め

こちらの記事を参考にしました。
TensorFlowで画像認識「〇〇判別機」を作る - Qiita

Google画像検索で出てきた画像を自動ダウンロードさせます。

pip install google_images_download
googleimagesdownload -k 山手線
googleimagesdownload -k 中央線快速
googleimagesdownload -k E235
:
:

集めた画像の中で、車両の外装が写っている写真だけを使います。以下のような画像は使いません。

• 車両が写っていない画像（路線図や駅舎だけが写っているなど）
• 複数の車両・編成が写っている画像
• 内装の写真
• 鉄道模型
• CG画像

いろいろなキーワードで試して、最終的に1形式あたり100枚以上の画像を集めます。今回は5種類で合計540枚となりました。
全然数が足りなそうですが、これでも結構大変なんですよ…。キーワードを変えても同じ画像しかヒットしなかったりとか。

次に、集めた画像を、クラスごとにフォルダに分けて配置します。

• images/
  • E231-yamanote/
    • E231系500番台（山手線）の画像 115枚
  • E233-chuo/
    • E233系0番台（中央線快速など）の画像 124枚
  • E233-keihintohoku/
    • E233系1000番台（京浜東北・根岸線）の画像 75枚
  • E233-nanbu/
    • E233系8000番台（南武線）の画像 101枚
  • E235-yamanote/
    • E235系0番台（山手線の新型車）の画像 125枚

実際に集まった画像

(1) E231系500番台（山手線）

(2) E233系0番台（中央線快速・青梅線・五日市線）

(3) E233系1000番台（京浜東北・根岸線）

(4) E233系8000番台（南武線）

(5) E235系0番台（山手線）

モデル学習のコード

さて、画像が準備できたらいよいよ学習です。
基本的には以下の記事の内容を参考にしました。
GPUを使ってVGG16をFine Tuningして、顔認識AIを作って見た - Qiita

今回の各形式は色が全然違う（山手線は2つありますが見た目がかなり違う）ので、女優さんの顔を識別するよりは簡単なタスクではないかと思いますが、それでもわずか500枚程度の画像では厳しいでしょう。
このデータの少なさに対処するため、VGG16の学習済みモデルを利用してファインチューニングを行います。VGG16のモデルはTensorFlow (Keras) から別途パッケージのインストールなしに利用できます。
Keras：VGG16、VGG19とかってなんだっけ？？ - Qiita

VGG16は鉄道車両とは関係ない1000クラスの画像分類を行うモデルですが、学習されている重みが画像の識別に有効な特徴量を表現していると考え、出力に近い層だけを今回のタスクに合わせて取り替えて学習してしまいます。それによって最初のモデルの学習データとは全く関係ない識別問題が解けるようになるらしい。あら不思議。
入力を128×128¹のカラー画像とし、VGG16のモデルを通した後に、全結合層256ユニット・Dropout・全結合層（出力層）5ユニットを付けます。
今回追加した全結合層と、VGG16の出力層に最も近いConv2D-Conv2D-Conv2Dの部分の重みだけを学習させ、残りのConv2D層は学習済みのパラメータから動かしません。

入力画像は、各所で紹介されているように ImageDataGenerator で拡大縮小や左右反転といったゆらぎを与えて学習に使います。元画像は500枚程度ですが、各エポックで毎回異なるゆらぎが与えられるので、それでデータを水増ししたことになるようです。
Python - Keras ImageDataGeneratorについて｜teratail

train.py

import tensorflow as tf
from tensorflow.keras.layers import Dense, Input, Flatten, Dropout
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
from tensorflow.keras.models import Model
from tensorflow.keras.applications import VGG16
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt

# 学習設定
batch_size = 32
epochs = 30
# 特徴量の設定
# classesはサブフォルダの名前に合わせる
classes = ["E231-yamanote", "E233-chuo", "E233-keihintohoku", "E233-nanbu", "E235-yamanote"]
num_classes = len(classes)
img_width, img_height = 128, 128
feature_dim = (img_width, img_height, 3)
# ファイルパス
data_dir = "./images"

# === 画像の準備 ===
datagen = ImageDataGenerator(
    rescale=1.0 / 255, # 各画素値は[0, 1]に変換して扱う
    zoom_range=0.2,
    horizontal_flip=True,
    validation_split=0.1
)
train_generator = datagen.flow_from_directory(
    data_dir,
    subset="training",
    target_size=(img_width, img_height),
    color_mode="rgb",
    classes=classes,
    class_mode="categorical",
    batch_size=batch_size,
    shuffle=True)
validation_generator = datagen.flow_from_directory(
    data_dir,
    subset="validation",
    target_size=(img_width, img_height),
    color_mode="rgb",
    classes=classes,
    class_mode="categorical",
    batch_size=batch_size)

# 画像数を取得し、1エポックのミニバッチ数を計算
num_train_samples = train_generator.n
num_validation_samples = validation_generator.n
steps_per_epoch_train = (num_train_samples-1) // batch_size + 1
steps_per_epoch_validation  = (num_validation_samples-1) // batch_size + 1

# === モデル定義 ===
# 学習済みのVGG16モデルをベースに、出力層だけを変えて学習させる
# block4_poolまでのパラメータは学習させない
vgg16 = VGG16(include_top=False, weights="imagenet", input_shape=feature_dim)
for layer in vgg16.layers[:15]:
    layer.trainable = False

# 今回のモデルを構築
layer_input = Input(shape=feature_dim)
layer_vgg16 = vgg16(layer_input)
layer_flat = Flatten()(layer_vgg16)
layer_fc = Dense(256, activation="relu")(layer_flat)
layer_dropout = Dropout(0.5)(layer_fc)
layer_output = Dense(num_classes, activation="softmax")(layer_dropout)
model = Model(layer_input, layer_output)
model.summary()
model.compile(loss="categorical_crossentropy",
              optimizer=SGD(lr=1e-3, momentum=0.9),
              metrics=["accuracy"])

# === 学習 ===
cp_cb = ModelCheckpoint(
    filepath="weights.{epoch:02d}-{loss:.4f}-{val_loss:.4f}.hdf5",
    monitor="val_loss",
    verbose=1,
    mode="auto")
reduce_lr_cb = ReduceLROnPlateau(
    monitor="val_loss",
    factor=0.5,
    patience=1,
    verbose=1)
history = model.fit(
    train_generator,
    steps_per_epoch=steps_per_epoch_train,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=steps_per_epoch_validation,
    callbacks=[cp_cb, reduce_lr_cb])

# === 正解率の推移出力 ===
plt.plot(range(1, len(history.history["accuracy"]) + 1),
         history.history["accuracy"],
         label="acc", ls="-", marker="o")
plt.plot(range(1, len(history.history["val_accuracy"]) + 1),
         history.history["val_accuracy"],
         label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.savefig("accuracy.png")
plt.show()

学習の推移

30エポック回して、学習データ・検証データでの正解率の推移はこんな感じになりました。
GPUなしのノートPCでCPUをぶん回して（4コアフル稼働で）学習させましたが、1エポックが1分程度でしたので、全部で30分程度で終わっています。

10エポックあたりで検証データの正解率は止まっていますが、5択問題で正解率94%まで来ています。データが少ない割にはよく頑張りましたね！

ModelCheckpoint の機能により、各エポック終了ごとにモデルを自動的に保存しています。今回、検証データの損失が最も小さかったのは17エポック目のモデル weights.17-0.1049-0.1158.hdf5 だったので、これを識別に使います。

import numpy as np
print(np.argmin(history.history["val_loss"]) + 1)
# 17（毎回変わる可能性があります）

注意点

Optimizerを SGD としていますが、これを Adam などにするとうまく収束してくれません。
これは、おそらくファインチューニングだからだと思われます。詳しくは以下の記事で。
[TensorFlow] OptimizerにもWeightがあるなんて - Qiita

車両を識別させる

冒頭に挙げた各画像を、実際に識別させてみましょう。

predict.py

import sys

def usage():
    print("Usage: {0} <input_filename>".format(sys.argv[0]), file=sys.stderr)
    exit(1)

# === 入力画像のファイル名を引数から取得 ===
if len(sys.argv) != 2:
    usage()
input_filename = sys.argv[1]

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image

# 特徴量の設定
classes = ["E231-yamanote", "E233-chuo", "E233-keihintohoku", "E233-nanbu", "E235-yamanote"]
num_classes = len(classes)
img_width, img_height = 128, 128
feature_dim = (img_width, img_height, 3)

# === モデル読込み ===
model = tf.keras.models.load_model("weights.17-0.1049-0.1158.hdf5")

# === 入力画像の読み込み ===
img = image.load_img(input_filename, target_size=(img_height, img_width))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
# 学習時と同様に値域を[0, 1]に変換する
x = x / 255.0
# 車両形式を予測
pred = model.predict(x)[0]
# 結果を表示する
for cls, prob in zip(classes, pred):
    print("{0:18}{1:8.4f}%".format(cls, prob * 100.0))

入出力例

先程の predict.py のコマンドライン引数に画像ファイル名を与えると、識別結果が出力されます。

python3 predict.py filename.jpg

ここで紹介する入力サンプルはすべて自前です。
なお、ここに掲載するために画像の一部を加工していますが、実際の学習・識別時にはオリジナルのまま入力しています。

(1) E231系500番台（山手線）

E231-yamanote      99.9974%
E233-chuo           0.0000%
E233-keihintohoku   0.0000%
E233-nanbu          0.0004%
E235-yamanote       0.0021%

文句なしの正解ですね。

(2) E233系0番台（中央線快速・青梅線・五日市線）

E231-yamanote       0.0023%
E233-chuo          97.3950%
E233-keihintohoku   0.0101%
E233-nanbu          2.5918%
E235-yamanote       0.0009%

これも全く問題なし。

(3) E233系1000番台（京浜東北・根岸線）

駅名標や人が写っていて、機械にとっては識別が難しそうな画像ですが…。

E231-yamanote       2.0006%
E233-chuo           0.9536%
E233-keihintohoku  34.9607%
E233-nanbu          6.5641%
E235-yamanote      55.5209%

山手線E235系の確率が高くなりました。条件悪いですし横からの画像ですし、やむを得ないか。

ちなみに、なぜこれだけ横からの画像かというと、たまたま自分で京浜東北線の電車を正面から撮った画像がなかったからです…（汗）

(4) E233系8000番台（南武線）

E231-yamanote       0.1619%
E233-chuo           7.9535%
E233-keihintohoku   0.0309%
E233-nanbu         91.7263%
E235-yamanote       0.1273%

正解の南武線に高い確率をつけましたが、中央線快速と少し迷った様子。もっとも、フォルムはほぼ同じで色違いなだけなのですが、それなら京浜東北線と迷ったっていいのでは。

(5) E235系0番台（山手線）

E231-yamanote       0.0204%
E233-chuo           0.0000%
E233-keihintohoku   0.0027%
E233-nanbu          0.0002%
E235-yamanote      99.9767%

これは問題ないですね。

その他

E231-yamanote       0.2417%
E233-chuo           0.0204%
E233-keihintohoku   2.1286%
E233-nanbu          0.0338%
E235-yamanote      97.5755%

本当は3番目が正解なのですが、山手線の新型車と思ってしまったようです。なぜ。。。

E231-yamanote      47.2513%
E233-chuo           0.0898%
E233-keihintohoku   0.4680%
E233-nanbu          6.5922%
E235-yamanote      45.5986%

2番目が正解なのですが、なぜか山手線を推してきます。単に横からの画像にはE235を推してくる説も？
南武線の確率が少し出ているのは、右端の標識の黄色に反応したのでしょうか（実際どうかはわかりません）。

まとめ

Google画像検索で集めた500枚程度の鉄道車両の画像を使って、5種類の車両形式を識別するモデルを学習してみました。
学習済みのモデル (VGG16) の一部を流用して学習することによって、GPUなしのPCでも30分程度でそこそこ識別できるモデルができたようです。間違えるパターンもありますが、計算リソースとデータ量の割には善戦した方ではないかと思います。意外と手軽に作れて面白かったです。

本気でやるならもっといろいろな方向からの画像データを集めないとダメですし、車両の部分を切り出すとかも必要だと思います。
顔の判別だったらOpenCVなどで顔の切り出しがすぐにできますが、車両の場合は物体検出のアノテーションからでしょうね…。

---

1. 元記事の通り150×150でもよかったのですが、VGG16を通すと画像サイズが縦横それぞれ1/32になるので、32の倍数にしておこうかとなんとなく思った次第です。オリジナルのVGG16学習に使われた224×224だとメモリが足りなくなってしまいました（Windows 10でTensorFlowをうまく動かせず、仮想マシン上のLinuxで動かしているためでしょう）。 ↩

はじめ

前回
今日からC。書くの忘れていたので一問だけです。

#15

問題

考えたこと
昨日のB問題の類題です。forループを3つから2つに減らすことでTLEを防いでいます。

n ,y = map(int,input().split())

for i in range(n+1):
    for j in range(n+1):
        noguti = (y - (i * 10000 + j * 5000)) // 1000
        if noguti + i + j == n and noguti >= 0:
            print(i,j,noguti)
            quit()

print(-1,-1,-1)

ちなみに、Python3→1567ms、PyPy3→276msでした。PyPyつよい

まとめ

昨日の類題だったので、すぐにできた。Python3とPyPy3で結構な速度差があるので、for文使うのはPyPyを使ったほうがいいかな。では、また

atcoderでよく(?)使うアルゴリズムや関数のリスト.
備忘録, コピペ用関数など. 勉強しながら更新します.

基本的な処理

辞書関連

辞書の要素をリストにして管理する.

良く忘れるので.

N =  int(input())
dic = {}
for i in range(N):
  x, y = map(int, input().split())
  dic.setdefault(x, []).append(y)

for 文を回すときは
dic : キー
dic.values() : 要素
dic.items() : キーと要素

高速化

出力に関して

あんまり出力について気にして無かったが, for分の中で毎回print()すると思っている以上に計算速度に影響している可能性がある.
ex)
ABC089 D問題
上の書き方 : 約 1000ms前後
下の書き方 : 約 500ms前後
と500ms近い差でした.

#遅い出力
for i in range(N):
  #処理
  print("計算結果")
#速い出力
ans = []
for i in range(N):
  #処理
  ans.append("計算結果")
print(*ans, sep = "\n")

numpy vs list

脳みそが整理されたら書く.

アルゴリズム

bit全探査(指数関数のオーダーでの全探査)

問題例 atcoder ABC119:C, ABC147:Cなど

$N < 10$程度(底が2なら15くらいまで可能?)なら有効. 2進数ならシフト演算での実装するのが普通そう
参考文献 : http://iatlex.com/python/base_change
bit全探査のアルゴリズムは : https://qiita.com/gogotealove/items/11f9e83218926211083a

n = int(input())
bit_base = 4#bit_base^nの全探査になる. 
def Base_10_to_n(X, n):#10進数をbit_base進数に変換
    X_dumy = X
    out = ''
    while X_dumy>0:
        out = str(X_dumy%n)+out
        X_dumy = int(X_dumy/n)
    return out
for i in range(bit_base**n):
  s = Base_10_to_n(i, bit_base)
  s = s.zfill(n)
  for num, j in enumerate(s):
    #問題に応じた処理を書く
print(ans)

nCr をpで割った余りの算出の高速化

よく使う
問題例 : atcoder ABC151:E, ABC145:D　など

公式

$a$は$b$で割り切れるとする.
$$ pが素数の時,\ a / b \equiv a * b^{(p-2)} \ (mod \ p) $$
が成り立つ.

• $a$を$b$で割って得られる整数を$p$で割った余りを求めるという作業は　$b^{(p-2)}$をかけて$p$で割った余りを求めるという作業で代替できる.

#階乗のリストを作成する
frac = [1]
for i in range(N):
    frac.append(frac[i]*(i+1)%p)

#上の公式を用いてcombの計算を行う
def comb(n, k, mod):
    a=frac[n]
    b=frac[k]
    c=frac[n-k]
    return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod

union find

要素をいくつかの木構造で分けて管理するような場合に有効. (ABC 157 D問題とか)
参考文献:?ホン

def find(x):#xの親を見つける
  if par[x] < 0:
    return x
  else:
    par[x] = find(par[x])
    return par[x]

def unite(x,y):#要素xとｙを併合させる
  x,y=find(x),find(y)#xとyの親の検索
  if x!=y:#親が異なる場合併合させる
    if x>y:
        x,y=y,x#小さい方をxとする. これにより要素の値が小さいものを優先して木の根とする. 
    par[x]+=par[y] #値を無向木の要素数の和にする.
    par[y]=x #枝側は根の位置を格納

def same(x, y):#要素xと要素yが同じ無向木に所属しているかを判定する
  return find(x) == find(y)#同じ値を持つか否か

def size(x):#要素xが所属する無向木の大きさを返す
  return-par[find(x)]

n = int(input()) #要素の数
par = [-1] * n #parは木の根の情報を持つ配列, xが根元ならpar[x]はその無向木に所属する要素の数を, そうでない場合は所属する根元のparにおける位置を示す数値が格納される. 

tkinterで背景が透明なFrameを作る。

環境

Windows10
Python3.7

※本記事ではWin環境のみ扱います。他OSでは正常に動かない可能性が高い。

サンプルコード

from tkinter import ttk
import tkinter

root=tkinter.Tk()
root.wm_attributes("-transparentcolor", "snow")
#root.attributes("-alpha",0.5)
ttk.Style().configure("TP.TFrame", background="snow")
f=ttk.Frame(master=root,style="TP.TFrame",width="400",height="300")
f.pack()

label=ttk.Label(master=root,text="薄くならないで…",foreground="red",background="snow")
label.place(x=150,y=150)
root.mainloop()

root.wm_attributesのtransparentcolorに透過させたい色を指定する。今回はsnowに設定。
これより、backgroundがsnowなfとlabelの背景が透明になる。

実行結果

FrameとLabelの背景が透過して後ろの壁紙が見えています。若干Labelにsnowが見えていますが、これはどうにもなりません(気持ち悪い)

-alphaオプション

上のコードのroot.wm_attributes("-transparentcolor", "snow")を
root.attributes("-alpha",0.5)のようにすると確かに-alphaの値で透明度を[0,1]で変更することができます。
しかし、

このようにrootにあるLabelなどオブジェクト全体に透過率が適用されるので注意が必要。

参考

【Python】【TkInter】透明なFrameを生成する
↑Mac環境下ではこの記事の内容で再現できるそうです(手元に環境がないので未確認)。

Linuxでも再現できないか調べはしたが、結局解決できず...
上のサンプルコードをそのまま手元のubuntu18.04.4環境下で実行すると、

Traceback (most recent call last):
  File "hoge.py", line 5, in <module>
    root.wm_attributes("-transparentcolor", "snow")
  File "/usr/lib/python3.6/tkinter/__init__.py", line 1788, in wm_attributes
    return self.tk.call(args)
_tkinter.TclError: bad attribute "-transparentcolor": must be -alpha, -topmost, -zoomed, -fullscreen, or -type

となった。

はじめに

この記事を読むと?

難解でとっつにくいイメージのある機械学習について、実際にコードを動かしながら、最短で体験することができます。

なぜこの記事を書いたのか

機械学習やディープラーニング学ぶ方（またはこれから始める方）が増えています。
今は優れた書籍やオンライン上の教材が豊富にあり、多様な選択肢があります。素晴らしい時代ですね。
しかし残念ながら、何かしらの教材で挑んでみたものの、実際に機械学習を実装する手前で挫折してしまう方も少なくないと感じています(そしてそれは本人の能力のせいではなく、わずかな周囲の環境やタイミングといった運によるものが大きいと思います)。
機械学習を習得するためには、PythonやRといったプログラミング言語の習得はもちろん、ある程度の数学の素養や、環境構築が必要です。それらでつまずき、「自らの手で機械学習を動かす」という経験をできないのはとても惜しいことです。

そこで私が提案したいのは、本格的な勉強を始める前にまずざっとでいいので、「ゴールを体験して全体像を概観する」ということです(=機械学習の場合はコピペで良いのでモデルを構築してみること)。
ゴールの見えないマラソンを続けることは非常に困難ですが、ゴールに至るまでの道筋が明確に見えてさえいれば、その足取りは確かになることでしょう。
また、最初にゴールを意識することで学習効率が高まるという効果も期待できます。

「機械学習」や「ディープラーニング」と聞くと難しそうですが、実はモデルを作るだけなら簡単にできます。環境構築も不要です。

忙しいあなたの時間を、今日という一日の10分間だけ機械学習を学ぶこと使ってみませんか?

対象者

・機械学習に興味がある人
・これから機械学習の勉強を始める人
・勉強を始めたけど序盤で躓き、中々アウトプットまで進めない人

環境

・Google Chrome
・Google Colaboratory
(Chromeブラウザさえ開ければ、PCはMacでもWindowsでも何でも大丈夫です）

セットアップ

今回はローカルに環境を構築せず、ブラウザ上から「Google Colaboratory」というクラウド実行環境を使います。
初めて聞く方も身構えないでください!Colaboratoryとは「ブラウザから簡単に使えて、無料の、高性能の機械学習・ディープラーニングを実行できる環境」です。流石Google様です。
高価なGPU機材が必要なイメージがあるかもしれませんが、必ずしもそうではないんですね。

Colaboratoryへサインアップ

さあ、Colaboratoryを始めましょう!
Colaboratoryは個人のGoogleアカウントに紐づいています。
下記URLから、ご自身のGoogleアカウントでColaboratoryでログインしてください。

Colaboratory へようこそ

これで完了です!!!なんと、Googleアカウントでログインするだけなんですね。なんて簡単でしょうか。

ファイル作成

さて、次は実際にコードを書くための場所を作成しましょう。
といっても、驚くほど簡単なので安心してください。
スクショの通り、画面右上の「ファイル」タブから「ノートブックを新規作成」をクリックしてください。

これで作成が完了しました！
このままでも良いですが、せっかくなのでファイル名を変えてみましょう。

「firstStep.ipynb」とでもしましょうか。（面倒な方はスキップしてOKです）

やってみよう！~kerasで画像認識~

さあ、いよいよ本番です。機械学習の世界へ入門してみましょう。
今回は「ゴールを経験する」ということが目的なので、コードをコピペするだけでOKです。
コードの説明の意味は今は理解せずとも良く、「ふーん」とでも聞き流してください。

基本モジュールのインポート

まず、各種モジュールをインポートしましょう。

import tensorflow as tf
import keras
import numpy as np
from matplotlib import pyplot
%matplotlib inline
import os
import distutils
if distutils.version.LooseVersion(tf.__version__) < '1.14':
    raise Exception('This notebook is compatible with TensorFlow 1.14 or higher, for TensorFlow 1.13 or lower please use the previous version at https://github.com/tensorflow/tpu/blob/r1.13/tools/colab/fashion_mnist.ipynb')

機械学習を勉強している方ならおなじみですね。
tensorflowモジュールとnumpyモジュールを、それぞれtf,npと扱いやすい名前をつけてインポートしています。

tensorflowとkerasをそれぞれインポートしています。実はimport kerasは省略しても今回のコードは問題なく動作します。そもそもkerasはtensorflowのラッパー言語、つまりtensorflowを簡単に扱えるようにしたものですので、バックエンドではtensorflowが動いています。できるようにしたものです。分かりやすいのでわざわざkerasもインポートしています。

numpyは、機械学習の膨大な計算を高速に行うためのモジュールです。numpyのおかげで機械学習やデータサイエンスはPythonが主流になりました。

matplotlibは出力結果をグラフ等で可視化するためのモジュールです。

osモジュールはMacのterminalやWidowsのcommand lineのような、OSっぽいことを実行できるようになります。ディレクトリ操作とかですね。

distutils?これは耳慣れない方も多いでしょう。Python公式ドキュメントで調べてみましょう。
Distutilsの紹介-Python3.8.0ドキュメント
disututilsモジュールはPython標準のパッケージ管理ツールです。
import distutilsの次のif文は、TensorFlowのver.を管理しています。
(if文にこんな使い方あるんですね。面白い〜)

データセットの準備

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()

# add empty color dimension
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

今回はtensorflowに備え付けのサンプル用のデータセットを使うのうで、別途インポートする必要はありません。
Python中級者の書き方として、複数の変数にまとめて値を代入することができます。これも機械学習を勉強している方にはお馴染みの書き方ですね。

モデルの定義

def create_model():
  model = tf.keras.models.Sequential()
  model.add(tf.keras.layers.BatchNormalization(input_shape=x_train.shape[1:]))
  model.add(tf.keras.layers.Conv2D(64, (5, 5), padding='same', activation='elu'))
  model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2,2)))
  model.add(tf.keras.layers.Dropout(0.25))

  model.add(tf.keras.layers.BatchNormalization(input_shape=x_train.shape[1:]))
  model.add(tf.keras.layers.Conv2D(128, (5, 5), padding='same', activation='elu'))
  model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
  model.add(tf.keras.layers.Dropout(0.25))

  model.add(tf.keras.layers.BatchNormalization(input_shape=x_train.shape[1:]))
  model.add(tf.keras.layers.Conv2D(256, (5, 5), padding='same', activation='elu'))
  model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2,2)))
  model.add(tf.keras.layers.Dropout(0.25))

  model.add(tf.keras.layers.Flatten())
  model.add(tf.keras.layers.Dense(256))
  model.add(tf.keras.layers.Activation('elu'))
  model.add(tf.keras.layers.Dropout(0.5))
  model.add(tf.keras.layers.Dense(10))
  model.add(tf.keras.layers.Activation('softmax'))
  return model

層毎にドロップアウトとバッチ正規化を施した、3層から成るCNNでモデルを構築します。
(強そうな用語の連続パンチですね!ここでは一旦スキップしてください)

モデルの訓練

訓練データを使って、モデルを訓練しましょう。
下記コードを実行してみると・・・？

resolver = tf.contrib.cluster_resolver.TPUClusterResolver('grpc://' + os.environ['COLAB_TPU_ADDR'])
tf.contrib.distribute.initialize_tpu_system(resolver)
strategy = tf.contrib.distribute.TPUStrategy(resolver)

with strategy.scope():
  model = create_model()
  model.compile(
      optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3, ),
      loss='sparse_categorical_crossentropy',
      metrics=['sparse_categorical_accuracy'])

model.fit(
    x_train.astype(np.float32), y_train.astype(np.float32),
    epochs=17,
    steps_per_epoch=60,
    validation_data=(x_test.astype(np.float32), y_test.astype(np.float32)),
    validation_freq=17
)

model.save_weights('./fashion_mnist.h5', overwrite=True)

ギュイーンとEpochが1/60から60/60になるまで更新されていきます！かっこいい!

これは何が起こっているのかというと、実際にニューラルネットワークで学習が行われていく要素を可視化してくれているんですね（なので、非表示にすることも可能です）。
動画で掲載できなくて残念ですが、AIっぽくてとてもテンションが上がる光景です。
コードをコピペするだけで簡単に実行できるので、是非ご自分の目で確かめてください。

訓練済みモデルでファッション画像を予測

前節を経て、今の我々は訓練済みのモデルを持っています。
早速使ってみましょう!

LABEL_NAMES = ['t_shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt', 'sneaker', 'bag', 'ankle_boots']


cpu_model = create_model()
cpu_model.load_weights('./fashion_mnist.h5')


def plot_predictions(images, predictions):
  n = images.shape[0]
  nc = int(np.ceil(n / 4))
  f, axes = pyplot.subplots(nc, 4)
  for i in range(nc * 4):
    y = i // 4
    x = i % 4
    axes[x, y].axis('off')

    label = LABEL_NAMES[np.argmax(predictions[i])]
    confidence = np.max(predictions[i])
    if i > n:
      continue
    axes[x, y].imshow(images[i])
    axes[x, y].text(0.5, 0.5, label + '\n%.3f' % confidence, fontsize=14)

  pyplot.gcf().set_size_inches(8, 8)  

plot_predictions(np.squeeze(x_test[:16]), 
                 cpu_model.predict(x_test[:16]))

すると、下記のような結果が出力されます。

10種類の服のジャンルを予測、分類することができました！しかもなかなか高精度ですね。

終わりに

お疲れ様でした。そしておめでとうございます！
これであなたは「機械学習のモデルを実装したことがある」と言う資格があります。
実はコード自体は短いし、実行するだけなら難しくないんですね。
「機械学習のプログラミングってこんな感じか〜」となんとなく感じて頂けたでしょうか。

最後に、今回の記事の概要を復習しましょう。
・機械学習の勉強はまずモデルを構築してみるのがおすすめ
・モデル構築だけなら機械学習は超簡単
・15分間でkerasで画像認識をしてみよう(必要なのはChromeが開けるPCのみ)

次は是非、機械学習の仕組みやPythonのコードについて理解することにチャレンジしてみてください。

参考文献

Fashion MNIST with Keras and TPUs-SeedBank
本記事のコードは「SeedBank」より引用させて頂いています。

Colaboratory へようこそ

Distutilsの紹介-Python3.8.0ドキュメント

はじめに

(以下、競馬用語を注釈無しで使用していきますのでご了承下さい。)

なんとなく5代血統表に漢字の馬名が入っている馬がどれくらいいるのか気になったので競馬データベースサイト「JBISサーチ」のページをスクレイピングして調べてみました。

近年活躍した競走馬で、5代血統表内に漢字の馬名がある馬といえばゴールドシップが一番有名でしょう。

5代母が1959年生の「風玲」という馬です。

昔は競走馬名にカタカナ使用の制限があっても、繁殖登録名には漢字が使えたという時代があった(60年くらい前まで？)ので、競走馬時代と異なる名で繁殖入りした馬や、輸入された際に漢字の名前をつけられた馬がいます。
人間よりも世代交代のサイクルが早いことや、血統の淘汰などを考えると、未だに5代以内に漢字の馬名がある馬は貴重と言えるでしょう。

調査対象

今回はゴールドシップ号と同じ2009年生まれの馬から2019年まで生まれた馬について調査対象にし、「風玲」のような漢字のみの馬名だけではなく「カバーラツプ二世」のような一部に漢字を含む馬名についてもマッチ対象にします。

準備

使用環境・ツール等

Windows 10
Python3.7.6(Anaconda)
Scrapy
ScrapyCloud
MongoDB
Metabaseなど

取得・保存する情報

血統表内の馬名に漢字があった場合は
その馬の

• 馬名・誕生年・父・母馬名・血統表のURL など基本的な情報
• n代前ごとの漢字馬名のリスト

についての情報を保存します。

各馬の血統表ページにはJBISサーチの検索結果ページからクロールし、5代血統表内の情報をスクレイピングします。

ページ構造

検索結果ページ

まずこちらが検索窓です。

今回は2009年~2019年生まれの馬が対象なのでとりあえず「生年」に「2009」と入れてみますが…

検索結果が10000件を超えるとNGがでてしまいます。

色々な条件を指定することが出来ますが、今回は生年に加え性別を指定していきたいと思います。

軽種馬の生産頭数を検索してみた結果や、性比に偏りは無さそうなことを考えると、この2つ条件を組み合わせていくことで、対象期間内のすべての馬の情報を検索結果からたどることができそうです。

この「牡馬、2009年生」の検索結果(100件表示)を馬名で昇順ソートすると、36ページ目からアルファベットの名前がずらりと並び、千数百件ものアルファベット馬名が登録されていることがわかります。

これらの外国馬は基本的にクローリング対象から除外しようと思います。
が、検索オプションで「輸出馬」を指定することができるため、そちらを指定して検索結果に出てきた馬に関してはクローリング対象に含めたいと思います。(なので、日本から輸出された馬の子孫に該当する馬があった場合は拾えないということになります。が、いたとしても誤差程度…と思いたい…)
クローリング時のリクエスト数やプログラムの実行時間の短縮も考えると無駄撃ちはなるべく減らしていきたいです。

検索結果ページのURLから不要なクエリパラメータを取り除くとこんな感じになります。
https://www.jbis.or.jp/horse/result/?sid=result&sex=(性別)&birth=(生年)&sort=name&items=100&page=1&order=A
性別のパラメータは牡馬がsex_1,牝馬がsex_2,セン馬がsex_3です。
あとは誕生年・ソート=名前順・100件ずつ表示・ページ番号・並びが昇順(ASC)です。

上記のURLを元に、クエリパラメータの性別・生年の部分を変更したURLを生成してクローリングの基点として使用します。

クローリングの動作としては
1.事前に用意した、基点となるURLのページを取得
2.各馬の血統表ページを取得
3.2がすべて終わったら「次へ」部分のURLのページを取得し2に戻る
4.「次へ」が無くなったら1に戻る
といった感じです。

2については前述した外国馬(馬名がアルファベットの馬)を除外するため、少々ややこしくなっています。
どんな馬でもクローリング対象にするのであれば検索結果の馬名の横の赤い「血統」アイコンのリンク先をクロールすれば用が足りるのですが今回は、

1.馬名の先頭がアルファベットで始まるかどうかを判定する
2.アルファベットで始まらない場合、馬名部分のURL(\https://www.jbis.or.jp/horse/(各馬ごとの識別番号)/) に /pedigree/ を足して(https://www.jbis.or.jp/horse/(各馬ごとの識別番号)/pedigree/) にして血統表のページを取得する。

という指定をします。
参考:【Scrapy】抜き出したURLを修正・加工する

血統表ページの詳細

血統表のtableの
th[rowspan="16"] が 父母(1世代前)
td[rowspan="8"] が2世代前
td[rowspan="4"] が3世代前
td[rowspan="2"] が4世代前
td:not([rowspan="8"]):not([rowspan="4"]):not([rowspan="2"])が5世代前
といったCSSセレクタで指定できます。

それぞれのテーブルのセル内のリンクテキストが漢字の正規表現パターンにマッチするか調べ、マッチする場合は世代ごとのリストに格納します。

漢字の正規表現パターンがマッチした場合は
世代ごとのリストをvalueとして持つdict
ページの上部のh1属性からその馬の「名前」
th[rowspan="16"]部分から「父」・「母」の名前
そのページの「URL」
その馬の「誕生年」を保存します。
誕生年に関しては血統表ページ内には存在しないので、リクエストヘッダーのreferrerから検索結果ページのクエリパラメータのbirthの値を取得します。

実践

Scrapy

今回はScrapyフレームワークを使ってクロール・スクレイピングします。
基本的なセットアップ・プロジェクトなどは省略。

クローラー本体。色々と命名が適当すぎますが…

kanji_pedigree.py

import scrapy
import urllib.parse

from scrapy.spiders import CrawlSpider, Rule
from jbis.items import HorseItem
from scrapy.linkextractors import LinkExtractor
from . import url_generator

class KanjiPedigreeSpider(CrawlSpider):
    name = 'kanji_pedigree'
    allowed_domains = ['www.jbis.or.jp']
    start_urls = url_generator.main() #開始するURLを生成する関数

    rules = [
        Rule(LinkExtractor(restrict_css='.next a')),
        #リンクの正規表現パターン 
        Rule(LinkExtractor( 
            allow=r'.*/horse/[0-9].*', 
            restrict_css=r'th.cell-br-no > a',
            restrict_text=r'^(?![a-zA-Z]).+$', #アルファベットで始まる馬名を除外
            process_value= lambda x:x + "pedigree/" #URLの最後にpedigree/くっつけて直接血統表ページに飛ぶ
            ),callback='parse_pedigree'),
    ]
#
    pattern = '.*[\u2E80-\u2FDF\u3005-\u3007\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF\U00020000-\U0002EBEF]+.*' #漢字の正規表現パターン

    def parse_pedigree(self, response):
        kanji_names = {}
        one_gen_ago = response.css('th[rowspan="16"] > a::text').re(self.pattern)
        two_gen_ago = response.css('td[rowspan="8"] > a::text').re(self.pattern)
        three_gen_ago = response.css('td[rowspan="4"] > a::text').re(self.pattern)
        four_gen_ago = response.css('td[rowspan="2"] > a::text').re(self.pattern)
        five_gen_ago = response.css('td:not([rowspan="8"]):not([rowspan="4"]):not([rowspan="2"]) > a::text').re(self.pattern)
        kanji_names['1代前'] = one_gen_ago if len(one_gen_ago) != 0 else None
        kanji_names['2代前'] = two_gen_ago if len(two_gen_ago) != 0 else None
        kanji_names['3代前'] = three_gen_ago if len(three_gen_ago) != 0 else None
        kanji_names['4代前'] = four_gen_ago if len(four_gen_ago) != 0 else None
        kanji_names['5代前'] = five_gen_ago if len(five_gen_ago) != 0 else None

        if list(kanji_names.values()).count(None) != 5: #
            item = HorseItem()
            item['name'] = response.css('h1.hdg-l1-02::text').get() #馬名
            item['sire'] = response.css('tr:nth-child(1) a::text').get() #父馬
            item['dam'] = response.css('tr:nth-child(17) th a::text').get()#母馬
            item['kanji_names'] = kanji_names #血統表内の漢字を含む馬名
            item['birth_year'] = int(urllib.parse.parse_qs(response.request.headers.get('Referer', None).decode('utf-8'))['birth'][0])
            item['url'] = response.url
            yield item

url_generator.py

import urllib.parse

START_YEAR = 2009 #
END_YEAR = 2009
ITEMS = '100'

def main():
    url = 'https://www.jbis.or.jp/horse/result/?sid=result&page=1&order=A&'
    return [url + urllib.parse.urlencode({'items':ITEMS,'sex':'sex_' + str(sex_param),'birth':str(year)}) for year in range(START_YEAR,END_YEAR+1,1) for sex_param in range(1,4,1)]
    # 輸出馬については下記を使用
    # return [url + urllib.parse.urlencode({'entry':'entry_5','items':ITEMS,'sex':'sex_' + str(sex_param),'birth':str(year)}) for year in range(START_YEAR,END_YEAR+1,1) for sex_param in range(1,4,1)] 

items.py

import scrapy

class HorseItem(scrapy.Item):
    name = scrapy.Field()
    sire = scrapy.Field()
    dam = scrapy.Field()
    kanji_names = scrapy.Field()
    birth_year = scrapy.Field()
    url = scrapy.Field()

settings.py

BOT_NAME = 'jbis'
SPIDER_MODULES = ['jbis.spiders']
NEWSPIDER_MODULE = 'jbis.spiders'
# Obey robots.txt rules
ROBOTSTXT_OBEY = True
DOWNLOAD_DELAY = 3 # ページダウンロード間隔3秒空ける。
FEED_EXPORT_ENCODING = 'utf-8' # スクレイピング結果を出力する際にUTF-8でエンコードする。

Scrapy Cloud

今回のプログラムはリクエスト数が多く、実行時間がかかると思われるため、プログラムの実行についてはScrapy Cloudというホスティングサービスを利用しました。

無料枠だと連続1時間しか実行できないのでわざわざ有料プラン(1ヶ月1000円弱)に登録してしまいました…

登録後にマイページのCode&Deploysという項目のページを見ると

$ pip install shub
$ shub login
API key: hogehoge
$ shub deploy fugafuga

というコマンドラインの見本みたいのがあり、そのままコピペすればデプロイ出来そうに見えますが、requirements.txtやyamlの作成が必要でした。
参考:【Python】Scrapy Cloudにデプロイする
を

デプロイしたSpiderを実行すると
スクレイピング結果がitemsタブにモリモリ保存されていきます。保存されたitemはJSON、CSVなどの形式で全部まとめて・又は1アイテム単位で保存できるようになっています。

一度、setting.pyでHTTPキャッシュ設定をTrueにしたままデプロイしてしまったのですが、途中でScrapyCloudの実行環境のストレージ容量がいっぱいになってしまいエラーになってしまいました。なので大規模なスクレイピングをする場合はオフにしておいたほうがいいです。

MongoDB

保存したJSONをMongoDBにimportします。
MongoDB CompassでJSONファイルを選んでimportを試みるとうんともすんとも言わず。
JSONと言っても行末にカンマを使ってはいけないなどMongo独自のルールがあるらしい。
参考:公式ドキュメント

ここはしょうがないのでPythonでJSONを読み込む→MongoDBに保存というプログラムを書いて無事JSONのデータをMongoDBのコレクションに加えることができました。

Metabase

Metabaseというデータ可視化ツールが面白そうなので使ってみた。
参考:MetabaseをWindowsにインストールする
MongoDB上のデータをきれいに表示してくれます。以下、表やグラフの画像はMetabaseの表示をスクショしたものです。

結果

想定外のマッチ

ローカル環境で動作を確認している際に気づいたが、いわゆる「サラ系」「アラ系」の血が入っている馬だと、血統表内の馬名の前に「サラ系」「アラ系」などの文字が混じっていて"系"の部分が漢字としてマッチしてしまいます。
これに関してはそれ程数が多くないだろうと判断し結果からは手動で除外しました。

詳細

上記の条件にあてはまり、尚且つ血統表内に漢字馬名を含まない馬を手動で除外し、輸出馬の検索結果ページからスクレイピングしたアイテムを加えた結果、
2009年から2019年に生まれ血統登録された馬のうち、5代血統表内に漢字を含む馬名があるのは1054頭いるということがわかりました(無論、私が設けた条件に漏れがなく・プログラム自体に瑕疵がない場合…ですが)

年ごとに見ると2018年→2019年で少し増えていますが、基本的には年々減少する傾向にあり、ここ十年で1/5ほどになっていることがわかりました。

1世代前・2世代前

1・2世代前に漢字の馬名持ちの馬は…さすがにいませんでした。どちらも「サラ系」が引っ掛かっただけです。

3世代前

こちらは15頭いました。
が、このうち競走馬とデビューしているのはイナズマクロス(91年クイーンカップG3勝ち)の産駒2頭や3代母に「風玲」持ちの1頭など7頭のみで、残りの「耐良」を3代母にもち、謎の種牡馬「デザートショット」「ゴールディヒダカ」を父とする8頭はなんと100%の純血アラブ馬(!)でした。
ネットで検索してみた感じだと馬術競技向けに生産されているようですが、現代の日本で純血アラブ馬が生産されているとは驚きです。

4世代前

ここまで来ると一気に増えて208頭(3世代前との重複含む)が該当し、それらは72頭の母馬から生まれていることがわかりました。

登場回数順で集計するとこんな感じになります。

Metabaseはネストした配列の中身を集計するにはデータベースのクエリを直接書かなければならないので注意。

4代前の配列の中身の要素でカウント・降順ソートするクエリの例
[
  { $project: { name: 1, kanji_names: 1 }},
  { $unwind: "$kanji_names.4代前" },
  { $group: { _id: "$kanji_names.4代前", count: { $sum: 1 }}},
  { $sort: { count: -1 } }
]

登場回数が一番多かったのが4代母が健宝=1962年桜花賞馬ケンホウというのが30頭
次に多かったのが4代母豊隼でこの馬は孫がホウヨウボーイだそう。

面白かったのは4代前に「耐良」が2つマッチした2011年生まれの名無しの純血アラブ馬さん。
どんなもんかと思って血統表を確認すると…とんでもないインブリードだ…。

5世代前

926頭(3・4世代前との重複含む)が該当し、それらは285頭の母馬から生まれていることがわかりました。

登場回数順で集計するとこんな感じです。

一番多かった「丘高」=(クモワカ)はかなりドラマチックな来歴を持つ馬なので是非wikipediaなどご覧になって下さい。
直系の牝系だけではなくワカオライデンなど種牡馬経由で丘高を持ってる馬もあった感じです。
ここに載ってるようなのは昔の競馬関係の書籍などで見覚えがある馬の名前が多いですね～。
数が数なので個々の馬に関して調べていくのはやめときます(´・ω・｀)

最後に

• 漢字馬名が父由来か母由来か、も調べるとよかったかも
  • 99%後者だろうけど
• データを収集してもそれをどう利用するか？という点が一番困ったのでその辺もうちょっと考えられるようになっていけたらなと…。
• 参考書籍:Pythonクローリング＆スクレイピング［増補改訂版］ ―データ収集・解析のための実践開発ガイドー
  • 参考サイトは本文中に都度記してあります。
• 誤りや質問などございましたら、コメント欄にお願いします。

2日目

GoogleAnalytics StandardをBigQueryにエクスポートする

GoogleAnalytics(以降 GA)をBigQueryにエクスポートしたいけど、GA360は高くて無理！
って思っていたので、GAのAPIを使って、GCS経由でBigQueryにエクスポートするのを実装しました。
まだ、少ししか試していないので、完ぺきではないかと思いますが、毎日投稿する関係上、悪しからず...笑

大まかな流れ

1. GA APIを使ってrawデータ取得
2. pythonでcsvに整形
3. GCSにエクスポート
4. GCSからBigQueryにエクスポート

この流れで紹介していきます！

GA APIを使ってrawデータ取得

GA API クイックスタート
上のページを参考にクイックスタートをパクります。
すると、rawデータを取得してくれるではありませんか！

ついでにライブラリもインストールしておきます。

pip install --upgrade google-api-python-client
pip install oauth2client

このサンプルを自分好みに変更していきます。
まずは一度に取得できる量が少ないのと、毎日更新したいので、日付を変更していきます。

from datetime import datetime,timedelta
maxSize = 10000
dt_now = datetime.datetime.now()
yesterday = dt_now - timedelta(days=1)
yesterday = yesterday.strftime("%Y-%m-%d")

...とここまで来て、素晴らしい記事があることに気が付きました。

こんな素晴らしい記事読んでいれば、もっと早く完成したのに...笑

わかりやすい記事（神様）

Google Analytics APIを利用して無料版でもrawデータをBigQueryにエクスポートする方法

終わり

ということで、わざわざ書かなくても記事があったので今回はこれで！
一応まとまったファイルになっているものが先ほどの記事にはなかったので、コピペするのも面倒な人向けに一応Gitに挙げておきます。

コード

day2

Day2も無事終了！

まずは3日坊主にならないことが目標です！笑

はじめに

TensorFlow (Keras) のLayerオブジェクトは重み（Weight）を持っています。全結合層 ${\bf y} = {\bf W} {\bf x} + {\bf b}$ の行列 ${\bf W}$ とバイアスのベクトル ${\bf b}$ が代表的ですね。

実はOptimizerにもWeightがあります。学習を中断して続きから再開するとか、Fine-Tuningを行うときなど、「すでに途中まで学習が進んでいる」状態では、このWeightの存在を意識しないと痛い目に遭うという話です。何を今更と言われるかもしれませんが。

検証環境

• Ubuntu 18.04
• Python 3.6.9
• TensorFlow 2.1.0 (CPU)

現象

まずはハマった内容をご紹介しましょう。
3エポック学習させた後、Optimizerを最初と同じ設定で再作成し、モデルを再コンパイルした後、同じデータで再度3エポック回します。実行している本人は、全部で6エポック分学習させた気になっていますが…？
（分かりやすいように例を単純化しています）

import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model

# 乱数シード固定
tf.random.set_seed(1)

# データ作成：現象が分かりやすいようにSubsetで試す
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train[0:1000, :]
y_train = y_train[0:1000]
x_test = x_test[0:100, :]
y_test = y_test[0:100]

feature_dim = 28*28
num_classes = 10

# 前処理をする
# 画素は[0, 1]のfloat32型に変換する
x_train = x_train.reshape((-1, feature_dim)).astype("float32") / 255.0
x_test  = x_test.reshape((-1, feature_dim)).astype("float32") / 255.0
# ラベルもfloat32型にする
y_train = y_train.reshape((-1, 1)).astype("float32")
y_test  = y_test.reshape((-1, 1)).astype("float32")

# モデル定義
layer_input = Input(shape=(feature_dim,))
fc1 = Dense(512, activation="relu")(layer_input)
layer_output = Dense(num_classes, activation="softmax")(fc1)
model = Model(layer_input, layer_output)
model.summary()

optimizer = Adam(lr=0.003)
model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=optimizer,
    metrics=["accuracy"])

# まずは普通に3epoch学習する
epochs = 3
batch_size = 32
model.fit(
    x=x_train,
    y=y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(x_test, y_test))

# Layerの重みを引き継いで続きから学習するつもりで
# Modelを再コンパイル
optimizer = Adam(lr=0.003)
model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=optimizer,
    metrics=["accuracy"])
# もう3epoch学習
model.fit(
    x=x_train,
    y=y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(x_test, y_test))

結果、このようなことが起きます。

Train on 1000 samples, validate on 100 samples
Epoch 1/3
1000/1000 [==============================] - 1s 919us/sample - loss: 0.8494 - accuracy: 0.7360 - val_loss: 0.3652 - val_accuracy: 0.9000
Epoch 2/3
1000/1000 [==============================] - 0s 225us/sample - loss: 0.2397 - accuracy: 0.9340 - val_loss: 0.3003 - val_accuracy: 0.9000
Epoch 3/3
1000/1000 [==============================] - 0s 209us/sample - loss: 0.1146 - accuracy: 0.9700 - val_loss: 0.2830 - val_accuracy: 0.9000
Train on 1000 samples, validate on 100 samples
Epoch 1/3
1000/1000 [==============================] - 1s 787us/sample - loss: 0.1515 - accuracy: 0.9560 - val_loss: 0.3035 - val_accuracy: 0.9200
Epoch 2/3
1000/1000 [==============================] - 1s 575us/sample - loss: 0.0608 - accuracy: 0.9820 - val_loss: 0.2220 - val_accuracy: 0.9300
Epoch 3/3
1000/1000 [==============================] - 0s 384us/sample - loss: 0.0190 - accuracy: 0.9980 - val_loss: 0.2319 - val_accuracy: 0.9100

注目していただきたいのは、最初の3エポック目のTraining Lossよりも、次の1エポック目のTraining Lossのほうが大きくなってしまっている (0.1146 → 0.1515) 点です。

一度に6エポック学習させた場合は、以下のように綺麗にTraining Lossが落ちていきます。
（乱数シードを固定しているため、最初の3エポック分の結果は全く同じです）

epochs = 6
batch_size = 32
model.fit(
    x=x_train,
    y=y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(x_test, y_test))

Train on 1000 samples, validate on 100 samples
Epoch 1/6
1000/1000 [==============================] - 1s 911us/sample - loss: 0.8494 - accuracy: 0.7360 - val_loss: 0.3652 - val_accuracy: 0.9000
Epoch 2/6
1000/1000 [==============================] - 0s 291us/sample - loss: 0.2397 - accuracy: 0.9340 - val_loss: 0.3003 - val_accuracy: 0.9000
Epoch 3/6
1000/1000 [==============================] - 0s 427us/sample - loss: 0.1146 - accuracy: 0.9700 - val_loss: 0.2830 - val_accuracy: 0.9000
Epoch 4/6
1000/1000 [==============================] - 0s 279us/sample - loss: 0.1008 - accuracy: 0.9710 - val_loss: 0.2584 - val_accuracy: 0.9200
Epoch 5/6
1000/1000 [==============================] - 0s 266us/sample - loss: 0.0420 - accuracy: 0.9950 - val_loss: 0.2393 - val_accuracy: 0.9300
Epoch 6/6
1000/1000 [==============================] - 0s 305us/sample - loss: 0.0188 - accuracy: 0.9990 - val_loss: 0.2104 - val_accuracy: 0.9200

今回は簡単な例なのですぐにまたTraining Lossが小さくなっていきますが、複雑な問題だとせっかく時間を掛けて途中まで学習させた成果が台無しになってしまいます。

何が起きたの？

ここで冒頭の「OptimizerにもWeightがあります」という話につながります。
Layerの重みを更新する場合、古典的な手法（SGD: 確率的勾配降下法）では、重みから「損失関数の偏微分係数に学習率を掛けたもの」を引きます。しかし、収束に時間が掛かるので、過去の情報に基づいて重みの変化量をうまく調整し、速く収束させる工夫が考えられてきました。

Optimizer : 深層学習における勾配法について - Qiita

ところが、Optimizerオブジェクトを何も考えずに再作成してしまうと、この「過去の情報」が消えてしまい、重みの調整に悪影響を及ぼしてしまいます。この「過去の情報」こそがOptimizerのWeightです。
上の参考ページの数式で言えば、$h_t, m_t, v_t$ のように、Layerの重み ${\bf w}_t$ 以外の情報を使って重みの更新を行っているアルゴリズムが存在しますね。もし学習を一旦中断し、続きから実行したい場合には、これらの情報を保存しておかなければなりません。

以下のようにすると、Optimizerオブジェクトに含まれるWeightの値を確認できます。

print(optimizer.get_weights())
print(model.optimizer.get_weights()) # ModelのプロパティでもOptimizerを取得可能

Optimizerの再作成とモデルの再コンパイルを行わない場合を試しましょう。以下のコードのうち2回目の方をコメントアウトします。

# optimizer = Adam(lr=0.003)
# model.compile(
#     loss="sparse_categorical_crossentropy",
#     optimizer=optimizer,
#     metrics=["accuracy"])

すると、2回目の学習を始めたときもTraining Lossはちゃんと減少しています。

Train on 1000 samples, validate on 100 samples
Epoch 1/3
1000/1000 [==============================] - 1s 1ms/sample - loss: 0.8494 - accuracy: 0.7360 - val_loss: 0.3652 - val_accuracy: 0.9000
Epoch 2/3
1000/1000 [==============================] - 0s 278us/sample - loss: 0.2397 - accuracy: 0.9340 - val_loss: 0.3003 - val_accuracy: 0.9000
Epoch 3/3
1000/1000 [==============================] - 0s 307us/sample - loss: 0.1146 - accuracy: 0.9700 - val_loss: 0.2830 - val_accuracy: 0.9000
Train on 1000 samples, validate on 100 samples
Epoch 1/3
1000/1000 [==============================] - 0s 243us/sample - loss: 0.1010 - accuracy: 0.9710 - val_loss: 0.2640 - val_accuracy: 0.9200
Epoch 2/3
1000/1000 [==============================] - 0s 263us/sample - loss: 0.0355 - accuracy: 0.9960 - val_loss: 0.2206 - val_accuracy: 0.9100
Epoch 3/3
1000/1000 [==============================] - 0s 235us/sample - loss: 0.0132 - accuracy: 1.0000 - val_loss: 0.2102 - val_accuracy: 0.9200

古典的なOptimizer (SGD) の場合

SGDを使う場合、時間によって変化する量はLayerの重み ${\bf w}_t$ だけであり、それ以外の内部状態を持たないので、この影響を受けないと思われます。試しに Adam の代わりに SGD を使ってみます。

import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Input
#from tensorflow.keras.optimizers import Adam
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.models import Model

# (中略)

optimizer = SGD(lr=0.003)
model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=optimizer,
    metrics=["accuracy"])

# まずは普通に3epoch学習する
epochs = 3
batch_size = 32
model.fit(
    x=x_train,
    y=y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(x_test, y_test))

# Layerの重みを引き継いで続きから学習するつもりで
# Modelを再コンパイル
optimizer = SGD(lr=0.003)
model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=optimizer,
    metrics=["accuracy"])
# もう3epoch学習
model.fit(
    x=x_train,
    y=y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(x_test, y_test))

以下のように、Training Lossは減少し続けています。もっとも、Adam より収束がかなり遅いのですが。

Train on 1000 samples, validate on 100 samples
Epoch 1/3
1000/1000 [==============================] - 1s 848us/sample - loss: 2.2205 - accuracy: 0.2150 - val_loss: 2.1171 - val_accuracy: 0.4200
Epoch 2/3
1000/1000 [==============================] - 0s 227us/sample - loss: 2.0913 - accuracy: 0.3970 - val_loss: 2.0141 - val_accuracy: 0.5700
Epoch 3/3
1000/1000 [==============================] - 0s 226us/sample - loss: 1.9763 - accuracy: 0.5210 - val_loss: 1.9227 - val_accuracy: 0.5900
Train on 1000 samples, validate on 100 samples
Epoch 1/3
1000/1000 [==============================] - 1s 738us/sample - loss: 1.8722 - accuracy: 0.5890 - val_loss: 1.8374 - val_accuracy: 0.6700
Epoch 2/3
1000/1000 [==============================] - 0s 211us/sample - loss: 1.7773 - accuracy: 0.6350 - val_loss: 1.7565 - val_accuracy: 0.7000
Epoch 3/3
1000/1000 [==============================] - 0s 277us/sample - loss: 1.6879 - accuracy: 0.6660 - val_loss: 1.6832 - val_accuracy: 0.7100

先ほどと同様に、6エポック一気に学習した場合はこんな感じです。2回に分けた場合とほぼ変わりません。
（4エポック目以降の値が微妙に異なりますが、この誤差はどこから来るのでしょうね？）

Epoch 1/6
1000/1000 [==============================] - 1s 802us/sample - loss: 2.2205 - accuracy: 0.2150 - val_loss: 2.1171 - val_accuracy: 0.4200
Epoch 2/6
1000/1000 [==============================] - 0s 233us/sample - loss: 2.0913 - accuracy: 0.3970 - val_loss: 2.0141 - val_accuracy: 0.5700
Epoch 3/6
1000/1000 [==============================] - 0s 259us/sample - loss: 1.9763 - accuracy: 0.5210 - val_loss: 1.9227 - val_accuracy: 0.5900
Epoch 4/6
1000/1000 [==============================] - 0s 266us/sample - loss: 1.8719 - accuracy: 0.5920 - val_loss: 1.8376 - val_accuracy: 0.6500
Epoch 5/6
1000/1000 [==============================] - 0s 315us/sample - loss: 1.7764 - accuracy: 0.6410 - val_loss: 1.7552 - val_accuracy: 0.6900
Epoch 6/6
1000/1000 [==============================] - 0s 273us/sample - loss: 1.6873 - accuracy: 0.6680 - val_loss: 1.6806 - val_accuracy: 0.7100

SGD にはWeightはありません…と思いきや、謎の値が出てきます。

print(optimizer.get_weights())
# Result: [192]

いろいろ試したところ、どうも学習した累計バッチ数が入っているようです。先ほどの参考ページの記法でいえば $t$ ですね。ただSGDの場合、$t$ の値そのものは（手法の原理上）重みの更新に影響を及ぼさないはずですので、これ以上は深く立ち入りません（例えばAdamは $t$ の値も使っていますね）。

対処法

今回のような面倒事にならないようにする方法としては

1. 数エポック学習させた後、同じデータで続きから学習させる場合は、OptimizerのWeightを保存しておく
2. Fine-Tuningなど、最初とは別のデータで続きから学習させる場合は、Optimizerとして内部状態を持たないSGDを使う (Momentum-SGDは使っても大丈夫のはず)

のが良いのではと思われます（特に2点目は自信なし…）。

OptimizerのWeightを保存する方法

Modelオブジェクトに対し save() すれば、LayerのWeightだけでなく、設定したOptimizerの情報やWeightの値も含めてファイルに保存できます。

model.save("model.h5", save_format="h5")
exit()

tf.keras.models.load_model() でモデルを読み込むと、前の情報を引き継いだ状態で学習できます。
独自のLayerやCallbackを指定して作成したモデルの場合は custom_objects 引数を指定する必要がありますが、ここでは触れません。
tf.keras.models.load_model | TensorFlow Core v2.1.0

import tensorflow as tf
from tensorflow.keras.datasets import mnist

feature_dim = 28*28
num_classes = 10

# データ作成
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train[0:1000, :]
y_train = y_train[0:1000]
x_test = x_test[0:100, :]
y_test = y_test[0:100]

# 前処理をする
# 画素は[0, 1]のfloat32型に変換する
x_train = x_train.reshape((-1, feature_dim)).astype("float32") / 255.0
x_test  = x_test.reshape((-1, feature_dim)).astype("float32") / 255.0
# ラベルもfloat32型にする
y_train = y_train.reshape((-1, 1)).astype("float32")
y_test  = y_test.reshape((-1, 1)).astype("float32")

# モデル読み込み
model = tf.keras.models.load_model("model.h5")
# print(model.optimizer.get_weights())

# 続きから学習
epochs = 3
batch_size = 32
model.fit(
    x=x_train,
    y=y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(x_test, y_test))

その他

Fine-tuningを使って少ない画像データから効率よく学習モデルを作成する方法 | AI coordinator

# TODO: ここでAdamを使うとうまくいかない
# Fine-tuningのときは学習率を小さくしたSGDの方がよい？

とコメントが書かれていますが、おそらく同じ現象が起きているかもしれません？

概要

ApacheやTomcatなどのアクセスログを解析しようと思っても、意外といいツールってありませんよね。様々な出力形式に対応していて、必要な情報だけをフィルタリングし、手軽に分かりやすく視覚化できるようなツールがあればいいのですが、なかなか見つかりません。

そこで、データ分析の世界では定番のPandasやMatplotlibを利用して、Jupyter Notebook上でApacheのアクセスログを解析、視覚化することが簡単にできるか試してみました。

※Pandas、Matplotlib、Jupyter Notebookのインストールについては、すでに多くの分かりやすい記事がありますので、ここでは触れません。

アクセスログを読み込む

必要なライブラリーのインポート

まずは最低限必要なPandasとMatplotlibをインポートします。

import pandas as pd
from pandas import DataFrame, Series
import matplotlib.pyplot as plt

環境設定

好みに応じて、環境設定します。

# グラフなどはNotebook内に描画
%matplotlib inline

# DataFrameの列の最大文字列長をデフォルトの50から150に変更
pd.set_option("display.max_colwidth", 150)

アクセスログのロード

アクセスログのロード方法については、このブログエントリーを参考にしました。アクセスログをロードする前に、それに必要な型解析用の関数を定義します。

from datetime import datetime
import pytz

def parse_str(x):
    return x[1:-1]

def parse_datetime(x):
    dt = datetime.strptime(x[1:-7], '%d/%b/%Y:%H:%M:%S')
    dt_tz = int(x[-6:-3])*60+int(x[-3:-1])
    return dt.replace(tzinfo=pytz.FixedOffset(dt_tz))

そして、pd.read_csv()でアクセスログをロードします。私の手元にあったアクセスログは少し出力形式が異なっていたので、以下のように修正しました。今回は簡略化のため、一部のカラムだけを抽出しています。

df = pd.read_csv(
    '/var/log/httpd/access_log',
    sep=r'\s(?=(?:[^"]*"[^"]*")*[^"]*$)(?![^\[]*\])',
    engine='python',
    na_values='-',
    header=None,
    usecols=[0, 4, 6, 7, 8, 9, 10],
    names=['ip', 'time', 'response_time', 'request', 'status', 'size', 'user_agent'],
    converters={'time': parse_datetime,
                'response_time': int,
                'request': parse_str,
                'status': int,
                'size': int,
                'user_agent': parse_str})

アクセスログを解析する

アクセスログをロードしたら、解析してみましょう。

データを加工せずに確認

まずはファイルの先頭と最後の5行ずつを確認します。

df

03月24日の18:20から1時間20分ほどで114,004件のリクエストがあったことが分かります。

応答時間の集計結果確認

応答時間の平均値や最大値を表示してみましょう。

print('応答時間の集計結果（マイクロ秒）\n')
print('最小値 : {}'.format(str(df['response_time'].min()).rjust(10)))
print('平均値 : {}'.format(str(round(df['response_time'].mean())).rjust(10)))
print('中央値 : {}'.format(str(round(df['response_time'].median())).rjust(10)))
print('最大値 : {}'.format(str(df['response_time'].max()).rjust(10)))

print('\n応答時間のワースト15')
df.sort_values('response_time', ascending=False).head(15)

応答時間のワースト15件は、いずれもOpenAMの認証サービスへのリクエストで、15秒ほどかけてHTTPステータス406のレスポンスが返っていました。OpenAMと連携するアプリケーションとの間で問題が発生していたことが分かります。

欠損値の確認

応答時間のワースト15を見ると、size（レスポンスのサイズ）とuser_agent（ユーザーエージェント）がNaNになっています。欠損値がどの程度あるのか確認してみましょう。

df.isnull().sum()

sizeがNaNなものは、リダイレクトなどです。また、3割ほどのuser_agentが不明です。OpenAMにアクセスするのは、エンドユーザーのブラウザーだけではないので、その中には「User-Agent」ヘッダーが未指定なものが多いということでしょう。他にはどのようなユーザーエージェントがあるのか調べてみましょう。

ユーザーエージェントの確認

ua_df = DataFrame(df.groupby(['user_agent']).size().index)
ua_df['count'] = df.groupby(['user_agent']).size().values
ua_df

なんと490種類もありました。エンドユーザーだけでなく、多数のアプリケーションが連携しているので、このような結果になったようです。

アクセスログを視覚化する

ここまで全く視覚化していないので、イマイチ面白くなかったかと思います。円グラフなどで表示してみましょう。まずは、レスポンスのステータスコードの割合を円グラフで描いてみます。

plt.figure(figsize = (5, 5))
labels = ['2xx', '3xx', '4xx', '5xx']
plt.pie(df.groupby([df['status'] // 100]).size(), autopct = '%1.1f%%', labels = labels, shadow = True, startangle = 90)
plt.axis('equal')
df.groupby([df['status'] // 100]).size()
plt.show()

うーん、割合が低いステータスコードのラベルが重なってよく見えないですね...

視覚化のためのユーティリティー関数を定義

ということで、少数の要素（1%以下の割合のもの）を「others」（その他）にまとめる関数を定義しておきます。Matplotlibの機能を使えば、こういった関数は不要かもしれませんが、見つけられなかったので、簡単なものをつくってみました。

# DataFrame用
def replace_df_minors_with_others(df_before, column_name):
    elm_num = 1
    for index, row in df_before.sort_values([column_name], ascending=False).iterrows():
        if (row[column_name] / df_before[column_name].sum()) > 0.01:
            elm_num = elm_num + 1

    df_after = df_before.sort_values([column_name], ascending=False).nlargest(elm_num, columns=column_name)
    df_after.loc[len(df_after)] = ['others', df_before.drop(df_after.index)[column_name].sum()]
    return df_after

# 辞書用
def replace_dict_minors_with_others(dict_before):
    dict_after = {}
    others = 0
    total = sum(dict_before.values())
    for key in dict_before.keys():
        if (dict_before.get(key) / total) > 0.01:
            dict_after[key] = dict_before.get(key)
        else:
            others = others + dict_before.get(key)
    dict_after = {k: v for k, v in sorted(dict_after.items(), reverse=True, key=lambda item: item[1])}
    dict_after['others'] = others
    return dict_after

ユーザーエージェントの視覚化

では、この関数を使用して、次はユーザーエージェントの種類を円グラフで表示してみましょう。

plt.figure(figsize = (15, 10))
ua_df_with_others = replace_df_minors_with_others(ua_df, 'count')
plt.pie(ua_df_with_others['count'], labels = ua_df_with_others['user_agent'], autopct = '%1.1f%%', shadow = True, startangle = 90)
plt.title('User Agent')
plt.show()

「User-Agent」ヘッダーを直接表示しても、イマイチ分かりづらいですね。「Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko」って何でしょう...

ということで、Wootheeというライブラリーを利用して分かりやすい表示に変換してみます。以下のコマンドでインストールします。

$ pip install woothee

これを利用して、クライアントのOSとユーザーエージェントを円グラフで表示してみます。

import woothee

ua_counter = {}
os_counter = {}

for index, row in ua_df.sort_values(['count'], ascending=False).iterrows():
    ua = woothee.parse(row['user_agent'])
    uaKey = ua.get('name') + ' (' + ua.get('version') + ')'
    if not uaKey in ua_counter:
        ua_counter[uaKey] = 0
    ua_counter[uaKey] = ua_counter[uaKey] + 1
    osKey = ua.get('os') + ' (' + ua.get('os_version') + ')'
    if not osKey in os_counter:
        os_counter[osKey] = 0
    os_counter[osKey] = os_counter[osKey] + 1

plt.figure(figsize = (15, 10))
plt.subplot(1,2,1)
plt.title('Client OS')
os_counter_with_others = replace_dict_minors_with_others(os_counter)
plt.pie(os_counter_with_others.values(), labels = os_counter_with_others.keys(), autopct = '%1.1f%%', shadow = True, startangle = 90)

plt.subplot(1,2,2)
plt.title('User Agent')
ua_counter_with_others = replace_dict_minors_with_others(ua_counter)
plt.pie(ua_counter_with_others.values(), labels = ua_counter_with_others.keys(), autopct = '%1.1f%%', shadow = True, startangle = 90)
plt.show()

「UNKNOWN」が増えてしまいましたが、分かりやすくはなったでしょうか。それにしても、いまだにWindowsでIE使ってる人が多いですね...

エラーレスポンスのステータスコードの視覚化

次にエラーとなったレスポンスのステータスコード（400以上）の割合を見てみましょう。

error_df = df[df['status'] >= 400]
plt.figure(figsize = (10, 10))
labels = ['4xx', '5xx']
plt.pie(error_df.groupby([error_df['status'] // 100]).count().time, labels=labels, counterclock=False, startangle=90)

labels2 = ['400', '401', '403', '404', '406', '500', '501', '502']
plt.pie(error_df.groupby(['status']).count().time, labels=labels2, counterclock=False, startangle=90, radius=0.7)

centre_circle = plt.Circle((0,0),0.4, fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)
plt.title('Error Status Code')
plt.show()

一般的にはあまり見慣れないステータスコード406のエラーレスポンスが多いのが、このアクセスログの特徴ですね。

負荷の状況の視覚化

では、違うグラフを出力してみましょう。まずは負荷の状況を確認します。

plt.figure(figsize = (15, 5))
access = df['request']
access.index = df['time']
access = access.resample('S').count()
access.index.name = 'Time'
access.plot()
plt.title('Total Access')
plt.ylabel('Access')
plt.show()

コンスタントにアクセスがあり、時々秒間100件以上を超えるような状況です。

レスポンスのサイズと時間の関係性の視覚化

レスポンスのサイズと時間に何らかの関係性があるか見てみましょう。

plt.figure(figsize = (15, 5))
plt.title('size v.s. response_time')
plt.scatter(df['size']/1000, df['response_time']/1000000, marker='.')
plt.xlabel('Size(KB)')
plt.ylabel('Response Time')
plt.grid()

明確な関係性は無いものの、レスポンスのサイズが0でなければ、サイズが大きいほど時間がかかる傾向が無いとも言えないですね。

最後に

アクセスログの解析にPandasとMatplotlibは使えると思います。これらのライブラリーを使いこなせるようになれば、トラブルシューティングにも十分に活用できそうです。

まだ思い付きでつくった試作段階ですが、GitHubにもコミットしておきます。

Deep Learningのフレームワークといえば，PyTorch，Tensorflow，Kerasなどたくさんの種類があります．
今回は，その中でも私がよく使わせていただいてるPyTorchに注目していこうと思います！

実はこのPyTorch，Python版だけではなく，C++版がリリースされているのはご存知でしょうか？
このおかげで，もしC++のプログラムの処理の一部としてDeep Learningを使いたいとなったときに，容易に組み込むことができるようになるのです！

そんなC++版のPyTorchですが，私は「C++はコンパイル型言語だからもしかしたらPython版より速いのでは？」と気になりました．

そこで，今回は実際に「C++とPythonでどのくらい速度に差が有るのか？」を調べてみました！
また，精度についても気になったのでついでに調べてみました．

比較実験に使用するもの

フレームワーク

今回は表題の通り「PyTorch」のC++版を使用します．
以下のサイトからダウンロードできるのでしてみてください！

PyTorch公式：https://pytorch.org/

私は以上のような設定でダウンロードしました．
「Preview（Nightly）版」は常に最新のファイルが置かれるようになっています．
しかし，開発途中のものであるため，安定版を使用したい場合は「Stable（1.4）」を選択しましょう．

また，一番下の「Run this Command」が結構重要で，CXXのビルドバージョンが11以上の人は下の方を選択するのをおすすめします．
現在はほとんどCXX17なので，下で大丈夫かと思います．
上を選ぶと，他のライブラリのリンクエラー等が発生して色々大変です．

モデル

今回は，畳み込みオートエンコーダ（Convolutional Autoencoder）を使用します．
私のGitHubから取得可能→https://github.com/koba-jon/pytorch_cpp

このモデルは，入力画像（高次元）を潜在空間（低次元）に写像し，今度はこの潜在変数（低次元）をもとに画像（高次元）を生成し，これと入力画像との誤差を最小化することが目的です．
学習を終えたこのモデルは，高次元の画像から低次元の空間を通って再び高次元の画像を生成できるため，学習用画像をより特徴付ける潜在空間を得ることができています．
つまり，次元圧縮の役割があり，いわゆる非線形的な主成分分析とも言えます．
これは，次元の呪いの解消，転移学習，異常検知のような様々な用途があり非常に便利です．

それでは，使用するモデルの構造について説明します．

• 画像のサイズが，1度の畳み込みで1/2倍，逆畳み込みで2倍
• 学習の安定化・収束の加速化
• 潜在変数の取り得る範囲が実数全て
• 画素値の取り得る範囲が[-1, 1]

これらの効果を期待して，以下のネットワークを構築しました．

Operation		Kernel Size	Stride	Padding	Bias	Feature Map		BN	Activation
						Input	Output
1	Convolution	4	2	1	False	3	64		ReLU
2						64	128	True	ReLU
3						128	256	True	ReLU
4						256	512	True	ReLU
5						512	512	True	ReLU
6						512	512
7	Transposed Convolution					512	512	True	ReLU
8						512	512	True	ReLU
9						512	256	True	ReLU
10						256	128	True	ReLU
11						128	64	True	ReLU
12						64	3		tanh

データセット

• CelebA（Large-scale CelebFaces Attributes）データセット
  http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html

今回は，セレブなお方の顔画像（カラー）を202,599枚集めたデータセットであるCelebAデータセットを使用します．
画像サイズが178×218[pixel]と，逆畳み込みの際に少々不都合が生じるため，今回は64×64[pixel]にリサイズしました．
また，その内9割（182,340枚）を学習用画像に，1割（20,259枚）をテスト用画像に使用しました．

これを先ほどのモデルに入力すると，潜在空間は（C,H,W）＝（512,1,1）となります．もし，128×128[pixel]またはそれ以上の画像を入力した場合，中間層はSpatialな潜在空間になります．

比較対象

今回は，「C++とPythonでどの程度速度が異なるのか」を調査するのがメインですが，以下の5種類の環境下での速度および性能も加えて比較していきたいと思います．

• CPUメイン稼働
  • Python
  • C++
• GPUメイン稼働
  • Python
    • 非決定論的
    • 決定論的
  • C++

1. メインで稼働させるユニットの違い（CPU or GPU）

• CPU
  「直列的で」「複雑な」命令を処理するのが得意
• GPU
  「並列的で」「単純な」命令を処理するのが得意

以上の特徴から分かる通り，画像を扱うDeep Learningでは，計算速度において圧倒的にGPUが有利であることが分かります．

(1) Pythonによる実装

• CPUを使用する場合

CPU.py

device = torch.device('cpu')  # CPUを使用

model.to(device)  # モデルをCPUに移す
image = image.to(device)  # データをCPUに移す

• GPUを使用する場合

GPU.py

device = torch.device('cuda')    # デフォルトのGPUを使用
device = torch.device('cuda:0')  # 1番目のGPUを使用
device = torch.device('cuda:1')  # 2番目のGPUを使用

model.to(device)  # モデルをGPUに移す
image = image.to(device)  # データをGPUに移す

(2) C++による実装

• CPUを使用する場合

CPU.cpp

torch::Device device(torch::kCPU);  // CPUを使用

model->to(device);  // モデルをCPUに移す
image = image.to(device);  // データをCPUに移す

• GPUを使用する場合

GPU.cpp

torch::Device device(torch::kCUDA);     // デフォルトのGPUを使用
torch::Device device(torch::kCUDA, 0);  // 1番目のGPUを使用
torch::Device device(torch::kCUDA, 1);  // 2番目のGPUを使用

model->to(device);  // モデルをGPUに移す
image = image.to(device);  // データをGPUに移す

2.決定論的か否かの違い（GPUメイン稼働＆Pythonに限る）

Python版のPyTorchには，GPUを用いた学習の場合，cuDNNを用いて学習の速度を向上させるという操作がされています．

しかし，C++とは異なり，学習の速度が向上するからと言って，再び学習を回したら必ずしも全く同じ状況を再現できるとは限りません．

そこで，PyTorch公式は，再現性を担保するためには以下のようにcuDNNの挙動を決定論的にする必要があり，それと同時に速度が低下すると明言しています．

https://pytorch.org/docs/stable/notes/randomness.html

Deterministic mode can have a performance impact, depending on your model. This means that due to the deterministic nature of the model, the processing speed (i.e. processed batch items per second) can be lower than when the model is non-deterministic.

エンジニアの立場においては，再現性の有無について気にする場合があるため，また再現性の有無によって速度に変化が生じるため，今回の速度の比較に含めました．

C++の「rand」関数とは異なり，乱数の初期値を何も設定しないとランダムになってしまうので，Pythonで再現性を担保するためには，明示的に乱数の初期値を設定する必要があります．
（乱数の初期値の設定が速度に影響を与えることはありません．）

実装については以下の通りです．

• 決定論的な場合

deterministic.py

seed = 0
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True  # 速度が低下する代わりに決定論的
torch.backends.cudnn.benchmark = False     # 速度が低下する代わりに決定論的

• 非決定論的な場合

non_deterministic.py

torch.backends.cudnn.deterministic = False  # 非決定論的である代わりに高速化
torch.backends.cudnn.benchmark = True       # 画像サイズが変化しない場合に高速化

3. プログラミング言語間の実装の違い

実装したい内容自体が同じでもプログラミング言語が変わることで，記法やルールが変わったり，必要なライブラリが変わったり，ということが発生します．
PythonとC++は共にオブジェクト指向言語なので概念自体は似ていますが，何よりPythonはインタプリタ型，C++はコンパイル型なので，C++に動的型付けが通用しないことを踏まえながら実装しなければなりません．
また，PyTorchのC++ APIは現在発展途上であるため，一部の機能が整備されてないことも考慮しなければいけません．

これらの点を踏まえ，Python，C++間での実装の違い，および私が実装したプログラムについて紹介します．

(1) ライブラリの使用状況

現在一般的に書かれているPythonのライブラリの使用状況に加え，C++で実装する場合に推奨するライブラリ，および私が実際に書いたプログラムのライブラリの使用状況についても記載します．

	Python（推奨）	C++（推奨）	C++（自作）
コマンドライン引数の処理	argparse	boost::program_options	boost::program_options
モデルの設計	torch.nn	torch::nn	torch::nn
前処理（transform）	torchvision.transforms	torch::data::transforms（実行前に多彩な前処理する場合） or 自作（実行後に多彩な前処理する場合）	自作（OpenCV使用）
データセットの取得（datasets）	torchvision.datasets（Pillow使用）	自作（OpenCV使用）	自作（OpenCV使用）
データローダー（dataloader）	torch.utils.data.DataLoader	torch::data::make_data_loader（クラス分類の場合） or 自作（クラス分類以外の場合）	自作（OpenMP使用）
損失関数（loss）	torch.nn	torch::nn	torch::nn
最適化手法（optimizer）	torch.optim	torch::optim	torch::optim
誤差逆伝搬法（backward）	torch.Tensor.backward()	torch::Tensor::backward()	torch::Tensor::backward()
プログレスバー	tqdm	boost	自作

現時点（2020/03/24）では，以上のような感じになります．

PyTorchのライブラリをC++で使う場合は，クラス名や関数名がPythonとほとんど同じです．
これは，製作者側がユーザーに配慮してのことだそうです．非常にありがたいですね！

次に，C++でPyTorchのプログラムを書く際に，特に気をつけたほうが良い点について記載します．

(2) モデルの設計

以下，私が書いたプログラムの一部を抜粋して記載します．

networks.hpp（一部抜粋）

using namespace torch;
namespace po = boost::program_options;

struct ConvolutionalAutoEncoderImpl : nn::Module{
private:
    nn::Sequential encoder, decoder;
public:
    ConvolutionalAutoEncoderImpl(po::Variables_map &vm);
    torch::Tensor forward(torch::Tensor) x;
}

TORCH_MODULE(ConvolutionalAutoEncoder);

モデルを設計する際は，Python同様に「torch::nn」クラスを使用します．
また，モデルを作成する際は構造体を使用します．（クラスのバージョンもありますが，少し複雑になるっぽい）
この際に注意するべきことがPython同様に，nn::Moduleを継承するということです．
ここについては，Pythonの書き方と同じですね．

次に重要なのが，構造体の名前を「[モデル名]Impl」にし，構造体の下に「TORCH_MODULE([モデル名])」を追加 することです．
これをしないと，モデルを保存したり，読み込んだりすることができなくなります．
また，「TORCH_MODULE([モデル名])」とすることで普通の構造体「ConvolutionalAutoEncoderImpl」をモデル用の構造体「ConvolutionalAutoEncoder」として宣言できるようになりますが，おそらく内部でクラスの継承をさらにおこなっている？（予想）ため，メンバ変数にアクセスする場合は「model->to(device)」のように，「->」（アロー演算子）を使う必要があるので注意してください．

次に，上記の件に関連しますが，nnクラスのモジュールを使用する際の注意点について説明します．
Python同様に「nn::Sequential」を使用することができます．C++で「nn::Sequential」にモジュールを追加していくためには，vector型のように「push_back」を使います．
ここで，「push_back」関数を呼ぶためには，「->」（アロー演算子）を使用することに気をつけてください．
実装例は以下のような感じです．

networks.cpp（一部抜粋・改変）

nn::Sequential sq;
sq->push_back(nn::Conv2d(nn::Conv2dOptions(3, 64, /*kernel_size=*/4).stride(2).padding(1).bias(false)));
sq->push_back(nn::BatchNorm2d(64));
sq->push_back(nn::ReLU(nn::ReLUOptions().inplace(true)));

(3) transform・datasets・dataloaderの自作

transform，datasets，dataloaderを自作する上では，テンソル型のデータを他の変数に渡す際に「.clone()」を使って渡すことです．私はここでハマりました．
テンソル型は計算グラフを扱う関係で？（予想），このように設定しないとテンソル内の値が変わる可能性があります．

transforms.cpp（一部抜粋）

void transforms::Normalize::forward(torch::Tensor &data_in, torch::Tensor &data_out){
    torch::Tensor data_out_src = (data_in - this->mean) / this->std;
    data_out = data_out_src.clone();
    return;
}

(4) その他のプログラム

その他のプログラムについては，ほとんどPython版と同じでハマるところは特にありません．
また，Python版とは異なる部分で少し使いにくいなと思ったクラスは自作しました．
具体的なプログラムは，以下のGitHubから見れますので参考にしてください．
https://github.com/koba-jon/pytorch_cpp/tree/master/ConvAE

もしかしたら，ソースコードの解説記事も書くかもしれません．
もし，「ここがおかしい」という意見がありましたら，大歓迎ですので是非コメントしてください．

プログラミング言語間で共通化させた項目

基本的には，Pythonで有るライブラリがC++には無いといったように，どうしようもない箇所以外は，ほとんど同じと思ってもらって構いません．
また，GitHubのプログラムから変えてないと思ってもらって結構です．

具体的には，Python版とC++版を比較する上で，以下の内容を共通化させました．

• 画像サイズ（64×64×3）
• 画像の種類（学習方法Aの画像群＝学習方法Bの画像群）
• バッチサイズ（16）
• 潜在空間のサイズ（1×1×512）
• 最適化手法（Adam，learning rate=0.0001，β1=0.5，β2=0.999）
• モデルの構造
• モデルの初期化方法
  • 畳み込み層，逆畳み込み層：平均0.0，標準偏差0.02
  • バッチノーマライゼーション：平均1.0，標準偏差0.02
• データのロード方法
  • 「datasets」クラスの初期化時にはパスのみ取得し，実際に動作させる時に初めてパスをもとに画像を読み込む．
  • 「datasets」クラスの稼働時に，1組のデータ（1枚の画像と1個のパス）のみを読み込む．
  • 「datasets」クラスの稼働時に，「transform」を実行する．
  • 「DataLoader」クラスの稼働時に，並列的にミニバッチのデータを「datasets」クラスから読み込む．
• データセットのシャッフル方法
  • 学習時はシャッフルするが，推論時はシャッフルしない．
  • エポックごとに，データを入力する一番最初にシャッフルする．

実験結果

比較する各対象において，celebAの64×64の画像182,340枚を用いて，L1誤差を最小化するように，1[epoch]だけ畳み込みオートエンコーダモデルをミニバッチ学習させました．
その際の「1[epoch]当たりの時間」および「GPUのメモリ使用量」を調べました．

ここで，「1[epoch]当たりの時間」はtqdmや自作した関数の処理時間も含まれています．
これについては，それが合計の処理時間にほとんど影響を与えなかったという点と，実際にPyTorchを使うときはビジュアライズもあったほうが便利だから使う人が多い点から含めました．

また，その学習済みモデルを用いて，テスト画像20,259枚を使って1枚ずつモデルに入力し，テストしました．
その際の「順伝搬の平均速度」および「入力画像と出力画像のL1誤差」も調べました．

そして，「実行ファイル」と「nvidia-smi」以外のものは一切立ち上げずに（Ubuntu起動時に最初から稼働しているものはそのまま），学習・テストしました．

		CPU（Core i7-8700）		GPU（GeForce GTX 1070）
		Python	C++	Python		C++
				非決定論的	決定論的
学習	時間[time/epoch]	1時間04分49秒	1時間03分00秒	5分53秒	7分42秒	17分36秒
	GPUメモリ[MiB]	2	9	933	913	2941
テスト	速度[seconds/data]	0.01189	0.01477	0.00102	0.00101	0.00101
	L1誤差（MAE）	0.12621	0.12958	0.12325	0.12104	0.13158

C++はコンパイル型言語です．
したがって，インタプリタ型言語のPythonに勝つ...かと思いきやどちらもいい勝負でした．

学習時間に関しては，CPUはほとんど同じ，GPUはC++がPythonより2倍以上遅いことがわかりました．（なぜ？）
この結果ですが，CPUは同じくらいでGPUのときだけ大きく異なるので，PyTorch C++版のGPUにおける処理の整備が完璧になっておらず，GPUによる順伝搬，逆伝搬が最適化されていない可能性，あるいはCPUで得たミニバッチのデータをGPUに移す際に時間がかかっている，という可能性がありそうです．

GPUのメモリ使用量もなぜか多いです．（ReLUのinplaceをTrueにしてるのに...）

また，推論（テスト）の速度や性能についてもPythonとほとんど変化ないため，現状はPythonで全然問題ないかもしれません．

Python（GPU）の決定論的・非決定論的の結果ですが，公式が明言している通り決定論的のほうが遅くなりました．
やはり，ここの時間は変わりますね．

結論

• 学習速度
  

  • 1位：Python版（非決定論的，GPUメイン稼働）
    
  • 2位：Python版（決定論的，GPUメイン稼働）
    
  • 3位：C++版（GPUメイン稼働）
    
  • 4位：CPUメイン稼働（Python版，C++版 同程度）
    
    

• 推論速度
  

  • 1位：GPUメイン稼働（Python版，C++版 同程度）
    
  • 2位：CPUメイン稼働（Python版，C++版 同程度）
    
    

• 性能
  

  • どれも同程度

おわりに

今回はPyTorchのPython版とC++版で，速度と性能を比較しました．

その結果，性能においてはPythonとC++はほとんど変わらないため，C++のPyTorchを使っても問題ないと思いました．
しかし，現段階では，速度を求めてC++のPyTorchをやるというのは，あまりオススメできないかもしれません．

もしかしたら，C++のAPIはまだ発展途上であるため，今後大幅に改善されるかもしれませんね！
今後に期待です！

参考URL

• https://pytorch.org/cppdocs/
• https://orizuru.io/blog/deep-learning/pytorch-cpp_01/
• https://www.noconote.work/entry/2019/01/08/200120
• https://github.com/pytorch/examples/tree/master/cpp

Python / 機械学習初心者です。
データ分析をしようと意気込んだ結果、欠損値の確認を怠ったことでつかえてしまったので反省としてメモを残します。

結論

• データ分析に入る前に、欠損値の有無の確認を行うべきである
• 欠損値が見られる場合は、欠損値以外のデータを上書きするか、欠損値が含まれる行を除外して分析をするなど、何らかの対策をとるべきである

起こったこと

• Kaggleというデータ分析コンテストに参加した際、すべて目視で確認することができない量のデータを分析した
• その際、欠損値(NaN)の存在に気づかず、プログラムが大量のNaNだらけになってしまい、エラーが止まらなかった

欠損値とは

• Not a Number / NaN
• 計算の処理結果が表せない場合の特殊表現
  • 詳細を追おうとすると大変にディープな勉強が必要そうなので、本稿ではふれません
• 他の数との演算結果をNaNで返す性質があるため、プログラム内に1つでもNaNが含まれると、計算結果が正しく求められなくなる可能性がある
  • 1 + NaNの演算結果はNaNである

対策 - データ分析開始時のすすめ

• ①まず、何よりも最初に、データの欠損値の有無を確認する
• isnull().any()を活用する
  • データフレームにおいて、欠損値が含まれる列を教えてくれる
  • 下記の用にdf_exampleに対して欠損値を確認すると、人口やGDPについては欠損値の存在をTrueで確認できる(北朝鮮の人口が正確にわからないのかな、などと想像も出来る)

#例:countries.csvに各国の基礎統計データが入っているとする
import pandas as pd
df_example = pd.read_csv("hogehoge/example.csv").copy()

print(df_example.isnull().any())

#例
Id            False
Name          False
Population    True
GDP           True
Region        False
life_expct    False

• ②欠損値の存在が確認された列において置換作業を行う
  • 列全体がNaNで構成される場合の別の削除方法や、欠損値の置換ではなく行自体の削除を行う場合の処理は割愛します。

# 欠損値存在列が判明したところで
df_example.loc[df_example['Population'].isnull(), 'Population'] = 0

注意

• この場合、置換する先の値が適切なものかどうか、後の計算で何を留意するべきか、注意されたい。
• 例えば、上記のように人口を0と置換した場合、2パターンありえるだろう:
  • 「このデータは人口の多い国TOP30をに対して分析するからこれで問題がない」
  • 「このデータからは平均人口を割り出す分析をするから、その際は『人口の値が0でない国』のみを計算対象にして、分母分子の値に不備の内容にしよう」

まとめ

• データを与えられたら、それにとびついていきなり分析をはじめるのではなく、欠損値の確認から行うことが大切。

参考

• pandasで欠損値NaNが含まれているか判定、個数をカウント
• pandasで欠損値NaNを除外（削除）・置換（穴埋め）・抽出

(以上)

---

補言

• 筆者はディープラーニングの入力層に欠損値がまぎれこんでしまったために、後の分析が全く有用でなくなるという経験をし、本稿を書くに至りました。
• 欠損値の確認以外にも、ヒストグラムを描いて外れ値を探すなど、分析前の確認工程・データクレンジングの工程は多々あるかと思います。本稿では2020/03/24時点では言及を控えましたが、それらについても調べたうえでいずれ追記したいと考えています。

概要

本記事では，GCEのUbuntuにおいて，Python環境を作ります．
（vimの設定等は適宜ご自身で行ってください．）
具体的にやることは以下です．

• サービスアカウント→ユーザーアカウントに変更
• zshを入れる
• Pythonを入れる
• Powerline-shellでカスタマイズ
• Jupyter notebookを使えるようにする
• Stackdriver Monitoring Agentを入れる．

初期設定

初期状態では，サービスアカウントが内部で使われます．
色々と面倒なので，自分のユーザーアカウントでログインしておくことを推奨します．

gcloud init

色々聞かれるので，言われたとおりに認証して，verification codeを貼ります．

zshの導入

まず，zshをinstallします．

sudo apt-get install zsh -y

その後，デフォルトのshellをzshにしたいのですが，パスワードがわからないため， chshコマンドが動きません．（やり方あったら教えて欲しい）
そのため，

vim ~/.bashrc

などでbashrcを開いて，末尾に

exec /usr/bin/zsh

を挿入します．これでデフォルトのshellがzshになりました．

oh-my-zshを入れる

続いて，oh-my-zshを入れます．
（個々人のこだわりがあるかと思うので，こだわりのあるかたは Python環境の構築 までスキップしてください．）

sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

デフォルトのシェルを変えるかみたいなこと聞いてきますが当然 no にしてください．

外部プラグインとして，以下を入れます．

• zsh-syntax-highlight
• zsh-autosuggest
• zsh-history-substring-search
• zsh-completions

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-history-substring-search ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-history-substring-search
git clone https://github.com/zsh-users/zsh-completions ${ZSH_CUSTOM:=~/.oh-my-zsh/custom}/plugins/zsh-completions

一旦ここで，zshrcを変更しましょう．

~/.zshrc

export ZSH="${HOME}/.oh-my-zsh"
ZSH_THEME="candy"
plugins=(
  git pip pyenv virtualenv zsh-syntax-highlighting zsh-autosuggestions history-substring-search zsh-completions
)
source $ZSH/oh-my-zsh.sh

編集したら，一旦読み込みます．

source ~/.zshrc

Python環境の構築

pyenvとvirualenvを使ったよくある仮想環境構築を行います．
まずは，pyenvとvirtualenvをインストールします．

sudo apt-get install -y make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev
git clone https://github.com/pyenv/pyenv.git ~/.pyenv
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshenv
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshenv
echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init -)"\nfi' >> ~/.zshenv
source ~/.zshenv
git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.zshenv
source ~/.zshenv

好きなバージョンのPythonをインストールします．
例えばこのような感じ．

pyenv install 3.6.5
pyenv virtualenv 3.6.5 default_env
pyenv global default_env

powerline-shellのインストール

ここもこだわりがある人はSkipしてください．
まず，現在の仮想環境にpowerline-shellを入れます．

pip install powerline-shell

その後，再びzshrcを以下のように編集してください．

~/.zshrc

export ZSH="${HOME}/.oh-my-zsh"
ZSH_THEME="candy"

function powerline_precmd() {
    PS1="$(powerline-shell --shell zsh $?)"
}
function install_powerline_precmd() {
  for s in "${precmd_functions[@]}"; do
    if [ "$s" = "powerline_precmd" ]; then
      return
    fi
  done
  precmd_functions+=(powerline_precmd)
}
if [ "$TERM" != "linux" ]; then
    install_powerline_precmd
fi

plugins=(
  git pip pyenv virtualenv zsh-syntax-highlighting zsh-autosuggestions history-substring-search zsh-completions
)
source $ZSH/oh-my-zsh.sh

export LC_ALL="en_US.UTF-8"
export LANG=ja_JP.UTF-8

#---------------------- 以下，私的設定なので割愛してください ----------------------#
#historyファイル指定
HISTFILE=$HOME/.zsh-history
HISTSIZE=1000
SAVEHIST=10000

#コマンドじゃなければ cd する
setopt auto_cd
# 補完候補を一覧表示
setopt auto_list
# TAB で順に補完候補を切り替える
setopt auto_menu
# カッコの対応などを自動的に補完
setopt auto_param_keys
# ディレクトリ名の補完で末尾の / を自動的に付加し、次の補完に備える
setopt auto_param_slash
# コマンドミスった時のcorrect
setopt correct
# 補完候補一覧でファイルの種別をマーク表示
setopt list_types
# 明確なドットの指定なしで.から始まるファイルをマッチ
setopt globdots
# ファイル名の展開でディレクトリにマッチした場合 末尾に / を付加
setopt mark_dirs
# 語の途中でもカーソル位置で補完
setopt complete_in_word
# カーソル位置は保持したままファイル名一覧を順次その場で表示
setopt always_last_prompt
# ビープを鳴らさない
setopt nobeep
# vcs有効化
setopt prompt_subst
# #以降をコメントとして扱う
setopt interactive_comments
# ヒストリの共有
setopt share_history
# ヒストリに追加されるコマンドが古いものと同じなら古いものを削除
setopt hist_ignore_all_dups

更にカスタマイズします．

mkdir -p ~/.config/powerline-shell && powerline-shell --generate-config > 

以下の2ファイルを作成します．

~/.config/powerline-shell/original_color.py

from powerline_shell.themes.default import DefaultColor
​
​
class Color(DefaultColor):
    USERNAME_FG = 15
    USERNAME_BG = 4
    USERNAME_ROOT_BG = 1
​
    HOSTNAME_FG = 15
    HOSTNAME_BG = 10
​
    HOME_SPECIAL_DISPLAY = False
    PATH_FG = 15
    PATH_BG = 70
    CWD_FG = 231
    SEPARATOR_FG = 0
​
    READONLY_BG = 1
    READONLY_FG = 7
​
    REPO_CLEAN_FG = 14
    REPO_CLEAN_BG = 0
    REPO_DIRTY_FG = 3
    REPO_DIRTY_BG = 0
​
    JOBS_FG = 4
    JOBS_BG = 8
​
    CMD_PASSED_FG = 255
    CMD_PASSED_BG = 136
    CMD_FAILED_FG = 255
    CMD_FAILED_BG = 1
​
    SVN_CHANGES_FG = REPO_DIRTY_FG
    SVN_CHANGES_BG = REPO_DIRTY_BG
​
    VIRTUAL_ENV_BG = 31
    VIRTUAL_ENV_FG = 231
​
    AWS_PROFILE_FG = 7
    AWS_PROFILE_BG = 2
​
    TIME_FG = 255
    TIME_BG = 246

~/.config/powerline-shell/config.json

{
    "segments": [
        "virtual_env",
        "aws_profile",
        "ssh",
        "cwd",
        "git",
        "git_stash",
        "jobs",
        "read_only",
        "newline",
        "set_term_title",
        "svn",
        "time",
        "exit_code"
    ],
    "cwd": {
        "max_depth": 4,
        "max_dir_size": 10,
        "full_cwd": 1
    },
    "mode": "patched",
    "theme": "~/.config/powerline-shell/original_color.py"
}

注意

• 仮想環境内にpowerline-shellがないとおかしくなりますので毎回 pip install してください．
• 文字化けする場合は，以下を参考にフォントを入れるとなおります．（自分はRoboto Mono for Powerlineを使ってます）
  • https://github.com/powerline/fonts

Jupyter Notebookの設定

そのままだとJupyterが使えないので設定します．
以下のサイトのjupyterの設定以降を行えばJupyterを使えます．
参考：https://rf00.hatenablog.com/entry/2018/01/01/160820

※sshが切れるとJupyterが落ちちゃうので，tmuxを立ててその中でJupyterを使うことを推奨します．

Stack Driver Monitoring Agentを入れる

GCEのリソース監視にStack Driver Monitoring Agentをお勧めします．
入れると詳しいメモリー使用率などがこちらの右上のHOSTタブの隣のAgentタブから確認できるようになります．
（ただし，別途課金がかかるので注意）

公式の通りにインストールします．
デフォルトだと1分ごとにデータを送信しますが，課金量が気になるので3分毎にデータを送信するように変更します．

sudo vim /etc/stackdriver/collectd.conf

/etc/stackdriver/collectd.conf

Interval 180  # Interval 60から変更

# 以下変更なし

はじめに

前回は、いろいろなボタンについて紹介をしました。またボタン関係です。以前、ボタンに画像をはっつけようとしてうまくできなかったので、ちょっと調べてみました。備忘録的な感じになると思います。ついでに、使い方の例を示したいと思います(タイトルの内容がメインではないものが出来上がってしまいましたが。。。)

間違えていた方法

単純にButtonのウィジェットにImageをadd_widgetして使おうとしてました。こんな感じになると思います。画像の後ろにボタンががっつり写ってしまい不恰好な感じがしますね。（たぶんいろいろ書けば、見た目はなんとかなるかもしれませんが）それと、ボタンの位置をずらすと、画像がついてきてくれなかったりと訳が分からないです。そのため、以前は実装を諦めてしまいました。

やることこんな感じになります。

画像ボタンはこう作る！

画像ボタンを作るにはkivy.uix.behaviorsというモジュールを用います。behaviors.ButtonBehaviorを用いることで、ラベルや画像などにボタンの機能を付与することができます。そのほかにも色々できるようです！
https://kivy.org/doc/stable/api-kivy.uix.behaviors.html

ソースコードは、下記の通りです。behaviors.ButtonBehaviorとボタンにしたいもの、ここではImageを継承した新しいクラスを作成します。そしてImageの画像を変更し、ボタンを押した時の画像、話した時の画像を指定してあげるとうまいこと動作します。

from kivy.app import App
from kivy.uix.image import Image
from kivy.uix.behaviors import ButtonBehavior


class MyButton(ButtonBehavior, Image):
    def __init__(self, **kwargs):
        super(MyButton, self).__init__(**kwargs)
        # 適当な画像
        self.source = 'data/val2017/000000000285.jpg'

    def on_press(self):
        # 押した時の画像
        self.source = 'data/val2017/000000000776.jpg'

    def on_release(self):
        # 元の画像に戻す
        self.source = 'data/val2017/000000000285.jpg'


class SampleApp(App):
    def build(self):
        return MyButton()


SampleApp().run()

トグルボタンを使いたい場合には、ToggleButtonBehaviorを継承してください。

from kivy.app import App
from kivy.uix.image import Image
from kivy.uix.behaviors import ToggleButtonBehavior


class MyButton(ToggleButtonBehavior, Image):
    def __init__(self, **kwargs):
        super(MyButton, self).__init__(**kwargs)
        self.source = 'data/val2017/000000000285.jpg'

    def on_state(self, widget, value):
        if value == 'down':
            self.source = 'data/val2017/000000000776.jpg'
        else:
            self.source = 'data/val2017/000000000285.jpg'


class SampleApp(App):
    def build(self):
        return MyButton()


SampleApp().run()

画像ボタンを使って作ったもの

画像ボタンの作り方を調べているうちに、いつの間にか画像ビュアーができていました。
イメージはこんな感じです。

任意の画像フォルダーの画像をスクロールビューに全て表示して、クリックした画像ボタンの画像が上のImageに表示されるような感じです。

ソース

できたものは下のような感じです。

import os
import cv2
import numpy as np

from kivy.app import App
from kivy.uix.image import Image
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.gridlayout import GridLayout
from kivy.uix.scrollview import ScrollView
from kivy.uix.behaviors import ToggleButtonBehavior
from kivy.clock import Clock
from kivy.graphics.texture import Texture

#画像ボタンクラス
class MyButton(ToggleButtonBehavior, Image):
    def __init__(self, **kwargs):
        super(MyButton, self).__init__(**kwargs)
        #画像ボタンの画像名を格納
        self.source = kwargs["source"]
        #画像を編集できるようにテクスチャーとして扱う
        self.texture = self.button_texture(self.source)

    # トグルボタンの状態、状態によって画像が変化する
    def on_state(self, widget, value):
        if value == 'down':
            self.texture = self.button_texture(self.source, off=True)
        else:
            self.texture = self.button_texture(self.source)

    # 画像を変化させる、押した状態の時に矩形+色を暗く
    def button_texture(self, data, off=False):
        im = cv2.imread(data)
        im = self.square_image(im)
        if off:
            im = self.adjust(im, alpha=0.6, beta=0.0)
            im = cv2.rectangle(im, (2, 2), (im.shape[1]-2, im.shape[0]-2), (255, 255, 0), 10)

        # 上下反転
        buf = cv2.flip(im, 0)
        image_texture = Texture.create(size=(im.shape[1], im.shape[0]), colorfmt='bgr')
        image_texture.blit_buffer(buf.tostring(), colorfmt='bgr', bufferfmt='ubyte')
        return image_texture

    # 画像を正方形にする
    def square_image(self, img):
        h, w = img.shape[:2]
        if h > w:
            x = int((h-w)/2)
            img = img[x:x + w, :, :]
        elif h < w:
            x = int((w - h) / 2)
            img = img[:, x:x + h, :]

        return img

    # 画像の色を暗くする
    def adjust(self, img, alpha=1.0, beta=0.0):
        # 積和演算を行う。
        dst = alpha * img + beta
        # [0, 255] でクリップし、uint8 型にする。
        return np.clip(dst, 0, 255).astype(np.uint8)


class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)
        # 読み込むディレクトリ
        image_dir = "data/val2017"

        # 縦配置
        self.orientation = 'vertical'

        # 画像ファイルの名前を管理
        self.image_name = ""

        # 画像を表示するウィジェットの準備
        self.image = Image(size_hint=(1, 0.5))
        self.add_widget(self.image)

        # 画像ボタンを配置する、スクロールビューの定義
        sc_view = ScrollView(size_hint=(1, None), size=(self.width, self.height*4))

        # スクロールビューには１つのウィジェットしか配置できないため
        box = GridLayout(cols=5, spacing=10, size_hint_y=None)
        box.bind(minimum_height=box.setter('height'))

        # 画像ボタンの一括定義、グリッドレイアウトに配置
        box = self.image_load(image_dir, box)

        sc_view.add_widget(box)
        self.add_widget(sc_view)

    # 画像ボタンの読み込み
    def image_load(self, im_dir, grid):
        images = sorted(os.listdir(im_dir))

        for image in images:
            button = MyButton(size_hint_y=None,
                              height=300,
                              source=os.path.join(im_dir, image),
                              group="g1")
            button.bind(on_press=self.set_image)
            grid.add_widget(button)

        return grid

    # 画像をボタンを押した時、画像ウィジェットに画像を表示
    def set_image(self, btn):
        if btn.state=="down":
            self.image_name = btn.source
            #画面を更新
            Clock.schedule_once(self.update)

    # 画面更新
    def update(self, t):
        self.image.source = self.image_name


class SampleApp(App):
    def build(self):
        return Test()


SampleApp().run()

少し解説

上の説明では、　ボタンの画像が切り替わるだけで、ボタンが押されているのかよく分からない状態だったと思います。そこで、画像を押した時に枠がついて画像が少し暗くなって押したことがわかるような処理を追加しました。また、グリッドレイアウトに綺麗に並べるために、画像の中心でトリミングする処理も加えております。

画像ボタンクラスには、ボタンとなる画像のファイル名を格納している変数sourceがあり、それを用いてこの関数で画像名からopencvで画像の処理をします。また、処理した画像を使うには、textureを使う必要があるため、返り値にtextureを指定しております。

※textureについてはその3で解説したので今回は省略いたします。

    # 画像を変化させる、押した状態の時に矩形+色を暗く
    def button_texture(self, data, off=False):
        im = cv2.imread(data)
        im = self.square_image(im)
        if off:
            im = self.adjust(im, alpha=0.6, beta=0.0)
            im = cv2.rectangle(im, (2, 2), (im.shape[1]-2, im.shape[0]-2), (255, 255, 0), 10)

        # 上下反転
        buf = cv2.flip(im, 0)
        image_texture = Texture.create(size=(im.shape[1], im.shape[0]), colorfmt='bgr')
        image_texture.blit_buffer(buf.tostring(), colorfmt='bgr', bufferfmt='ubyte')
        return image_texture

アプリ側のボタンを押した時の処理ですが、ボタンを押した時に、画面上部のImageのsourceを変更するだけでは、画像は変化しません。画像を変えるためには、画面を更新する必要が必要です。そのため、画像を押した時に、Clockを一度動かして画面を更新しております。

    # 画像をボタンを押した時、画像ウィジェットに画像を表示
    def set_image(self, btn):
        if btn.state=="down":
            self.image_name = btn.source
            #画面を更新
            Clock.schedule_once(self.update)

    # 画面更新
    def update(self, t):
        self.image.source = self.image_name

参考文献

・OpenCV - 画像の明るさやコントラストを変更、ガンマ補正など - Pynote
　画像を暗くする処理のソースを参考にいたしました。

・COCO Dataset
　今回使用させていただいた画像のリンクです。