前提となる環境

* Windows 10 Home Edition
* Docker Toolbox

やったこと

1. Angular+Node用のDockerfile及びimageの作成
2. 1で作成したimageをもとにコンテナを作成しつつ、ホストマシン上でコードをいじれるようマウント
3. 実際にサーバを立ち上げてみる
4. ホスト上からコードに修正を加えてみる

1. Angular+Node用のDockerfile及びimageの作成

とりあえずNodeでサーバを立てて Angular動かしてみるかということになった。

https://hub.docker.com/r/monostream/nodejs-angular-cli/

ひとまず ↑を参考にして以下のような感じでDockerfileを作成。

FROM node:alpine

RUN apk add --quiet --no-cache bash && \
    yarn global add @angular/cli && \
    yarn cache clean && \
    rm -rf /var/cache/* /tmp/*

EXPOSE 4200

WORKDIR /home/node

COPY ng_apps ng_apps

CMD ["/bin/sh"]

Angularでserveした際のデフォルトのポートが4200なので、4200番を開放している。
また、ng_apps という空ディレクトリをコピーしているが、これはホストマシンとの共有を想定したディレクトリ。Angularアプリケーションを配下に置いておくことでホストマシンから直接コードをいじれるようにしたかった。Dockerfileを作成したら、同ディレクトリにて以下コマンドを実行。

docker build -t angular-test .

Successfully tagged angular-test:latestという文言とともにイメージが作成される。

2. 1で作成したimageをもとにコンテナを作成しつつ、ホストマシン上でコードをいじれるようマウント

以下のようにdocker run でコンテナを作成する。

docker run --name angular_test_server -d -it -p 80:4200 -v $(pwd)/ng_apps:/home/node/ng_apps angular-test

-v オプションにて ng_appsディレクトリをマウントしつつ、ポートは80番で叩けるようにした。
引き続き以下のコマンドを実行し、作成したコンテナに入り、Angularが適切にインストールされているかどうかを確認する。

docker exec -it angular_test_server /bin/sh
ng --version

3. 実際にサーバを立ち上げてみる

コンテナに入ったままng_appsディレクトリに移動し、ng new コマンドによって myappというアプリケーションを立ち上げる。
ここで一つ問題が発生する。Windowsの場合、Virtualbox経由で共有ディレクトリをつくった場合ゲストマシン側でそのディレクトリにシンボリックリンクを貼ることができない。これにより共有ディレクトリ上で npm install が通らず、結果的に ng new myapp がコケるという事態に陥る。そこで npm install の際に –no-bin-links オプションをつける必要があるのだが、Angularでこれをやりたい場合は以下のようにする模様。

ng new myapp --skip-install
cd myapp
npm install --no-bin-links

これによって共有ディレクトリ上でも無事Angularアプリケーションを置くことができた。あとはnpm installが完了したら以下のコマンドでサーバの立ち上げを行う。

ng serve --host 0.0.0.0

今回はDockerのデフォルトネットワーク経由のため、ホストマシンのブラウザから 192.168.99.100 にアクセス。

表示された。

4. ホスト上からコードに修正を加えてみる

せっかくマウントしたわけだし、ホスト上からコードをいじってみる。とりあえず簡単な例として初期に表示されるページのタイトルを変えてみることにする( パスはmyapp/src/index.html )。

こんな感じでいじって再度ゲストマシン側にてng serve –host 0.0.0.0を実行すると…

無事更新が反映された模様。

The post DockerでAngular+Nodeのサーバを立てた話 appeared first on きのこる庭.

　この記事ではTensorFlowによる学習のコードを見て どこでどういう処理が行われているのかなんとなくイメージできる事を目標として、簡単なモデルの例からTensorFlowにおける学習の導入まで段階的に議論を進めていきます。

モデル

　TensorFlowでモデル構築…といえばよくある多層パーセプトロンがパッと頭に思い浮かびそうですが、TensorFlowで構築できるモデルは何もニューラルネットに限ったものではありません。例えば以下のコードを見てみましょう。

# -*- coding: utf-8 -*-
import tensorflow as tf

x = tf.placeholder(dtype=tf.float32)
y = tf.placeholder(dtype=tf.float32)
addition = tf.add(x, y)

　このコードを図で表すと以下のようなグラフ構造になります。

　この addition は「二つの数を足し算する」という単純なものですが、これも立派なモデルと言えます。ここで重要な事として、このモデル自体は「学習」や「実行」の意味合いを持ちません。実際の所、具体的にどのような2つの数を足し算するかも定められていませんし、ただ「二つの数を足し算する」という事を表しているだけです。このことに注目すると、TensorFlow関連の書籍でモデル構築をする際によく出てくる以下のようなコード(以下は単純な多層パーセプトロンの例)がどういうものか、何となく分かってきますね。

x1 = tf.placeholder(dtype=tf.float32) # 入力層
w1 = tf.Variable(dtype=tf.float32)
b1 = tf.Variable(dtype=tf.float32)
h = tf.nn.relu(tf.add(tf.matmul(x1, w1), b1)) # 隠れ層

w2 = tf.Variable(dtype=tf.float32)
b2 = tf.Variable(dtype=tf.float32)
y = tf.nn.softmax(tf.add(tf.matmul(h, w2), b2)) # 出力層

　隠れ層の部分を見てみましょう。これを言葉にすると「x1とw1を掛け合わせたものにb1を足し算したものを ReLUという関数で変換する」というグラフ構造です。これをhとして、今度は出力層を見てみましょう。出力層では、「hとw2を掛け合わせたものにb2を足し算したものを softmaxという関数で変換する」というグラフ構造になります。この y をモデルとして採用したものがいわゆる多層パーセプトロンです。

　このように、様々な計算を処理するための雛形となるものがモデルです。以下は様々なモデルのイメージです。このようにTensorFlowではグラフ構造に基づく柔軟なモデル構築が可能です。

モデルを用いた計算

　一旦先ほど定義した単純なモデルである addition の例に戻りましょう。モデルを構築した所で、今度は実際に何かしらの入力を加えて実際にモデルを使ってみます。以下の例では additionモデルを使って5+3の結果を出力しています。

sess = tf.Session()
output = sess.run(addition, feed_dict = {
  x: 5.,
  y: 3.
})
print(output) # 結果は8.0

　sess.run() にて 実際に計算に使用するモデルを定義し、その際に入力値を与えています。この時点でも、上記計算に「学習」という意味合いは存在しておらず、ただ単純にモデルとデータを元に計算を実行しただけであることに注意してください。

学習

　ただ計算を実行するだけだと味気ないので、今度は学習を行ってみましょう。先ほどadditionモデルを「二つの数の和を計算するモデル」として定義しましたが、今回はこのモデルにちょっと変更を加えて「入力xと変数yを足し算する」というようにしてみましょう。

# -*- coding: utf-8 -*-
import tensorflow as tf

x = tf.placeholder(dtype=tf.float32)
y = tf.Variable(tf.constant(1.))
addition = tf.add(x, y)

　最初のadditionモデルと異なる点として、最初のadditionモデルでは モデルを用いて計算する際にxとyの両方を入力していましたが、新しいadditionモデルで入力するのは xだけである点です。yには初期値として1が代入されているので、このadditionモデルは最初の段階で「x + 1.0」を計算するものとなります。x = 5.0 なら additionの出力は6.0、という具合です。

　さて、ここで この新しいadditionモデルを用いて、どんな実数値xを入れても「x + y = 8.0」となるようなモデルを得たいとしましょう。しかし、このモデルにおけるyはそのままだと初期値 1.0 のままなので、x = 7.0の時以外では理想の結果が得られません。理想の結果を得るためには yの値がうまいこと増減しないといけません(例えばx=12なら、12.0 + y = 8.0 を得るために yの値は初期値である1.0よりも小さい方向にずらす必要がある…等といった具合です)。

　この時点で初めて「学習」という概念を導入します。…とすると、additionはここで初めて「学習前のモデル」という形で認識できます。では y の学習はどのようにして行われるのでしょうか？

　ここで「損失」という概念を導入してみましょう。学習中のモデルによって予測値を計算した際、当然本当の値との誤差があります。この誤差が大きければ大きいほど損失も大きく、小さければ小さいほど損失も小さいと考えます。値が正解から離れれば離れる程損失が大きくなっていく…という仕組みを定量化するために機械学習ではよく二乗誤差を用います。というわけで慣例に従って以下のように損失関数を定義します。

loss = tf.square(tf.subtract(addition, 8))

　学習の目的はこの損失を限りなく少なくしていくことです。ここで損失が限りなく少なくなるということは、予測値が実際の値に限りなく近づいていくことと考えて下さい( ただし、適切でない損失関数の設定が行われた場合等はこの限りではありません )。

　損失を算出する方法はlossによってうまく定義できたものの、「lossによって算出された損失をもとに yの値を修正する」という仕組みが無ければ学習が行えません。幸い、TensorFlowでは予めデフォルトでこの機能を提供してくれます。それが以下のコードにて示す GradientDescentOptimizer という機構です。

optimizer = tf.train.GradientDescentOptimizer(0.2)
train_step = optimizer.minimize( loss )

　GradientDescentOptimizerの引数にある 0.2 というのは学習率のことで、イメージとしては損失関数からの情報を一回の学習でどれだけ参考にして取り入れるかを示すものです( 学習率が高すぎると予測値が振動・発散してしまうリスクが高くなるし、低すぎるといつまでも予測値が正解に近づかないため、状況に応じて適切な学習率の設定が必要です。ただこの辺りの議論に関しては本題の範疇を超えてしまうためここまでにしておきます )。

　ここで、前述の「モデル」の項にて説明した通り、この時点でのtrain_stepはグラフ構造として定義されているだけで、まだ実際の入力値を与えられてもいないし、学習自体も行われていないことを思い出して下さい。実際に計算をする場合は以下のようにします。

sess = tf.Session()
sess.run( tf.global_variables_initializer() ) # 変数の初期化

output = sess.run(train_step, feed_dict = { x: 5.  }) # モデルの学習を行う
y_val = sess.run(y, feed_dict = {x: 5. }) # 学習済のモデルを使って y の値を計算
print("y = %f" % ( y_val )) # y = 1.800000

　x = 5.0 の場合、 y = 3.0 が正解となりますが、train_stepにより一回学習を回してみた所、yは初期値の 1.0 から 1.8 となり、確かに正解に近づいていることが分かります。
　ところで、基本的に学習は複数回数行うものなので、前の例では単純化のためtrain_stepを一回だけ実行するような形にしていましたが、以下のコードのような形に修正して 30回程train_stepによるイテレーションを回してみることにします。この時、yの値はどのように遷移するか見てみましょう。

sess = tf.Session()
sess.run( tf.global_variables_initializer() ) # 変数の初期化

for i in range(30):
  output = sess.run(train_step, feed_dict = { x: 5.  })
  y_val = sess.run(y, feed_dict = {x: 5. })
  addition_val = sess.run(addition, feed_dict = {x: 5. })
  print("5.0 + %f = %f" % ( y_val, addition_val ))

　このコードを実行した結果は以下のようになります。

　学習を重ねるにつれて確かにyの値が 3.0 に近づいていることが確認できます。では今度は入力値を変えてみて、 x=11 とした場合どうなるでしょう。

　x=11にしても、ごく僅かな誤差はあるもののほぼ正解に近い値になっています。これがTensorFlowによる学習です。

データセット

　今回の学習モデルでは簡単のため 入力値・正解をただ一つだけ設けましたが、実際にTensorFlowで学習を行う際には 一般的にまとまった複数の入力値・正解のセットをモデルに与えて学習させていきます。
　実際のデータセットを扱う上で重要な観点の一つが、一つのデータセットを「学習用データ」「テスト用データ」の二つのデータ群に分離することです。これは、学習させたモデルで実際でどれくらいの精度が出るのかを確かめるためのデータが必要となるからです。
　一つのデータセットを学習用データ群・テスト用データ群に分ける上で手動でプログラムを構築する必要はなく、scikit-learnがこれに相当する機能を提供してくれているので、こうしたものを使用するのが懸命です。

from sklearn.cross_validation import train_test_split

:
x_train, x_test, y_train, y_test = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=42)
:

ここで、dataset_x, dataset_y はそれぞれ 入力データ群、入力データに対する正解の群を表しています。

まとめ

　というわけで、一つの塊として見ると膨大で複雑なTensorFlowのコードですが、一つ一つ丁寧に要素を分解して見ていくと意外とそこまで複雑ではありません。ここで説明した概念は単純な多層パーセプトロンに止まらず再帰ニューラルネット等様々なモデルにも適用可能な基礎となるものなので、ぜひ抑えておきたい所です。

The post TensorFlowでモデル構築して学習させる際のイメージ appeared first on きのこる庭.

また、今回はモデル構築部の幾何的な理解を目標としているため、実際のKeras部分を用いた学習に関しては省略しております。ご了承下さい。

通常の多層パーセプトロンの場合

# -*- coding: utf-8 -*-
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD

何はともあれインポート。これらのインポートしたものがそれぞれどういう意味を持つのかは後述します。

num_input_layer  = 3 # 入力層のニューロンの数
num_hidden_layer = 4 # 隠れ層のニューロンの数
num_output_layer = 3 # 出力層のニューロンの数

入力層、隠れ層、出力層のニューロンの数を変数として持たせておきます。

model = Sequential()

Sequentialインスタンスを作成しました。
このSequentialというやつは、以下の画像のような複数の層を持つデータをモデル化するためのインスタンスです。

ネットワークの左側の緑色は「入力層」、右側の緑色が「出力層」、(存在する場合)入力層と出力層の間に挟まれているのが「隠れ層」です。
普通のKerasの用途としては隠れ層を複数導入してディープニューラルネットワークのように使うのが通常かと思われますが、一応モデルとして隠れ層を持たない入力層・出力層だけのネットワークのモデル(図の左側に浮いているやつ)も定義できるっぽいです。

というわけで、インスタンスを定義したので早速ですが多層パーセプトロンをつくってみます。

model.add(Dense(num_hidden_layer, input_dim=num_input_layer))

DenseというのはDensely-Connected なニューラルネットの層を指す。
Densely-Connected の イメージとしては上図のようにそれぞれの層の入力と出力同士が全て互いにくっついている感じ。認識が間違っていなければ Fully-Connectedと同義のはず。
( 一応確かめました: dense-vs-convolutional-vs-fully-connected-layers )

今回は入力層が3つ、隠れ層が4つのニューロンからなるため上記のコードにより以下のような図のネットワークができたことになります。
( 因みに この時点で定義されているネットワークにおいて、下記にて隠れ層として描かれているものは モデル上では隠れ層でなく出力層となっています )

次は活性化関数を追加します。活性化関数というのは、あるニューロンが複数の(各ニューロンごとに重みがついた)ニューロンからの入力を受け取り、受け取った値を合計した後 そのニューロン自身を0～1の間の値に落とし込むための関数です。これは連続値の場合もありますし、離散値(0,1)の場合もあります。離散値の場合は「ステップ関数」と言われており、ニューロンが「発火」= 他のニューロンからの入力の合計が閾値を上回りステップ関数が1になる というイメージのものです。活性化関数に関する具体的な議論に関しては他の方の記事に譲ります。

model.add(Activation('sigmoid'))

今回は活性化関数によく使われるシグモイド関数という関数を使用しました。
( なお、最近だとReLU関数というのが使われるのが割とメジャーな方法になってきているっぽいですね )

これにより、ネットワークは以下のような状態になりました。

今回は多層パーセプトロンを組みたいので、隠れ層の次に出力層を追加します。

model.add(Dense(num_output_layer))
model.add(Activation('softmax'))

出力層の活性化関数には「ソフトマックス関数」を使用します。ソフトマックス関数は多クラス分類問題においてよく使われる関数で、「これが一番大きい！」と最大の1つを決定する挙動をより緩やかにして、「これが全体の中で結構大きいよね。5つのアウトプットを相対的に表現すると ( 0, 0, 0.03, 0.94, 0.03 ) くらいかな。といった形で「マックス」を「ソフト」にする効用があるため「ソフトマックス」と呼ばれています。

上記コードの追加により、最終的にこんな感じのネットワーク構造ができました。
最後にこのネットワーク構造をコンパイルします。

model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.01),metrics=['accuracy'])

( このあたりのコードは後述の書籍(『詳解ディープラーニング』)を参考にさせていただいております。 )
コンパイル時に、どのようにネットワークの学習に際して必要となる情報を併せて引数として渡します。

loss は誤差関数です。テスト時に予測が実際の結果とどれくらいずれていたかをはかる指標です。

【発展的な議論】
因みに誤差関数は何でも良いというわけではなく、活性化関数と対応させる必要があります。
例えば多クラス分類問題を解く際にはソフトマックス関数を活性化関数として選びますが、この場合多クラス用のクロスエントロピー誤差関数を選ぶのが一般的です。
( その他 最小二乗法を用いた回帰問題であれば二乗誤差関数、2クラス分類ならクロスエントロピー誤差関数等 )

optimizerというのは学習の際どのように精度を高めていくかを表す関数です。今回はSGD(Stochastic Gradient Descent; 確率的勾配降下法)という最適化問題における有名な手法を使用します。またこの際lrという引数をSGDに渡していますが、これはlearning rate、すなわち学習率を表し、学習率が大きいほど 誤差をより大きく修正しようという方向で動きます。

metricsはモデルの評価指標です。Kerasではmetrics=['accuracy']という形で設定して、訓練時・テスト時にモデル精度の高さを測る方法がよく使われるようです。

まとめると、以下のようになります。

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

from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD

num_input_layer  = 3 # 入力層のニューロンの数
num_hidden_layer = 4 # 隠れ層のニューロンの数
num_output_layer = 3 # 出力層のニューロンの数

model = Sequential()

model.add(Dense(num_hidden_layer, input_dim=num_input_layer))
model.add(Activation('sigmoid'))

model.add(Dense(num_output_layer))
model.add(Activation('softmax'))

model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.01),metrics=['accuracy'])

隠れ層を増やしてみる

上記コードの入力層と出力層との間に同じ手順でもう一つ追加するだけです。

model.add(Dense(num_hidden_layer))
model.add(Activation('sigmoid'))

なお、今回は 隠れ層に含まれるニューロンの数をいずれも num_hidden_layer で固定していますが、隠れ層の各層によってニューロンの数を変化させても問題ありません。

結果的にどういうネットワーク構造になるかというと…

こんな感じです。
コードをまとめると、

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

from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD

num_input_layer  = 3 # 入力層のニューロンの数
num_hidden_layer = 4 # 隠れ層のニューロンの数
num_output_layer = 3 # 出力層のニューロンの数

model = Sequential()

model.add(Dense(num_hidden_layer, input_dim=num_input_layer))
model.add(Activation('sigmoid'))

model.add(Dense(num_hidden_layer))
model.add(Activation('sigmoid'))

model.add(Dense(num_output_layer))
model.add(Activation('softmax'))

model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.01),metrics=['accuracy'])

となります。Keras、ちょっと触っただけだけど、割と直感的に書けていいな～と思いました。

※ 一部コードは以下の書籍を参考にさせていただいております。RNN, LSTM, BRNN, seq2seq 等の話題も豊富で、且つコードの例も豊富に載っているためオススメです。

詳解-ディープラーニング-TensorFlow-Kerasによる時系列データ処理 – 巣籠 悠輔(著)

The post Kerasで多層パーセプトロンのモデル構築する際のイメージ(数式無し) appeared first on きのこる庭.

先日無事入籍を終え、結婚式に向けてあれこれ準備が必要になるということで、友人の何人かがやっていたように家庭内でRedmineを導入した。「結婚式準備」プロジェクトを立ち上げて暫く運用していて 最近ようやく運用が落ち着いてきたため、今度は少し欲が出てきた。
現状、チケットが更新されるタイミング・何のチケットが更新されたか等タイムラインでしか把握できない状態になっているので、Slackを使って チケットが更新されたらリアルタイムに通知が飛ぶようにした。最近一部の界隈では家庭内でこういうツールを導入するのもよくある流れになってきたのかなあとは思う(ねーよ)ので、流行に便乗してみようといった所だ。導入・設定に苦戦するかなあと思ったら、元々Redmineが入っている状態から15分くらいで意外とサクッと導入できた。

これまで

家庭内でRedmineを導入したのはおよそ一ヶ月前のことだ。使い方としては、以下のような感じでチケット毎にタスクの進捗状況などを書き込んだりして使用していた。
暫く回してみた感じ、中々良い感じに管理できているなという手ごたえがあった。

そこに今回、より利便性を高めるためSlackを導入しようという算段である。
導入に際し、今後何かとライフイベントが発生する可能性を考慮して、「結婚式準備」「引越し」等プロジェクトごとにチャットルームを作成し それぞれに通知が飛ぶようにした。

結果

以下のような感じでRedmine側で更新をかけると･･･

以下のようにリアルタイムで通知が飛ぶ。デスクトップ上にNotificationも飛んでくれるので便利ですね。

まとめ

大人になると色々と比較的大きめの取り決め事を並行して消化していかないといけない事が多くなってくるので、こういう風に家庭の事も管理しておくと「あーこれも準備しておかなきゃいけなかったー」みたいな抜け漏れも防ぐことができ、且つ計画的・効率的にタスクをこなしていくことができて結構良いのではないかと思った。

参考にさせていただいたサイト様

● Redmineの変更をSlackで通知できるようにする
SlackとRedmineを連携し、登録したチケットの更新を通知する方法 – LIG INC.

● Redmine上の複数プロジェクトをSlackのチャットルームごとに通知
SlackにRedmineのチケット更新を通知する – ZEALOTエンジニアブログ

The post 家庭内のタスクをRedmineとSlackを連携させて管理するようにしたらうまくいった話 appeared first on きのこる庭.

そんなDjangoだが、Vagrantによる導入時点で早速ハマった事があったので備忘録として残しておく。

環境は以下を使用しました。

・Python 3.4.3
・Django 1.7
・Vagrant 1.7.4

※ 前提として Python, Django, Vagrantは既にインストール済みであること。

プロジェクトをつくる

$ django-admin.py startproject blog

このコマンドを使用することによってカレントディレクトリ上に blog というDjangoプロジェクトのディレクトリができる。
ディレクトリ下には プロジェクト名と同様の名前のディレクトリが存在し(blog/blog)その下にベースとなる設定(DB設定、ディレクトリパス設定等)、ベースとなるルーティング設定 等のファイル群が置かれている。

ローカルPCからアプリケーションにアクセスできるようにする

blogディレクトリ下で以下のように実行したものの、繋がらず。

$ python manage.py runserver

厳密に言うと、サーバは立ち上がっているのだけど、デフォルトのままrunserverを打つと サーバが127.0.0.1:8000で立ち上がってしまい、仮想環境内で閉じているから外部からアクセスできないという状態になっている。
サーバ内でアクセス可能な様子は サーバ上で 127.0.0.1 にpingを打つ事で確認できる。

ローカルPCのブラウザから表示させる場合は、まずVagrantfileの設定を確認する必要がある。
Vagrantfile内に以下のようなポートフォワードの記述があることを確認してほしい。

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine. In the example below,
  # accessing "localhost:8080" will access port 80 on the guest machine.
  config.vm.network "forwarded_port", guest: 8000, host: 8080

ローカルのブラウザで 127.0.0.1:8080 と打つ → 仮想環境の 8000番ポートにアクセスしますよ、という意味となる。
人によっては guest と hostの設定が異なる場合があるので、逐一数値を変換して読んで欲しい。

では あとは仮想環境側で待ち受ければよいのだが、ここでサーバ側を 127.0.0.1:8000 として待ち受けても繋がらない(127.0.0.1は自身のマシン内で処理するもののため)ので、代わりに 0.0.0.0:8000 を指定する必要がある。

指定の仕方は簡単で、runserverの引数に与えるだけでよい。

$ python manage.py runserver 0.0.0.0:8000

これでサーバを立ててブラウザにアクセスすると…

ひとまずうまく動いた模様。

The post Vagrant + Django でrunserverするまで appeared first on きのこる庭.