Kaggle：その２（Titanic、Mnistなど）

前回のTitanicの続きです。
いろいろとハイパーパラメータを調節して目標としていたスコア：0.80（上位8%）を何とか超えることができましたが、どうも乱数固定が不安定で偶然出てきた結果という感じ。たぶんCUDAとともにインストールしたcuDNNのほうで乱数の固定ができていないような。まあ、それでもできるだけ固定することでわずかな誤差ですむようになってきました。以下が現在の乱数固定方法。このほかKerasのDense層のkernel_initializer、Dropoutにおいてもseedを固定しています。

	import numpy as np
	import tensorflow as tf
	import random as rn
	import os
	os.environ['PYTHONHASHSEED'] = '0'
	random_n = 123
	np.random.seed(random_n)
	rn.seed(random_n)
	session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)
	from keras import backend as K
	tf.set_random_seed(random_n)
	sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)
	K.set_session(sess)

view raw Keras_random_seed.py hosted with ❤ by GitHub

スコアをあげるための決定的な解決策はまだ出てきていないのですが、今回はKerasのEarlyStopping機能（訓練ループを自動的に止める）を使ってみました。

	from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
	reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=0.000001,verbose=1)
	checkpointer = ModelCheckpoint(filepath='checkpoint.hdf5', verbose=1, save_best_only=True)
	early_stopping = EarlyStopping(patience=10, verbose=1)
	history = model.fit(x_train, y_train,
	epochs=300,
	batch_size=32,
	verbose=1,
	validation_split=0.1,
	callbacks=[reduce_lr, early_stopping, checkpointer])
	model.load_weights('checkpoint.hdf5')
	pred = model.predict(x_test)

view raw Keras_EarlyStopping.py hosted with ❤ by GitHub

EarlyStoppingだけでなく、自動的に学習率を下げるReduceLROnPlateauとModelCheckpointでベストなウェイトを保存させて、その結果から予測させています。要はできるだけ自動化という方向で。

提出結果のスコアを比較していくと、隠れ層を1層にした非常にシンプルなニューラルネットのほうがいい結果が出ました。Titanicの場合はデータ数が少ないので（訓練＋テスト：1309サンプル）、優れた予測モデルを構築しにくいのかもしれません。乱数の違いでもかなり結果が変わってしまうのでその辺が難しそう。

基本的にはデータをみながらの工夫はせずに、数値化したデータをそのままニューラルネットに渡して自動的に解決する方法にしています。

それぞれのデータに関しては：

Pclass：そのまま
Name：含まれるTitle（Mr/Mrsなど）を抽出し数値化（0〜17）、正規化
Sex：数値化、male:0, female:1
Age：欠損値あり（後で穴埋め）、正規化
SibSp：正規化
Parch：正規化
Ticket：削除
Fare：欠損値あり（後で穴埋め）、正規化
Cabin：欠損値も含め数値化：nan:0, C:1, E:2, G:3, D:4, A:5, B:6, F:7, T:8に変換
Embarked：欠損値あり（後で穴埋め）、数値化：S:0, C:1, Q:2

何度かスコア：0.80を超えた（上位8%）のですが、あまり当てにならないので、再度仕切り直しで以下のコード（スコア：0.78947）。

Loading

Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.

view raw Titanic-ES.ipynb hosted with ❤ by GitHub

表示されない場合はこちら。

Digit Recognizer（Mnist）：
Titanicはまだまだやり続けたいのですが、1日に10回までしか提出できないので、ビギナー用のDigit Recognizerも試してみました。これはサンプルでよく使われているMnist（手書き文字）。
基本的にCNNを通して10通りの数字を分類しますが、これまで精度を上げてみるということはしたことがなかったので、どの程度できるのか今回チャレンジ。

よくあるCNNでやってみてもスコア：0.99以上にはなりました。あとは0.001でもいいのでより精度をあげるにはどうしたらいいかという感じです。
結果としては、0.99528（上位18%）まで上げることができました。以下がコード。

Loading

Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.

view raw Kaggle-mnist-CNN-ES.ipynb hosted with ❤ by GitHub

表示されない場合はこちら。

サンプルなどでよくあるCNNに対して層やユニット数を調整したり、BatchNormalizationやDropoutを加えてみました。最初は0.993くらいでしたが、その分やや向上しました。
この他、画像をリサイズしてKeras ApllicationsにあるXceptionやInceptionV3なども試してみましたが、それほど良い結果は得られなかったので、そんなに層を増やさなくてもよさそうです。
これもまだまだ精度をあげることはできそうなので、もう少しやり込みたいと思っています。


TGS Salt Identification Challenge：
この他、賞金ありのコンペにも試しに登録してみました。これは地質画像をもとに塩の埋蔵量を予測するコンペのようです。Kernelsには基本的なアルゴリズムがのっているので、そのままコピペしてベースラインのスコアは得られますが、そこからさらに精度をあげなければいけません。基本的に画像認識のコンペですが、セグメンテーションするためのU-net、intersection-over-union（IoU）、その離散値を連続値として計算可能にするLovasz Hinge Lossというテクニックが使われているようで難しそうです。
期限前までに完全理解することはできませんでしたが、Kernelsを読んでいるだけでも勉強になるので、難しそうでも一度参加してみて、できるところまでやってみると知見も広がってよさそうです。

Kaggleで勝つデータ分析の技術

posted with amazlet at 19.11.04

門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363

Amazon.co.jpで詳細を見る

SCHOOL OF AI: MOVE 37（無料強化学習コース）

Siraj Raval氏のAI関係のYoutube動画はよく見るのですが、9/10から無料のコース「MOVE 37」が始まったので試しに登録してみました。内容は主に強化学習についてであり、10週で完了するコースです。

去年まではGANなどの生成的ネットワークにトピックが集中していたような気がしますが、最近は強化学習が流行ってきたのでしょうか？Pose Estimatorのようなアルゴリズムも公開され、ディープラーニングの応用法においても幅が広がってきたのかもしれません。


この「MOVE 37」というコースにおいては、以下を使って学ぶようです。

・Pytorch
・OpenAI Gym
・Google Collaborator
・TensorFlow

Google Colab上でコーディングし無料GPUで訓練できるので、どんなパソコンでも大丈夫という感じです。

コース内容は、1週間ごとに以下の項目を実施（合計10週）。

・Markov Decision Processes 0/7

・Dynamic Programming 0/7

・Monte Carlo Methods 0/6

・Model Free Learning 0/7

・RL in Continuous Spaces 0/7

・Deep Reinforcement Learning 0/7

・Policy Based Methods 0/7

・Policy Gradient Methods 0/7

・Actor Critic Methods 0/7

・Multi Agent RL 0/7

基本から始まり、一通り強化学習を順を追って勉強していくので、全体を網羅するにはいいのかもしれません。

1週目は「マルコフ決定過程」についてですが、

・強化学習の基礎知識（ビデオや文章）

・ミニテスト

・OpenAIのインストール

・Google Dopamine（Google最新の強化学習フレームワーク）の紹介

などです。

2週目（来週）から本格的にコーディングしていくという感じでしょうか。

無料コースなので、それほど親切丁寧に指導してくれるというわけではなさそうですが、Forumなどもあるので、聞きたいことがあれば誰かが答えてくれるといった環境はあります。そもそも強化学習に興味あるけど、どのような順番で何を勉強していけばいいかという手がかりは最低限得られるので、その後独学する手立てにもなると思います。

Google Colabの無料GPUで強化学習（Keras-RL）を試す

最近は、Google Colabの無料GPU（連続12時間まで）を使用して演算が可能なので、機械学習用GPUが搭載されていないパソコンでも充分機械学習の訓練などできそうです。使い方はオンラインのJupyter Notebookという感じです。

Colabスペック：
Ubuntu17.10（現在は18.04）
Intel(R) Xenon CPU @2.3GHz
13GB RAM
GPU NVIDIA Tesla K80

スペックはこんな感じ。アルゴリズムにもよりますがTesla K80がどのくらい高速なのかが気になります。自前のゲーミングノートはPascal世代のGTX1060ですが、K80はそれよりも2世代前のKepler世代のGPUのようです。
!nvidia-smiを打ち込むと以下。

このほか、機械学習に必要な基本的なライブラリはnumpy、pandas、matplotlib、Tensorflow、Kerasも含め既にインストールしてあるようです。Pytorchは入っていないのでインストールする必要があります（追記：その後Pytorchなどもインストール済みになったようです）。

ということで、前回のKeras-RL + Open AI Gym Atariの訓練（1750000ステップ）を比較してみようかと。自前のゲーミングノートGTX1060では約3時間かかりました。


インストール：
とりあえず、Keras-RLやGymなど必要なものをapt-get installやpipで前回同様にインストールする必要があります。

!pip install gym keras-rl pyglet==1.2.4
!apt-get install -y cmake zlib1g-dev libjpeg-dev xvfb ffmpeg xorg-dev python-opengl libboost-all-dev libsdl2-dev swig
!pip install 'gym[atari]'

最初に「!」マークをつけたあとpipやapt-getなどでインストールできます。今回は上記のものをインストールしました。前回Jupyterの際、pyglet1.3.2だとダメだったので、最新ではないpyglet1.2.4をインストールしています。
必要なライブラリなどはインストールできますが、再度ログインするとまたインストールし直さないといけないようです（Colab内は毎回クリアされる？）。


実行時間の比較：
以下が自前のGTX1060での訓練時のログ。これは前回Jupyter用に書き直したAtariブロック崩しの訓練です。

10000ステップで約60秒かかっています。訓練するには合計1750000ステップあるので、約3時間ということになります。

これに比べて、Google Colab（Tesla K80）の方は以下。

10000ステップで約108秒かかっています（意外と遅い）。

自前のゲーミングノート（GTX1060）のほうが1.8倍速いという計算になります。

とはいっても普通のMacBook（CPU演算）に比べればはるかに速いとは思います。

しかしながら、370000ステップの途中で突然ストップしてしまいました。

最後に、「Buffered data was truncated after reaching the output limit」という表示が出ています。何か出力限界に達したようで、途中停止しています。

検索してみると、Stack flowに似たような件について書いてありました。RAMかGPUのメモリをオーバーしてしまったようで、バッチサイズを少なくするか、小分けに途中経過（ウェイト）を保存しておいて再開するかなどの工夫が必要そうです。一応プログラム上ではチェックポイントを設けて250000ステップごとにウェイトを途中保存してはあります。

やはりある程度の規模になると、使用する上での工夫が必要そうです。今回の場合だと1750000ステップの訓練をさせるには概算すると5時間はかかりそうです。連続使用12時間以内で済みそうですが、それ以前にメモリなども気を遣わなければいけないということです。

ということで、処理速度を知りたかったので訓練は途中で終了。

動画表示：

そのかわりに、以前保存しておいたウェイトを読み込んでColab上に表示できるか試してみました。

尚、外部ファイルなどを読み込ませるには以下を書き込んでランさせるとファイル選択ダイアログがでてきて、パソコンの任意の場所からファイルを読み込むことができます。

from google.colab import files
uploaded = files.upload()

前回Jupyter上で表示可能であった方法を試してみましたが、画面のちらつき、動画としての更新速度が非常に遅く、いまいちという結果。

ということから一旦出力画像を非表示にして、matplotlibのArtistAnimationに変換後表示する方法を試してみました（以下）。

from rl.callbacks import Callback
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
%matplotlib inline

ims = []

class Render(Callback):
    def on_step_end(self, step, logs={}):
        im = plt.imshow(env.render(mode='rgb_array'))
        ims.append([im])

weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
dqn.load_weights(weights_filename)

callbacks = Render()
fig = plt.figure(figsize=(4,5))
plt.axis('off')
dqn.test(env, nb_episodes=1, visualize=False, callbacks=[callbacks])

ani = animation.ArtistAnimation(fig=fig, artists=ims, interval=10)
# ani.save("anim.gif", writer = "imagemagick")  # imagemagick for Ubuntu
plt.close()

HTML(ani.to_jshtml())         # JavascriptHTML output
#HTML(ani.to_html5_video())   # HTML5 Video output

これは前回もJupyter上で試した方法です（前半の訓練時のコードは省いてあります）。一旦画像は非表示にして、Keras-RLのCallback関数をオーバーライドして表示用サブクラスをつくっています（詳しくは前回参照）。Keras-RLはdqn.test()で別窓に動画表示してしまうので、それを非表示にしておき、Jupyter上で表示可能なデータに変換してから表示しています。
結果的には、アニメーションとして最後表示することができました。Jupyterも表示には手こずりましたが、Colabはオンラインでもあるためどうしてもリアルタイムだと遅くなってしまうようで、このようにアニメーションとして変換してしまえば問題なさそうです。アニメーションに変換する分、少しだけ（数十秒程度）余計に時間がかかりますが、特に目立った遅さではないのでこれでいけそうです。

アニメーションとして保存してあるので、オンラインによるタイムラグはなく普通に速く動きます。
Atariの場合はこのようにColab上に表示されますが、CartPoleのようなClassic controlの場合はレンダリングの仕組みが違うためかColab上のアニメーションだけでなく別窓にも表示されてしまいます。

追記：尚、このボタン付きアニメーションをWebページに埋め込むには以下。
Matplotlib Animation embed on web page：アニメーションのWebページ上への埋め込み


まとめ：

結果的には自前のゲーミングノートGTX1060のほうが速かったのですが、数時間かかりそうな訓練の場合にはGoogle Colabのほうで処理させておき、メインのパソコンではまた別の作業をという感じで使うこともできそうなので、それなりに便利かと。

今後はこのようなGPUのクラウドサービスが主流となってくれば、機械学習をするにはわざわざゲーミングパソコンを買うまでもないかと思います。ネットだけできればいいような5万円前後のGoogle Notebookでもいいのかもしれません。

Loading

Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.

view raw colab-gym-keras-rl.ipynb hosted with ❤ by GitHub

機械学習スタートアップシリーズ Pythonで学ぶ強化学習 入門から実践まで (KS情報科学専門書)

posted with amazlet at 19.11.04

久保 隆宏
講談社
売り上げランキング: 115,841

Amazon.co.jpで詳細を見る

Keras-RLで強化学習/DQN(Deep Q-Network)を試してみる

前回GANについて理解を深めてみましたが、その後もGANの発展型となるACGANやInfoGANについても引き続き勉強中です。しかしながら、今回はやや方向転換して強化学習（Reinforcement Learning）について試してみました。

環境：
Ubuntu 18.04
GTX 1060
CUDA 9.0
python 3.6
tensorflow 1.9
Keras 2.1.6
Keras-rl 0.4.2
Jupyter Notebook 5.6


アルゴリズム：
強化学習には独特のアルゴリズムが使われており、ディープラーニング以前にも

・Q-Learning
・SARSA
・モンテカルロ法

などが基本としてあるようです。
その後、AlphaGOで有名となった

・DQN（Deep Q-Network）

そして、さらに改良された

・Double DQN
・Dueling DQN
・AC3
・UNREAL
・PPO

などがあるようです。日々改良されているようですが、どれがいいのかは目的によっても異なるようです。とりあえず今となってはDQNあたりが基本かと。


OpenAI：
手っ取り早く強化学習を勉強するならOpenAIのGYMを利用するとよさそうです。GYMには倒立振子やATARIのビデオゲームなどの教材があり、強化学習アルゴリズムを書き足せばすぐに試すことができます。
このページのインストール方法に従って必要なライブラリなどをインストールしますが、ATARIのビデオゲームを使いたい場合はcmakeも必要となるので、Ubuntuであれば一通り以下のコマンドで全てインストールしておいたほうが良さそうです。

apt-get install -y python-numpy python-dev cmake zlib1g-dev libjpeg-dev xvfb ffmpeg xorg-dev python-opengl libboost-all-dev libsdl2-dev swig

動作チェック：
Getting Started with Gymにも書いてありますが、以下のコードで100ループ動きます（ランダムな動き）。ちなみにこのままだとJupyter Notebookでは表示（レンダリング）されないので、.pyファイルにして実行させないといけません。

import gym

env = gym.make('CartPole-v0')
env.reset()

for _ in range(100):
    env.render()
    env.step(env.action_space.sample())
env.close()

あっというまに表示が終わってしまうので以下のようにtime.sleep()でディレイを加えてみました。

import gym
import time

env = gym.make('CartPole-v0')
env.reset()

for _ in range(100):
    env.render()
    env.step(env.action_space.sample())
    time.sleep(0.02)
env.close()

Jupyter Notebookの場合：
アニメーションをJupyter Notebook上で表示するには少し工夫が必要です。stack overflowにもいくつか方法が書いてあります。
ATARIの場合であれば以下の方法で表示可能でした。

import gym
from IPython import display
import matplotlib.pyplot as plt
%matplotlib inline

env = gym.make('Breakout-v0')
env.reset()

img = plt.imshow(env.render(mode='rgb_array'))

for _ in range(100):
    img.set_data(env.render(mode='rgb_array'))
    display.display(plt.gcf())
    display.clear_output(wait=True)
    action = env.action_space.sample()
    env.step(action)
env.close()

しかし、CartPole-v0のようなClassic controlの場合だとエラーがでてしまうので、インストールしてあるpyglet1.3.2を一旦アンインストール（pip uninstall pyglet）して、pyglet1.2.4をインストール（pip install pyglet==1.2.4）し直すといいようです（こちらの方法）。ただこの方法だとJupyter上だけでなく別窓も開いてしまいます。そして、env.close()を最後に書き加えないと、別窓を閉じることができなくなるので要注意。

別窓だけの表示でいいのであれば（Jupyter上には表示させない）、pyglet1.2.4にダウングレードさえしておけば、以下の方法でも可能でした。

import gym
import time

env = gym.make('CartPole-v0')
env.reset()

for _ in range(100):
    env.render()
    env.step(env.action_space.sample())
    time.sleep(0.02)
env.close()

Jupyter Notebook上に表示させる方法をいろいろ探してみましたが、別窓での表示であれば簡単そうなので、以下のKeras-RLでも別窓表示にすることにしました。


Keras-RL：
とりあえずDQNで強化学習をしたいので、どの機械学習フレームワーク（Tensorflow、Keras、Pytorchなど）を使えばいいかということですが、Keras-RLというKeras向けの強化学習用のライブラリがあり、以下のようなアルゴリズム（ここに書いてある）が既に搭載されており、すぐに使うことができます。

Name	Implementation	Observation Space	Action Space
DQN	rl.agents.DQNAgent	discrete or continuous	discrete
DDPG	rl.agents.DDPGAgent	discrete or continuous	continuous
NAF	rl.agents.NAFAgent	discrete or continuous	continuous
CEM	rl.agents.CEMAgent	discrete or continuous	discrete
SARSA	rl.agents.SARSAAgent	discrete or continuous	discrete

複雑なアルゴリズムをコーディングしなくても、既存の関数にパラメータを渡せば計算してくれますが、基本となるQ-Learningの仕組みはある程度理解しておいたほうがよさそうです。
Action Space欄に離散値か連続値かの違いがあるので、目的に応じて使い分けるといいと思います。


DQNを試してみる：

CartPoleのサンプル：
Keras-RLにはいくつかのサンプルコードがあるので、dqn_cartpole.pyを試してみることに。
Jupyter NotebookでRunさせる場合は、別窓としてアニメーションが表示されます。終了後別窓を閉じるために、最後の行にenv.close()を追加しておきます。

import numpy as np
import gym

from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten
from keras.optimizers import Adam
from rl.agents.dqn import DQNAgent
from rl.policy import BoltzmannQPolicy
from rl.memory import SequentialMemory

ENV_NAME = 'CartPole-v0'

env = gym.make(ENV_NAME)
np.random.seed(123)
env.seed(123)
nb_actions = env.action_space.n

model = Sequential()
model.add(Flatten(input_shape=(1,) + env.observation_space.shape))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(nb_actions))
model.add(Activation('linear'))
print(model.summary())

memory = SequentialMemory(limit=50000, window_length=1)
policy = BoltzmannQPolicy()
dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=10,
               target_model_update=1e-2, policy=policy)
dqn.compile(Adam(lr=1e-3), metrics=['mae'])

dqn.fit(env, nb_steps=50000, visualize=True, verbose=2)
dqn.save_weights('dqn_{}_weights.h5f'.format(ENV_NAME), overwrite=True)

dqn.test(env, nb_episodes=5, visualize=True)
env.close()

GTX1060で、学習50000ステップ、約5分かかりました。
DQNAgentクラスに必要な項目を渡すだけなので、アルゴリズム的には超シンプルです。
CartPoleに関しては左か右に動かすだけなので、env.action_space.nは2になります。
最後のほうにあるdqn.save_weight()で学習したウェイトが外部保存されるので、次回このウェイトをつかってテストするには、以下のように書き換えることになります。

# 以下をコメントアウトして
# dqn.fit(env, nb_steps=50000, visualize=True, verbose=2)
# dqn.save_weights('dqn_{}_weights.h5f'.format(ENV_NAME), overwrite=True)

# かわりに保存したウェイトを読み込む
dqn.load_weights('dqn_{}_weights.h5f'.format(ENV_NAME))

dqn.test(env, nb_episodes=5, visualize=True)
env.close()

デフォルトでは、以下のように一回のepisodeでsteps: 200になっています。

例えばsteps: 500に変えるには、

env = gym.make("CartPole-v0")
env._max_episode_steps = 500

とすればいいようです（ここに書いてありました）。


ATARIブロック崩しをJupyter Notebook上に表示：
もうひとつは、ATARIのブロック崩しのサンプルです。これは (210, 160, 3) のRGB画像を入力としてCNNを通して学習していきます。画像から判断するので、どんなゲームでもいいということになります。サンプルにある通り1750000ステップ学習するために約3時間かかりました（GTX1060）。
もともとこのサンプルは.pyファイルですが、Jupyter Notebook上に表示できるように少し手を加えてみました。サンプルは最後の方にあるdqn.test()で結果表示されますが、既存コードを見るとenv.render(mode='human')が使用されており、Jupyter Notebook上に表示するにはenv.render(mode='rgb_array')に変換する必要がありそうです。
そのため、既存の結果表示はvisualize=Falseで非表示にし、かわりに自前のCallback関数を追加することで毎ステップ画像表示させることにしました。またargparseはJupyterでは使えないので消去し、そのかわりに各変数を用意しました。

from PIL import Image
import numpy as np
import gym

from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten, Convolution2D, Permute
from keras.optimizers import Adam
import keras.backend as K

from rl.agents.dqn import DQNAgent
from rl.policy import LinearAnnealedPolicy, BoltzmannQPolicy, EpsGreedyQPolicy
from rl.memory import SequentialMemory
from rl.core import Processor
from rl.callbacks import FileLogger, ModelIntervalCheckpoint


INPUT_SHAPE = (84, 84)
WINDOW_LENGTH = 4

class AtariProcessor(Processor):
    def process_observation(self, observation):
        assert observation.ndim == 3
        img = Image.fromarray(observation)
        img = img.resize(INPUT_SHAPE).convert('L')
        processed_observation = np.array(img)
        assert processed_observation.shape == INPUT_SHAPE
        return processed_observation.astype('uint8')

    def process_state_batch(self, batch):
        processed_batch = batch.astype('float32') / 255.
        return processed_batch

    def process_reward(self, reward):
        return np.clip(reward, -1., 1.)

ENV_NAME = 'BreakoutDeterministic-v4'
env = gym.make(ENV_NAME)
np.random.seed(123)
env.seed(123)
nb_actions = env.action_space.n
input_shape = (WINDOW_LENGTH,) + INPUT_SHAPE

model = Sequential()

if K.image_dim_ordering() == 'tf':
    model.add(Permute((2, 3, 1), input_shape=input_shape))
elif K.image_dim_ordering() == 'th':
    model.add(Permute((1, 2, 3), input_shape=input_shape))
else:
    raise RuntimeError('Unknown image_dim_ordering.')

model.add(Convolution2D(32, (8, 8), strides=(4, 4)))
model.add(Activation('relu'))
model.add(Convolution2D(64, (4, 4), strides=(2, 2)))
model.add(Activation('relu'))
model.add(Convolution2D(64, (3, 3), strides=(1, 1)))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dense(nb_actions))
model.add(Activation('linear'))
#print(model.summary())

memory = SequentialMemory(limit=1000000, window_length=WINDOW_LENGTH)
processor = AtariProcessor()

policy = LinearAnnealedPolicy(EpsGreedyQPolicy(), attr='eps', value_max=1., value_min=.1, value_test=.05,
                              nb_steps=1000000)

dqn = DQNAgent(model=model, nb_actions=nb_actions, policy=policy, memory=memory,
               processor=processor, nb_steps_warmup=50000, gamma=.99, target_model_update=10000,
               train_interval=4, delta_clip=1.)

dqn.compile(Adam(lr=.00025), metrics=['mae'])

# コールバックとJupyter表示用モジュールのインポート
from rl.callbacks import Callback
from IPython import display
import matplotlib.pyplot as plt
%matplotlib inline

# 表示用Renderサブクラス作成（keras-rlのCallbackクラス継承）
class Render(Callback):
    def on_step_end(self, step, logs={}):
        plt.clf()
        plt.imshow(env.render(mode='rgb_array'))
        display.display(plt.gcf())
        display.clear_output(wait=True)

MODE = 'train' # 'train' or 'test' 学習とテストのモード切替え

if MODE == 'train':
    weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
    checkpoint_weights_filename = 'dqn_' + ENV_NAME + '_weights_{step}.h5f'
    log_filename = 'dqn_{}_log.json'.format(ENV_NAME)
    callbacks = [ModelIntervalCheckpoint(checkpoint_weights_filename, interval=250000)]
    callbacks += [FileLogger(log_filename, interval=100)]
    dqn.fit(env, callbacks=callbacks, nb_steps=1750000, log_interval=10000)

    dqn.save_weights(weights_filename, overwrite=True)
    # dqn.test(env, nb_episodes=10, visualize=False)
    
elif MODE == 'test':
    weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
    dqn.load_weights(weights_filename)

    # 表示用コールバック関数を適用
    callbacks = Render()
    plt.figure(figsize=(6,8))
    dqn.test(env, nb_episodes=2, visualize=False, callbacks=[callbacks])

env.close()

元々のサンプルはargparseで'train'か'test'でモードの切り替えをしていましたが、かわりに変数MODEを用意して切り替えています（argparseの代わりにeasydictを使うといいようです）。
keras-rlのCallback関数をオーバーライドしJupyter用に表示用サブクラスをつくって、毎ステップごとにenv.render(mode='rgb_array')を呼び出して表示させています。keras-rlのCallbackクラスを見てみると、episodeやstepの前半後半のタイミングでコールバックできるようで、今回はstep後半のon_step_end()に表示機能を挿入しておきました。
この結果、一応Jupyter上には表示できるようになりましたが、plt.imshow()を使っているせいか動きが遅くなってしまいます。やはり別窓に表示させたほうがいいかもしれません。リアルタイムで表示させなくてもいいのであれば、以下の方法がいいかと。


Jupyter Notebook上にアニメーション表示とGIF動画保存：
matplotlibのArtistAnimationクラスで先程のブロック崩しを表示しつつ、GIF動画として保存する方法についてです。訓練後のテスト部分を少し変えて以下のようにしてみました。

from rl.callbacks import Callback
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
%matplotlib inline

ims = []  # アニメーション用リスト

class Render(Callback):
    def on_step_end(self, step, logs={}):
        im = plt.imshow(env.render(mode='rgb_array'))
        ims.append([im])

weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
dqn.load_weights(weights_filename)

callbacks = Render()
fig = plt.figure(figsize=(4,5)) # 出力画面サイズ調整
plt.axis('off')                 # 目盛り、枠線なし
dqn.test(env, nb_episodes=1, visualize=False, callbacks=[callbacks])

ani = animation.ArtistAnimation(fig=fig, artists=ims, interval=10)
# ani.save("anim.gif", writer = "imagemagick") # GIFアニメ保存する場合はコメントアウト
plt.close()

# Jupyter Notebook上にアニメーション表示
HTML(ani.to_jshtml())        # JavascriptHTML出力
#HTML(ani.to_html5_video())  # HTML5 Video出力（.mp4ファイルとしてダウンロード可）

サブクラスRender()内で予め用意しておいたアニメーション用リストに毎ステップ画像を追加していき、それをあとからArtistAnimationで動画にするという手順です。ArtistAnimationを使えばすぐにGIF動画として保存もできます。

Jupyter上のアニメーション表示としては2種類あり、JavascriptHTMLは動画速度を変えて再生も可能なので便利です（上画像）。またHTML5 Video出力のほうは表示画面から.mp4として動画をダウンロードできる機能がついています。
尚、matplotlibのArtistAnimationについては以前投稿したここを参照して下さい。

追記：尚、このボタン付きアニメーションをWebページに埋め込むには以下。
Matplotlib Animation embed on web page：アニメーションのWebページ上への埋め込み


まとめ：
OpenAIのGYMとKeras-RLを使うことで簡単にDQNを試すことができます。DQNに渡すパラメータについて理解しておけばいいという感じです。
このほか、二足歩行モデルがあるMuJoCo、ロボットアームやハンドマニピュレータがあるRoboticsのサンプルもあります。学習させるには結構時間かかりそうなので、まだ試してはいませんが、強化学習は生成モデルとはまた違ったアプローチをしている部分が興味深いという感じ。また、強化学習と生成モデルの組み合わせもできそうなので、アルゴリズム的に面白くなりそうです。
GPUがなくても、Google Colabを使えばこの程度の訓練であれば短時間でおわるかもしれません。

関連：
Google Colabの無料GPUで強化学習訓練を試す（Keras-RL）

Loading

Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.

view raw dqn-atari-keras-rl.ipynb hosted with ❤ by GitHub

機械学習スタートアップシリーズ Pythonで学ぶ強化学習 入門から実践まで (KS情報科学専門書)

posted with amazlet at 19.11.04

久保 隆宏
講談社
売り上げランキング: 115,841

Amazon.co.jpで詳細を見る

tf.kerasでDCGAN（Deep Convolutional Generative Adversarial Networks）

前回VAE（Variational Autoencoder）を試して見たので、今回はDCGAN（Deep Convolutional Generative Adversarial Networks）をKerasで実装しつつ理解を深めたいと思います。使用データはMNISTです。 元々GANによる画像生成に興味があったのですが、約10ヶ月前にサンプルを試したときには、二つの敵対するネットワークによって画像生成するという大まかな流れしか理解できませんでした。
チュートリアルなどでは、
・Autoencoder（AE）
・Variational Autoencoder（VAE）
・Generative Adversarial Networks（GAN）
という順番で説明されていることが多く、VAE（潜在空間、ベイズ推定、KLダイバージェンスなど）を理解しないことにはGANを理解することも難しいかなと勝手に思っていましたが、そもそもAEとVAEも大きく異なるしGANもまた別のアルゴリズムという感じで、基本のAEが分かればGANを理解することはできそうです。
GANの派生型はいろいろありますが、とりあえず今回はDCGANを理解しようと思います。

画像ソース

上の画像はDCGANの構造で、左半分がGeneratorで右半分がDiscriminatorです。最終的にはGenerator層の右端（上画像中央：64x64x3）に画像が生成されます。
まずGeneratorで画像生成する前に、Discriminatorの左端から訓練画像を入力してDiscriminatorだけを教師あり学習します。その後、GeneratorとDiscriminatorを連結させたネットワークで教師あり学習させます。このときDiscriminatorの学習を停止させておいてGeneratorだけが学習するようにします。そうすると既に学習されているDiscriminatorを利用しながらGeneratorだけが学習し、その結果として画像が生成されます。この交互に学習させる手順がわかりにくいので難しく見えるのかもしれません。
GeneratorはAEやVAEのdecoder層だけで構成されている感じで、最初のノイズ画像はVAEで言う潜在空間と呼びますが、途中でReparameterization TrickやKLダイバージェンスなどの複雑な計算を使うこともないので、潜在空間というよりは単なるノイズ画像（np.random.normalで生成）と捉えたほうがよさそうです。


GANの訓練の特長：
先ほどの訓練手順についてですが、GANの訓練では、以下のようにそれぞれ別々に訓練させるようです。
・Discriminatorの本物画像識別の訓練（訓練画像を利用）
・Discriminatorの偽物画像識別の訓練（Generator生成画像を利用）
・Generatorの本物画像生成の訓練（Discriminator層も利用するが訓練を一時停止）

GANの説明では、Discriminatorは本物か偽物を見分けると書いてあり、Discriminatorに入力した画像が最終的に1か0に判定されるような層になっています。訓練用画像（本物）を入力した際にはラベルを1とし、ノイズ画像（偽物）を入力した際にはラベルを0として固定して（教師データとして）、それぞれを分けて学習させていきます。そうすることで、Discriminator層には本物/偽物を見分ける重み付けが徐々に形成されていきます。

一方Generatorでは、ノイズ画像を本物画像に近づくように訓練しなければいけないのですが、AEやVAEのように具体的な訓練画像を目指してdecodeしていくわけではないので、一体どうやって本物に近づけていくのだろうと疑問に思っていました。
最終的にはGeneratorのノイズ画像が、Discriminator層の最後の1次元の出力層で1（本物）になるようにGenerator層が学習していけばいいということになります。そのためには、Generator単独で訓練するのではなく、Discriminator層も連結してラベル（教師データ）を1に固定して訓練させます。画像を教師データにして訓練するのではなく、本物かどうかというラベルを教師データにして訓練する点がGANの特長だと思います（それでも画像生成は可能）。ただし、二つを連結させると両方とも訓練してしまうので、二つのうちGenarator層だけを訓練させるために、

discriminator.trainable=False

を挿入してDiscriminatorの訓練を一時停止しておく必要があります。
この部分に注意すれば、あとはそれほど難しいアルゴリズムが登場してくることはないかと。解説を読むと数式や抽象的な概念が出てきますが、アルゴリズム的に訓練の手順を理解すればそれほど難しいものではないような気がします。AEではモデル全体は真ん中がくびれていますが、GANの場合は始まりと終わりが細くて真ん中が太くなっているので（decoderとencoderを逆につなげたように）一見わかりにくいという印象です。しかしよくみれば、100次元のノイズを入力元として、decoder（Genarator）で28*28次元のMNIST画像に拡大し（生成画像）、またそれをencoder（Discriminator）で1次元まで落として、最後はsigmoidで0/1判定するという流れになっています。


DCGAN実装：

環境：
Ubuntu 18.04.1
GTX 1060
CUDA 9.0
Python 3.6
Tensorflow 1.9 (Keras 2.1.6)
Jupyter Notebook 5.6


まずはモジュールのインポート。今回もJupyter Notebookで。

import tensorflow as tf
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, BatchNormalization
from tensorflow.keras.layers import Conv2D, Conv2DTranspose, Activation, LeakyReLU
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

tf.logging.set_verbosity(tf.logging.ERROR)

警告がでるので、tf.logging.set_verbosity()で非表示にしています。
次に、各種変数とGenerator層。

img_rows = 28
img_cols = 28
channels = 1
img_shape = (img_rows, img_cols, channels)
latent_dim = 100

def generator_model():
    model = Sequential()
    model.add(Dense(1024, input_shape=(latent_dim,)))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Dense(7*7*128))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Reshape((7,7,128)))
    model.add(Conv2DTranspose(64, kernel_size=5, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(1,kernel_size=5, strides=2, padding='same'))
    model.add(Activation('tanh'))
    
    return model

Generator層では、BatchNomarization、LeakyReLU、Conv2DTransposeを入れてみました。DCGANを安定させる方法としていろいろ工夫があるようですが、いくつか試したなかで今回はこの方法で。LeakyReLUのalpha値をデフォルトにするだけでも結果が変わってしまうので、このへんのパラメーターチューニングは難しそう。

次に、Discriminator層。

def discriminator_model():
    model = Sequential()
    model.add(Conv2D(32, kernel_size=5, strides=2,padding='same', input_shape=img_shape))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(16,kernel_size=5,strides=2, padding='same'))
    model.add(BatchNormalization())              
    model.add(LeakyReLU(alpha=0.01))
    model.add(Flatten())
    model.add(Dense(784))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Dense(1))
    model.add(Activation('sigmoid'))
    
    return model

こちらもLeakyReLU、BatchNomalizationを入れています。
Dropoutを入れて試してみましたが逆効果となってしまったので、今回はなし。

次は、GenaratorとDiscriminatorの連結層。

def combined_model():
    discriminator.trainable = False
    model = Sequential([generator, discriminator])
    
    return model

Generatorを訓練する際にこの連結層を使用します。そのため事前に、discriminator.trainable=Falseにしておきます。こうすることでGeneratorだけの訓練になります。

まずは、MNISTデータの読み込みと正規化（-1〜1）。そして、Discriminator、Generator、Combined（G + D）モデルの定義。Adamで最適化。

(x_train, _), (_, _) = mnist.load_data()
x_train = (x_train.astype('float32') - 127.5) / 127.5
x_train = x_train.reshape(-1, 28, 28, 1)

# Discriminator Model
discriminator = discriminator_model()
discriminator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0002, beta_1=0.5), metrics=['accuracy'])

# Generator Model
generator = generator_model()

# Combined(G + D) Model
combined = combined_model()
combined.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.00015, beta_1=0.5))

そして訓練ループ。
まずDiscriminatorの訓練をリアル画像とフェイク画像に分けて行います。
訓練はfitではなくtrain_on_batchでバッチごとに行うといいようです。その際にDiscriminatorの場合は、フェイク:0とリアル:1の二つのラベルを教師データとして与えておき、それぞれを別々に訓練し、最後にそのロスを合算しておきます。
次のGeneratorの訓練では、教師データをリアル:1として与えておき、Discriminatorの訓練を一時停止した状態で連結したcombinedモデルを訓練させます。そうすると出力がリアル:1になるようにGeneratorの重み付けが形成されます。この部分がGAN特有の訓練のさせ方だと思います。

batch_size = 32
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))

epochs = 10000
Loss_D = []
Loss_G = []

import time
start = time.time()

for epoch in range(epochs):
    
    # shuffle batch data
    idx = np.random.randint(0, x_train.shape[0], batch_size)
    imgs = x_train[idx]
    
    # Train Discriminator
    # sample noise images to generator
    noise = np.random.normal(0, 1, (batch_size, latent_dim))
    gen_imgs = generator.predict(noise)

    # train discriminator real and fake
    d_loss_real = discriminator.train_on_batch(imgs, real)
    d_loss_fake = discriminator.train_on_batch(gen_imgs, fake)
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # Train Generator
    g_loss = combined.train_on_batch(noise, real)
 
    Loss_D.append(d_loss[0])
    Loss_G.append(g_loss)

    if epoch % 100 == 0:
        print("%04d [D loss: %f, acc.: %.2f%%] [G loss: %f] %.2f sec" % (epoch, d_loss[0], 100*d_loss[1], g_loss, time.time()-start))

    if epoch == epochs - 1:
        r, c = 5, 5
        noise = np.random.normal(0, 1, (r * c, latent_dim))
        gen_imgs = generator.predict(noise)
        gen_imgs = 0.5 * gen_imgs + 0.5

        fig, axs = plt.subplots(r, c)
        cnt = 0
        for i in range(r):
            for j in range(c):
                axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
                axs[i,j].axis('off')
                cnt += 1
        plt.show() 

Discriminatorの訓練（2種類別々で訓練し最後に合算）：
d_loss_real=ノイズ-->Generator-->Discriminator-->realラベル（教師データ）
d_loss_fake=ノイズ-->Generator-->Discriminator-->fakeラベル（教師データ）
Discriminator_loss=0.5*(d_loss_real+d_loss_fake)

Generatorの訓練：
g_loss=ノイズ-->Generator-->Discriminator(訓練停止)-->realラベル（教師データ）
という手順でそれぞれを訓練しています。
教師データとなるreal/fakeラベルはbatch_size分用意しておき、train_on_batch()に代入します。

合計10000エポック回して、100エポックごとに各Lossを表示。最後に最終画像を表示。

生成画像結果：

生成画像（10000エポック）。

途中の画像も見てみましたが、5000エポックくらいでもそこそこ識別できるレベルにはなりましたが、10000エポックくらい回したほうがよさそうです（GTX1060で約6分、Macだと１時間はかかりそう）。モード崩壊（似たような画像ばかりになる現象）は発生していないようです。

生成画像（5000エポック）。やや不明瞭？？

生成画像（2500エポック）。

生成画像（2000エポック）。このあたりだとやはり不鮮明。

以下のコードでLossを表示。

plt.plot(np.arange(epochs), Loss_D, 'r-')
plt.plot(np.arange(epochs), Loss_G, 'b-')

赤：Discriminator Loss、青：Generator Loss
これをみてもよくわからない。3000エポック以降はあまりかわっていないようなので5000エポックくらいの訓練でもいいのかもしれない。


まとめ：
DCGANは思っていたよりもシンプルな構造で、GeneratorとDiscriminatorをつくれば、あとはそれぞれの訓練の手順を間違わないようにコーディングしていけばいいという感じです。どちらかというとVAEのほうが難しかったという印象です。
ただしDCGANで難しいのは、GeneratorとDiscriminatorの中身の層をどうするか？ということかもしれません。ここを参考にすると、LeakyReLUやBatchNormを使った方がいいらしいのですが、層の順番やパラメータが少し違うだけでも生成画像がノイズのままで終わってしまうので、安定的に画像生成させるにはいろいろ試してみる必要がありそうです。GANの派生型はたくさんあるので、DCGAN以外のGANも試して比較してみたほうがよさそうです。


参考にしたサイト：
https://towardsdatascience.com/having-fun-with-deep-convolutional-gans-f4f8393686ed
https://elix-tech.github.io/ja/2017/02/06/gan.html
https://qiita.com/triwave33/items/1890ccc71fab6cbca87e
https://qiita.com/t-ae/items/236457c29ba85a7579d5

直感 Deep Learning ―Python×Kerasでアイデアを形にするレシピ

Posted with Amakuri at 2018.12.21

Antonio Gulli, Sujit Pal

オライリージャパン

販売価格 ￥3,672

Amazonで詳細を見る

tf.kerasでVAE（Variational Autoencoder）

Tensorflowもあっというまに1.9までバージョンアップしており、トップページが日本語表示になっていました。Get started with Tensorflowという最初のチュートリアルも変わったようで、Keras、Eager、EstimatorがHigh Level APIとして前面にでてきています。Pytorchも試していましたが、Tensorflowがますます便利になっていくのでTensorflowに戻りつつあります。書きやすくなったEagerやtf.layersも試してみましたが、結局Kerasがシンプルでわかりやすいという結論に達し、Keras自体もバージョンアップしたようなのでTensorflowというよりもKerasでVAEを試してみようかと。

VAEは中間層で突然正規分布が登場して、ベイズ的な手法で画像生成していくアルゴリズムが興味深く、固定値を確率に変換して表現するという部分がずっと気になっていました（最初に試したのは約10ヶ月前）。
潜在空間、ベイズ推定、Reparameterization trick、KL-divergenceなど、画像生成に通じるテクニックを勉強するにはちょうどいいサンプルだと思います（かなり難しいですが）。

TensorflowでKerasをインポートする際に、以前はtensorflow.python.kerasだったけど、Tensorflow 1.9からは、tensorflow.kerasで使えるようになったようです。

Kerasの書き方：
Kerasの場合いくつか書き方があり、
Sequential()の中に各層をそのまま並べて行く方法。

model = Sequential([
    Dense(32, input_shape=(784,)),
    Activation('relu'),
    Dense(10),
    Activation('softmax'),
])

Sequential()でモデルを定義してから各層をaddで追加していく方法。

model = Sequential()
model.add(Dense(32, input_shape=(784,))
model.add(Activation('relu'))
model.add(Dense(10))
model.add(Activation('softmax'))

これらの方法はSequentialモデルと呼ばれ、各層をそのまま重ねていけばいいのでわかりやすい。

このほか、functional APIというモデルがあり、各層に変数をつけて行末の()に前の層を代入し、最後にモデルを定義する方法。

inputs = Inputs(shape=(784,))
layer1 = Dense(32, activation='relu')(inputs)
outputs = Dense(10, activation='softmax')(layer1)

model = Model(inputs,outputs)

行末の（）なしで各層を連結させないで書くには以下。あとから連結式（代入式）を書いて、先ほどの結果（Model）と同じになります。

inputs = Inputs(shape=(784,))
l1 = Dense(32, activation='relu')
l2 = Dense(10, activation='softmax')

layer1 = l1(inputs)
outputs = l2(layer1)

model = Model(inputs,outputs)

Sequentialモデルのほうがすっきりしてわかりやすいけれども、VAEの場合だと少し複雑になるので、今回はfunctional APIで各層を別々に書いていくタイプを使います。
そのほか、これらModelクラスをサブクラス化する書き方もあるけれど、一行ずつ順を追ってベタに書いていったほうが理解しやすいので、今回はサブクラス化せずにJupyter Notebookに書いていこうと思います。

VAEの実装：

環境：
Ubuntu 18.04
GTX 1060
CUDA 9.0
python 3.6
tensorflow 1.9
Jupyter Notebook 5.6


まずは各モジュールのインポート。

import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras import losses, backend as K
from tensorflow.keras.layers import Dense, Input, Lambda
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

そして、今回使用するmnistデータセットの読み込みと正規化、28x28の画像を784の1次元へ平坦化。

mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)

このへんはサンプルなどでもお馴染みの方法。

Encoderと潜在変数z：
そして、encoder層。

# encoder
inputs = Input(shape=(784,))
encoder_h = Dense(256, activation='relu')(inputs)
z_mu = Dense(2, activation='linear')(encoder_h)
z_log_sigma = Dense(2, activation='linear')(encoder_h)

encoderは、784次元に平坦化された画像を入力とし、reluを通して256次元に変換、その後さらに2次元へ変換し正規分布のパラメータとなる平均muと分散logΣに分けておきます。分散をΣではなくlogΣにしているのは、encoderからの出力が負の場合もあるため、Σ=σ²が常に正であるのに対し、logをつけることで負の値であっても成立するようにしているらしい（論文p11でもlogσ²と書いてある）。
要は、計算から求められる固定値を正規分布という確率分布に置換してから演算することで画像生成を可能にしているようです。

平均と分散をもとに正規分布から値を取り出すには通常サンプリング（ある確率に従ってランダムに値を取り出す）が必要となり、数式では以下のようにあらわします。

z~N(μ,Σ)

このサンプリング式をnumpyであらわすと、

z=np.random.normal(loc=μ, scale=Σ, size=1)

になりzを求めることは可能ですが、サンプリングすると後々バックプロパゲーションが不可能（微分不可能）となるため、Reparameterization trickという代替演算法をつかうようで、

z=μ+Σ^0.5*ε

に置き換えて（平均値μに誤差εを掛け合わせた分散Σを足し合わせるという感じ）、
上の式中のΣをlogΣに変換するには、

Σ=exp(logΣ)

であるから、最終的には、

z=μ+exp(0.5*logΣ)*ε

という式になるようです。この部分が以下のdef sampling()の内容です。

def sampling(args):
    z_mu, z_log_sigma = args
    epsilon = K.random_normal(shape=(K.shape(z_mu)[0], K.int_shape(z_mu)[1]))
    return z_mu + K.exp(0.5 * z_log_sigma) * epsilon

z = Lambda(sampling)([z_mu, z_log_sigma])

# encoder model
encoder = Model(inputs, [z_mu, z_log_sigma, z])
encoder.summary()

潜在変数zを求めるLambda（keras.layers.Lambdaクラス）の部分はKerasのモデルの一部に組み込むために必要で、そのままsampling()関数からの戻り値を受け取るだけだと、モデルの一部としてバックプロパゲーションなどしてくれなくなるようです。
最後にsummary()でこのモデルの各層を確認できます（以下）。

_______________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
input_1 (InputLayer)            (None, 784)          0                                            
__________________________________________________________________________________________________
dense (Dense)                   (None, 256)          200960      input_1[0][0]                    
__________________________________________________________________________________________________
dense_1 (Dense)                 (None, 2)            514         dense[0][0]                      
__________________________________________________________________________________________________
dense_2 (Dense)                 (None, 2)            514         dense[0][0]                      
__________________________________________________________________________________________________
lambda (Lambda)                 (None, 2)            0           dense_1[0][0]                    
                                                                 dense_2[0][0]                    
==================================================================================================
Total params: 201,988
Trainable params: 201,988
Non-trainable params: 

先程のLambdaの計算部分もモデルに組み込まれているのがわかります。最初pythonのlambda式と勘違いしており意味がわかりませんでしたが、これはKerasレイヤーのLambdaということです。

Decoder：
そして残りのdecoder層。decoder層は訓練用と画像生成用の２種類のモデルをつくっておきます。これは訓練用の方です。

# decoder
d_h = Dense(256, activation='relu')
d_out = Dense(784, activation='sigmoid')

decoder_h = d_h(z)
outputs = d_out(decoder_h)

# vae: encoder + decoder
vae = Model(inputs, outputs)
vae.summary()

画像生成時にもこのレイヤーを使い回すので、それぞれのレイヤーごとに分けて書いておき、次の行でzと隠れ層を代入します。そして、encoderの入力からdecoderの出力までを足し合わせてvaeモデル（訓練用）をつくります。vae.summary()で先程と同様にモデルの各層を確認します（以下）。

Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
input_1 (InputLayer)            (None, 784)          0                                            
__________________________________________________________________________________________________
dense (Dense)                   (None, 256)          200960      input_1[0][0]                    
__________________________________________________________________________________________________
dense_1 (Dense)                 (None, 2)            514         dense[0][0]                      
__________________________________________________________________________________________________
dense_2 (Dense)                 (None, 2)            514         dense[0][0]                      
__________________________________________________________________________________________________
lambda (Lambda)                 (None, 2)            0           dense_1[0][0]                    
                                                                 dense_2[0][0]                    
__________________________________________________________________________________________________
dense_3 (Dense)                 (None, 256)          768         lambda[0][0]                     
__________________________________________________________________________________________________
dense_4 (Dense)                 (None, 784)          201488      dense_3[0][0]                    
==================================================================================================
Total params: 404,244
Trainable params: 404,244
Non-trainable params: 0

入力784次元、256次元、2次元（z_mu, z_log_sigma, z）、256次元、784次元という各層があることがわかります。基本的にはz_muとz_log_sigmaの二つだけでいいのですが、比較もしたいためにzも組み込んでおきました。

Generator：
上記のvaeモデル（encoder+decoder）でz値を通して訓練用画像（x_train）で学習しますが、訓練後はz_muとテスト画像（x_test）を用いてpredict（予測/画像生成）します。
その画像生成する際のgeneratorのコードが以下。

# generator
generator_in = Input(shape=(2,))
generator_h = d_h(generator_in)
generator_out = d_out(generator_h)

generator = Model(generator_in, generator_out)
generator.summary()

後々使うのですが、とりあえす先につくっておきます。

Loss function：
つぎは、ロスの計算です。この部分はVAE特有の難しいアルゴリズムで、Reconstruction lossの最大化とKL-divergence loss最小化を組み合わせることになりますが論文や解説などを参考にするしかないと言う感じ。KL-divergenceは二つの分布の比較の値を計算してくれるようです。差が少ないほど0に近づくので最小化していくには便利。

ネットで探してみるとKerasのバージョンによっても違いがあるのか計算方法や関数が微妙に異なっており、いろいろ試した結果この方法に（参考はここ）。recon内で784を掛けていますがK.sum()でもいいのかもしれません。

def vae_loss(inputs, outputs):
    recon = 784 * losses.binary_crossentropy(inputs, outputs)
    kl = - 0.5 * K.sum(1 + z_log_sigma - K.square(z_mu) - K.exp(z_log_sigma), axis=-1)
    return K.mean(recon + kl)

vae.compile(optimizer='adam', loss=vae_loss)

epochs = 10
vaefit = vae.fit(x_train, x_train, 
                 shuffle=True,
                 epochs=epochs,
                 batch_size=64,
                 validation_data=(x_test, x_test),
                 callbacks=[])

今回はadamで最適化してみました。vae.fit()内のcallbacks=[]を加えることで訓練中のロス値を呼び出すことができるようで、それを利用してグラフを描くことができるようです。Tensorboardも利用できるようですが、今回はmatplotlibで。

# plot loss
loss = vaefit.history['loss']
val_loss = vaefit.history['val_loss']

plt.plot(range(1,epochs), loss[1:], marker='.', label='loss')
plt.plot(range(1,epochs), val_loss[1:], marker='.', label='val_loss')
plt.legend(loc='best', fontsize=10)
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

このコードを書き加えると以下のグラフが描けます。

100エポック回したときのロスの変化です。まだ下がりそうですが、100エポックでやめてしまいました。GTX1060で1エポック3秒前後（batch_size=64）。
隠れ層のユニット数やbatch_sizeを調整したほうがいいのかもしれませんが続行。

視覚化：
つぎは、結果の出力。

hidden_imgs = encoder.predict(x_test)
model_imgs = generator.predict(hidden_imgs[0])
vae_imgs = vae.predict(x_test)

s = 0
n = 10
plt.figure(figsize=(10, 3.1))
plt.subplots_adjust(wspace=0, hspace=0)

for i in range(n):
    #original
    ax = plt.subplot(3, n, i + 1)
    plt.imshow(x_test[i+s].reshape(28, 28))
    plt.axis('off')
    plt.gray()

    #reconstruction
    ax = plt.subplot(3, n, i + 1 + n)
    plt.imshow(model_imgs[i+s].reshape(28, 28))
    plt.axis('off')
    
    #vae model
    ax = plt.subplot(3, n, i + 1 + n + n)
    plt.imshow(vae_imgs[i+s].reshape(28, 28))
    plt.axis('off')
    
plt.show()

最初にencoder層をpredictし、その結果（hidden_imgs[0]はz_muによる出力）をgenarator層（生成用モデル）に渡して画像を得ています。同様にvae（訓練用モデル）も使って画像生成してみました（こちらはz経由での出力）。
結果の画像。オリジナル、encoder/z_mu/generator生成画像、vaeモデル:encoder/z/decoder生成画像。

4と9のような画像が多いので、まだ改良の余地がありそうです。

そして、2次元の潜在空間（z_mu）での各数字の分布。二つの値がそれぞれ横軸と縦軸に割り当てられそれを座標上に表したものです。

plt.figure(figsize=(10,10))
plt.scatter(hidden_imgs[0][:,0] ,hidden_imgs[0][:,1], marker='.', c=y_test, cmap=plt.get_cmap('tab10'))
plt.colorbar()
plt.grid()

cmapでtab10を用いることで10段階で色分けしています。結果の画像は以下。

これを見ると数字の5（茶色）が、かろうじてy=0より少し上に横に細長く並んでいるのがわかります。0、1、3、7は、領域がはっきり分かれているため認識しやすそうですが、それ以外は中央に重なるように集中しているので識別しにくそうです。

さらに、この分布をグリッド状の画像に置き換えるコード。

n = 20
digit_size = 28
figure = np.zeros((digit_size * n, digit_size * n))
grid_x = np.linspace(-2, 2, n)
grid_y = np.linspace(-2, 2, n)[::-1]

for i, yi in enumerate(grid_y):
    for j, xi in enumerate(grid_x):
        z_sample = np.array([[xi, yi]])
        x_decoded = generator.predict(z_sample)
        digit = x_decoded[0].reshape(digit_size, digit_size)
        figure[i * digit_size: (i + 1) * digit_size, j * digit_size: (j + 1) * digit_size] = digit

plt.figure(figsize=(10, 10))
start_range = digit_size // 2
end_range = n * digit_size + start_range + 1
pixel_range = np.arange(start_range, end_range, digit_size)
sample_range_x = np.round(grid_x, 1)
sample_range_y = np.round(grid_y, 1)
plt.xticks(pixel_range, sample_range_x)
plt.yticks(pixel_range, sample_range_y)
plt.xlabel("z [0]")
plt.ylabel("z [1]")
#plt.imshow(figure, cmap='gnuplot')
plt.imshow(figure, cmap='Greys_r')
plt.show()

先程の分布のグラフはx:-4〜4、y:-4〜4の範囲ですが、このコード内の4、5行目のgrid_xとgrid_yのnp.linspaceの範囲を-2〜2に変えることで、その範囲での数の分布を見ることができます。以下がその結果。

これは分布グラフの範囲をx:-2,2、y:-2,2に限定して出力したものです。先程のドットの分布で5が水平に細長く分布していたように、この画像においても中央右寄りに細長く水平に分布しています。一応一通り0〜9が存在していますが、分布領域が広範囲な数と狭い範囲にしかない数があるのがわかります。
ただ、このような結果から1と3と5の中間に8が位置していたりと、その特性を利用して面白い画像生成ができそうです。

まとめ：
VAEは以前Tensorflowのサンプルを試しましたが、単なるAutoencoderに比べると潜在変数やReparameterization trick、さらにはロス関数の部分の理解が難しいという印象でした。今回あらためてKerasで書いてみると、Kerasのシンプルな構造のおかげか、かなり理解が深まりました。特に最後の２つの分布的なグラフについてはどう表示するのかと思っていましたが、どこをいじればどうなるかが分かりました。
通常のAutoencoderの場合なら入力から出力までそのまま層を重ねて行けばいいのですが、VAEの場合だと中間層で正規分布からサンプリングするため、そのままだと訓練時にバックプロパゲーションができなくなってしまうことからReparameterization trickで微分計算可能な経路につくりかえます。訓練後はReparameterization trickは必要ないので、encoderからそのまま分布の中心位置となるz_mu経由でgeneratorを通り出力するということになっています。

訓練時（x_train）：
encoder
z_mu, z_log_sigma
z(Reparameterization trick)
decoder

訓練後（x_test）：
encoder
z_mu
generator


参考にしたサイト：
https://qiita.com/kenchin110100/items/7ceb5b8e8b21c551d69a
https://wiseodd.github.io/techblog/2016/12/10/variational-autoencoder/
https://www.kaggle.com/rvislaywade/visualizing-mnist-using-a-variational-autoencoder
https://blog.csdn.net/A_a_ron/article/details/79004163

関連：
tf.kerasでDCGAN（Deep Convolutional Generative Adversarial Networks）

直感 Deep Learning ―Python×Kerasでアイデアを形にするレシピ

Posted with Amakuri at 2018.12.21

Antonio Gulli, Sujit Pal

オライリージャパン

販売価格 ￥3,672

Amazonで詳細を見る

Bayesian Optimization / Gaussian Process

前回、matplotlibのアニメーションについては大体使えるようになったので、「ベイズ最適化・ガウス過程」を実験してみました。いろいろと専用のライブラリがあるのですが（GPy、GPFlow、Edward、Pyroなど）、今回はscikit-learn Gaussian Processesを使っています。

ベイズ最適化はハイパーパラメータチューニングに使われるようで、ブラックボックス関数における最大値（あるいは最小値）を全領域をスキャンしなくても探し出すことができる方法のようです。

今回の場合は、グラフ内の赤破線の最大値がどこにあるか探索しています。赤破線を見ると、左と右にピークが二箇所ありますが、微妙に右側のほうが高いという設定にしてあります。それを間違えないように探し出せるかという実験です。

右側の赤丸が正解（最大値）の地点です。この地点は、x座標-2〜2までの範囲を0.1刻みで200回スキャンし、その結果から最大値を求めています。

しかし、ベイズ最適化の場合は、200回スキャンしなくても約10回程度で、どこが最大値なのかを効率よく探してくれるようです。

今回の手順として：
・カーネル：Matern、獲得関数：UCBを選択

・xの範囲（-2〜2）からランダムにまず2点（青丸：start印）選んで初期観測値とする

・その観測値から、全域のμ（青破線）とσ（青塗）を求める

・μとσを獲得関数（UCB）に代入

・獲得関数の結果（緑実線）から最大値の箇所を見つける

・獲得関数の最大値から、それに相当するxの位置を見つける

・xの位置から、それに相当するyの位置を求める

・ここで求めたxとyの座標を次回の探索箇所にする

・次回探索箇所を観測値リストに加える

・あとは繰り返し

グラフ下部（緑実線）にあるのが獲得関数UCBの値です。緑実線の一番高いところが、次の探索地のx座標となります。

今回使用したUCBの中身は単純で、

UCB最大値 = mu + kappa * sigma

となっています。係数kappa=1.0の場合は、μ値（青破線）にσ値（青塗）を足した値がそのままUCB最大値となるので、グラフ内の青塗を含めた一番高い箇所が次の探索箇所となります。μ値が高いところほど選ばれがちですが、kappaを大きくするとσ値も大きくなるので、μ値が低い箇所でも探索される可能性があがります。

%matplotlib inline
import numpy as np
from matplotlib import pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern
import matplotlib.animation as animation
from IPython.display import HTML

np.random.seed(111)

def f(x):
    return -np.sin(x*4.5)*x*0.3+0.02*x                  # 真の関数（赤破線表示）

x = np.linspace(-2,2,200)                               # x値範囲
y = f(x)                                                # 真のy値

fig = plt.figure(figsize=(12,6))                        # 画面サイズ設定
ax = plt.subplot()                                      # サブプロットを用意
ax.axis([x.min(),x.max(),y.min()*2,y.max()*2])          # グラフ範囲設定（x,yの値に依存）
ax.set_aspect(1.0)                                      # アスペクト比設定

ax.plot(x,y,'r--',alpha=0.8)                            # 真の関数曲線をプロット（赤破線）
ax.plot(x[np.argmax(y)],y.max(), 'ro',alpha=0.8)        # y正解値；x全域スキャンによるy最大値（赤丸）

init_pt = 2                                             # 初期観測値個数
xi = np.random.uniform(x.min(),x.max(),init_pt)         # 初期観測値：xの範囲から2箇所ランダム選択
yi = f(xi)                                              # 初期観測値：yの値
ax.plot(xi,yi,'bo')                                     # 初期観測値プロット（青丸）
for i in range(len(xi)):
    ax.text(xi[i],yi[i],'  start'+str(i),color='b')     # 初期観測値：'start'文字表示

def UCB(mu_x, sigma_x, kappa=1.0):                      # 今回使用する獲得関数：upper_confidence_bound
    return mu_x + kappa * sigma_x                       # kappa増大-->σ増大-->探索領域拡大

kernel = Matern(length_scale_bounds="fixed")            # 今回使用するカーネル：Matern
gp = GaussianProcessRegressor(kernel=kernel,alpha=0.01) # scikit-learnガウス過程回帰オブジェクト

ims = []                                                # アニメ用リスト
itr = 15                                                # 探索ループ回数

for i in range(itr):
    gp.fit(xi[:,None],f(xi))                                 # 観測値フィッティング（xiをリシェイプして代入）
    mu_x, sigma_x = gp.predict(x[:, None], return_std=True)  # μ(x)とσ(x)を獲得（事後分布）

    a_x = UCB(mu_x, sigma_x, kappa=2.0)                      # UCBでa(x)最大値を得る
    index = np.argmax(a_x)                                   # a(x)最大値のindexを得る
    x_next = x[index]                                        # a(x)最大値のindexから次のx探索値を決定
    y_next = f(x_next)                                       # y探索値決定
    
    P1 = ax.plot(x, mu_x, 'b--')                                               # μ値（青破線）
    P2 = ax.fill_between(x, mu_x-sigma_x, mu_x+sigma_x, color='b', alpha=0.2)  # σの範囲（青塗）
    P3 = ax.plot(xi,yi,'bx',markersize=8)                                      # 探索済み箇所（青クロス）
    P4 = ax.plot(x_next, y_next, 'mo')                                         # 現在探索箇所（マジェンタ丸）
    P5 = ax.plot([x_next,x_next],[y.min()*2, y_next] ,'m-', alpha=0.6)         # 現在探索箇所（マジェンタ縦線）
    P6 = ax.plot(x_next,(a_x[index]-a_x.min())/2+y.min()*2, 'go',alpha=0.8)    # a(x)最大値：σ（青丸）
    P7 = ax.plot(x, (a_x-a_x.min())/2+y.min()*2, 'g-')                         # 獲得関数値：a(x)
    P8 = ax.plot([xi,xi],[[y.min()*2]*len(yi),yi], 'b-', alpha=0.2)            # 探索済み箇所（青縦線）
       
    xi = np.r_[xi,x_next]                                  # 現在探索箇所をリストに加える（r_: concatenateの代用）
    yi = np.r_[yi,y_next]
    
    ims.append(P1 + [P2] + P3 + P4 + P5 + P6 + P7 + P8)    # アニメ用リストへ各プロットを入れる
    
print('x :',x[y.argmax()], '   y :',y.max())               # 正解値出力（y値）
print('xi:',xi[yi.argmax()], '   yi:',yi.max())            # 最終最大値出力（yi値）

ani = animation.ArtistAnimation(fig, ims, interval=1000)   # アニメ関数
#ani.save("gp_sim.gif", writer = "imagemagick")            # GIFアニメ保存
plt.close()
HTML(ani.to_html5_video())                                 # HTML5 Video 出力（mp4ダウンロード可）
#HTML(ani.to_jshtml())                                     # JavascriptHTML 出力

GaussianProcessRegressor()にはカーネルを指定する箇所があり、今回は、scikit-learnのMaternを使っています。ちなみにカーネルを指定せずデフォルトのままだと、以下のような感じになります。

σ（青塗）の領域が結構変わります。
scikit-learnのこのページにカーネルの違いについて書いてあります。

ハイパーパラメータチューニングと言っても、カーネルの選び方でもかなり違いがでてきます。
また、獲得関数もUCB以外にいくつかあるので、それも選ばなければいけないという感じです。


参考にしたサイト：
Scikit-learn Gaussian Processes
llSourcell/hyperparameter_optimization_strategies
ベイズ最適化入門
機械学習のハイパーパラメータ探索 : ベイズ最適化の活用

関連：
GPyOpt: Digital Recognizer(MNIST) CNN Keras ハイパーパラメータ最適化

Deep Learning用ノートパソコン（GPU:GTX1060）のエディタと実行環境

Deep Learning用ゲーミングノートパソコンの設定は一段落したのですが、使っているうちに幾つか気になる点がでてきたので少しだけ以下の環境を見直してみました。

・Python用エディタの設定
・Deep Learning用ライブラリ、プラットフォームの選定
・デュアルブートパーティションによるUbuntuへの割当量

まずはエディタに関してです。

エディタ：Pycharm/Spyder/VS Code/Atom
Pycharmが使いやすいという評判から試してみましたが、案外Anacondaに同包されているSpyder IDEというエディタのほうが使いやすかったです。しかしどちらもややカスタマイズしにくい。それでは人気のあるVS Codeはどうかというと、拡張性もありカスタマイズできそうだし、なにより動きが軽快。ということで、VS Codeで環境を整えていましたが慣れないこともあり、いまいち上手くいかない。それで、いままで使っていたAtomに戻って設定し直してみると、望んでいるような使い方ができるとわかり、結局のところAtomを使うことに。AtomはVS Codeに比べてやや重い感じもしますが、パッケージの豊富さとかなりのカスタマイズ自由度があって使いやすい。

Spyder IDE：　
Anaconda Navigatorからすぐにアップロードでき、比較的使いやすい印象。ただカスタマイズしにくい。ダークのthemeを選んでいるにもかかわらずフレーム部分だけは白いままで変えられない。オープンソースなので、元のソースを変えればカスタマイズ可能だろうけれども面倒。

Anaconda仮想環境に合わせたエディタ：
Atomを選んだ切っ掛けとして、Anacondaの仮想環境に対して設定がしやすいということが一つありました。Anaconda自体はかなり便利なのですが、切り替え可能な仮想環境とエディタをつなげる部分がやや面倒。要は仮想環境PATHへつなぐ設定法がそれぞれのエディタで異なっており、Atomの場合比較的簡単で自由度があったということです。

AtomとAnaconda Navigator：
Anacoda Navigatorでグラフィカルに複数の仮想環境を見比べることができるので便利。インストール/アンインストールもこの画面内で可能。仮想環境切り替えや接続に関してはAtomが比較的使いやすい。

最終的にはAnacondaの仮想環境は上画像のようにrootとpy35（Python3.5）だけにしました。それまでの仮想環境は：

・root（万が一のために備え、ここにはインストールしない/使わない）
・py35（安定版Tensorflow1.4、Pytorch0.2.0など/メインで使う用）
・py27（Python2.7にしか対応していないサンプルなどあるときに使う）
・cuda90（CUDA9に対応したα版Tensorflow1.5やソース版Pytorchなど/最新版実験用）

という感じで複数の仮想環境を使い分けて、どの環境が使いやすいか試していました。ライブラリやパッケージを入れすぎて不具合が出ても、仮想環境ごと消してしまえばいいのでシステムに影響を与えずに済みます。
Tensorflowなどを最新版（α版）にすれば最速になるのかと思いましたが、結局のところまだ不具合があったりサンプルも対応していなかったりとあまり使い勝手がよくない。ということから、サンプルも豊富な安定版を使ったほうがいいという結論に達しました。

Atomのパッケージ：
主には仮想環境の切り替えと接続が容易ということからAtomでの環境整備。MacBook Proのほうでは便利そうなパッケージをどんどん入れていましたが、今回はシンプルに最低限必要なパッケージだけをインストールしました。いまのところ標準装備のパッケージ以外3つだけで充分です。

・autocomplete-python
・platformio-terminal（このターミナルが使いやすい/Python RUN用）
・script（Python RUN用）

ネットで検索するとほぼ英語圏のサイトが多いことから英語表記のほうがわかりやすいため、日本語化しないことにしました。既存のOne Dark：Themeを使っていますが、フォントサイズや見た目的なカスタマイズは、Edit>Stylesheetからstyles.lessファイルで上書き変更しています。

PythonスクリプトをRUNさせる環境：
ここが一番悩んだところで、AtomのなかにもいくつかPythonスクリプトを実行できるパッケージがあり、ただRUNさせるだけであればどれでもいいのですが、ターミナルを使って実行させる方法とボタンやショートカット一発で実行できるものということ、そして仮想環境や作業ディレクトリの切り替えが即座にできるということから、platformio terminalとatom-scriptを選びました。

Anaconda仮想環境切り替え方法：
Anacondaの仮想環境を使っていると、毎回ターミナルで入力が必要になります。通常は以下の状態（Anaconda root：Python3.6）：

そして、以下を入力すると、
$ source activate py35

先頭に(py35)という表示がでて、仮想環境py35：Python3.5に入ったことになります。
追記：現在は「conda activate py35」に変更済み。

which pythonを打てば、どのPython interpreterを使うかという違いが分かります。いわゆるPythonのPATHについてです。

これは、which pythonをつかって両方の環境のPATHを確認してみた画面です。最初のwhich pythonがAnaconda/rootのPATHです。つぎのwhich pythonがAnaconda/py35のPATHになります。
実際のところ仮想環境はAnacondaだけでなく、その手前にpyenvでも仮想環境をつくっています。anacondaで色々試しているため、anaconda内部で不具合が起きてしまったら、pyenvでanacondaごとアンインストールしてしまえばいいというわけです（実際一度anacondaを入れ替えました）。

platformio terminalの設定（かなり便利）：
platformio自体は以前ESP32を試したときに使ったことがあるのですが、今回のようなPython用には設定していないので、あらためて使い直すという感じです。
Packages>Settings>Manage Packagesでインストール済みのパッケージリストからplatformioのsettingsボタンを押して各種設定に入ります。

主には、一番上のほうに出てくるこのあたりを設定します。
特にToggles欄の上から4番目の「Run Inserted Text」と5番目の「Select To Copy」にはチェックを入れておきます。
次にCore欄の、「Auto Run Command」に先程の仮想環境を切り替えるコマンドを入れておきます。ここではさらに、「which python」でPATHの確認、ディレクトリ内のリスト表示させる「ls」もセミコロンで区切っていれてあります。
その下の「Map Terminals To」でタブから「File」を選びます。
こうすると、platformio terminalが自動的に仮想環境に入って、しかも選択ファイルのディレクトリに移動して開いてくれます。

ファイルを切り替えるごとに、
source activate py35
which python
cd ${File}
ls
これらを自動的にやってくれて、仮想環境移行/PATH確認/作業ディレクトリへ移動/ディレクトリ内のリスト表示が一気にでてきて、実行する前の確認や手続きが一発で済みます。
ほかにもターミナルのパッケージがありますが、ここまでできるのはplatformio terminalくらいかもしれません。かなり便利です。
あとはプログラムをRUNさせるだけでいいのですが、もう一つ問題があります。

コマンドオプション付きのPythonプログラムの実行：
PytorchサンプルなどをRUNさせるときによくあることですが、Python Argparseでコマンドオプション（CUDAの有無やイテレーションの設定など）を追記する必要があります。

Pytorch examples/dcgan/main.pyをRUNさせる場合（コマンドオプション）：

parser.add_argument('--dataset', required=True, help='cifar10 | lsun | imagenet | folder | lfw | fake')
parser.add_argument('--dataroot', required=True, help='path to dataset')
parser.add_argument('--workers', type=int, help='number of data loading workers', default=2)
parser.add_argument('--batchSize', type=int, default=64, help='input batch size')
parser.add_argument('--imageSize', type=int, default=64, help='the height / width of the input image to network')
parser.add_argument('--nz', type=int, default=100, help='size of the latent z vector')
parser.add_argument('--ngf', type=int, default=64)
parser.add_argument('--ndf', type=int, default=64)
parser.add_argument('--niter', type=int, default=25, help='number of epochs to train for')
parser.add_argument('--lr', type=float, default=0.0002, help='learning rate, default=0.0002')
parser.add_argument('--beta1', type=float, default=0.5, help='beta1 for adam. default=0.5')
parser.add_argument('--cuda', action='store_true', help='enables cuda')
parser.add_argument('--ngpu', type=int, default=1, help='number of GPUs to use')
parser.add_argument('--netG', default='', help="path to netG (to continue training)")
parser.add_argument('--netD', default='', help="path to netD (to continue training)")
parser.add_argument('--outf', default='.', help='folder to output images and model checkpoints')
parser.add_argument('--manualSeed', type=int, help='manual seed')

このmain.pyをRUNさせるには、これだけコマンドオプションがあります。ほぼdefault（コマンドオプションなし）でもいいのですが、defaultが設定されていない--dataset、--dataroot、--cuda、--manualSeedについてはコマンドオプションが必要となります。ということから最低でも、

$ python main.py --dataset cifar10 --dataroot ./ --cuda --manualSeed 1

という感じでpython main.py以下に必要項目を追記してからRUNさせなければいけません。この部分が面倒で、すべてにdefault値を設けたコードに書き直したり、この一行をコピペできるようにコメントに書いておいたりしていましたが、platformio terminalやscriptだと比較的簡単にできました（まあ、ターミナルでそのまま打ち込んでもいいのですが）。

platformio terminalのコマンドオプション付き実行の場合：
まず、上記のようなコマンドオプション付きのコマンドをコメントに書いておきます。そして最初に設定しておいた「Select To Copy」機能によって、上記コマンド一行をマウスで選択した段階でコピーが済んでおり、あとはペーストするだけになります。さらにペーストをキーマッピングしておきます。

・platformio terminalのSettings画面で「Select To Copy」にチェックを入れておく
・platformio terminalのSettings画面の下のほうにある「Custom Texts」の「Custom test 1」に「python $F」を入力しておく


このSettings画面で設定した内容は、Edit>Config...>config.csonでも編集できます。以下のconfig.csonファイルで直接編集してもいいかもしれません。

ちなみにplatformio terminalの設定はいまのところこんな感じになっています。

・Edit>Keymap...でkeymap.csonを開きキーマップ割当をする
上記の内容をキーに割り当てることで、もう少し入力方法が簡単になります。

これはkeymap.cson内に書き込んであるキー割当のスクリプトです。こちらを参考にしました。
alt-zで選択したテキストを実行します。
alt-xでpython fileを実行します。
コマンドオプションがある場合（例：python main.py --cuda --niter 1）は、コマンドオプションを含めた一行をどこかに書いておいて、それを選択してalt-zで実行するという感じです。
コマンドオプションが不要な通常の方法（例：python main.py）の場合は、そのままalt-xで実行します。キーマッピングなので、都合の良いキーに割当られますが、意外と既にあるショートカットキーと重複することがあるので、試し打ちしてみて使っていないキーの組み合わせを探さないといけません。

実行中停止させるコマンド：
通常ターミナルでプログラム実行中に割り込む命令としては、
一時停止：ctrl-z
ジョブ名表示：jobs
再開：fg 1（ジョブ名）
終了：ctrl-c
となりますが、ctrl-cで終了させるために、kill -9 $$やskill --fullなどをキーマッピングしてみましたが上手く機能しません。もうすこしSIGNALやシェルの勉強が必要かもしれません。最悪、途中強制終了するにはplatformio terminalの画面を閉じてしまうかです。
もしかしたら、platformio terminalはエミュレータのターミナルなのでそこまでの処理ができないのかもしれません。この部分については調査中です。

atom-scriptの場合：
atom-scriptは様々な言語に対応しており人気のあるパッケージだと思います。いろいろ改良されており、jupyter notebookにも対応、一応コマンドオプション付きでRUNさせることもできます。ただ問題はそのままだと仮想環境には自動的に入ってくれないという部分です。Pythonなどの環境変数に対応させるために
atom .
と、ドットつきでターミナルからatomを起動しろと書いてあります。これが煩わしいので、専用のatom起動用アイコン（ランチャー）をつくり、ドット付きの起動を可能にしました。

atom仮想環境用起動アイコン（ランチャー）：
・「/usr/share/applications」の中の「Atom」アイコンを右クリックでコピー
・デスクトップなどにペーストし、右クリックでプロパティ画面を開く
・名前を「AtomPY35」などと変える
・コマンド欄に以下のような環境変数とドット（２箇所あり）を含めたシェルコマンド書く
＊シェルコマンドについてはまだ勉強不足で不確かな部分もあるのですが、一応以下でも動きました。sourceの代わりにドット（.）を使っていますが、もしかしたらexportなど使ったほうがいいのかもしれません。

bash -ic ". /home/mirrornerror/.pyenv/versions/anaconda3-5.0.1/bin/activate py35; atom .; exec bash"

・ターミナルで新アイコンが置いてあるDesktopへ移動

cd ./Desktop

・新アイコンを「/usr/share/applications」へコピー移動する

sudo cp AtomPY35.desktop /usr/share/applications

・一度「/usr/share/applications」内から「AtomPY35」をクリック起動し、ランチャーにアイコンが並んだらランチャーに登録しておく

画像の色も微妙に変えておくといいかもしれません。通常用のアイコンと仮想環境用のアイコンを複数つくっておけば状況に応じて使い分けも可能です。そうすれば煩わしい事前設定をせずにアイコンクリックで仮想環境でのatomが使えるようになります。

atom-scriptでのRUN方法：
Packages>Scriptの中には
Script: Run by Number （jupyter notebook用）
Run Script (python main.py/コマンドオプションなし)
Run with profile (python main.py --cuda --niter 1/コマンドオプション付き)
Stop Script
Configure Script（環境変数やコマンドオプションなどの設定）
Close Window and Stop Script
Copy Run Results

という感じでいろいろあります。
一度対象のプログラムにフォーカスを与えてから、「Configure Script」をクリックすると、

このような設定画面が現れるので、「Program Arguments:」にコマンドオプションとなる「--cuda --niter 1」を記入して右下の▶Runボタンを押せば実行できます。この場合、ターミナルは起動しなくても実行できるので比較的簡単な操作になると思います。この内容を「Save as profile」ボタンで保存しておけば、次回からボタン操作だけで実行可能となります。

一旦保存すれば、このプログラムの設定を含んだ「dcgan（名前は任意）」というボタンが生成され、Packages>Script>Run with Profile（Shift+Ctrl+Alt+B）から「dcgan」ボタンを押して▶Runボタンで実行できます。
Stop Script（Ctrl+Q）もあるので途中で終了も可能です。

platformio terminalとscriptの二つがあれば、ほぼ問題なく簡単に実行できると思います。というわけで、エディタと実行環境については思っていたようなことができるようになったので一安心です。