読者です 読者をやめる 読者になる 読者になる

TensorFlow、マシン性能でどのくらいの差が出るか

本格的に Deep Learning を行うのに、どの程度のスペックのパソコンが、何台必要なのでしょうか? ネット上にはいろいろな意見は載っているけど、それが自分に適応できるものか分かりません。自分がこれから組むネットワークは、それら先人のネットワークとは異なるからです。

スペックの異なるパソコンで簡単なチュートリアルを試し、かかった時間、使用された RAM の量*1について書いていくページです。

軽いネットワークから複雑なネットワークまで、(自分が知識のついたネットワークから)試してみたいと思います。

 

 

※マシンスペックは最下部に記載 

 

TensorFlow, tutorial, MNIST

http://pmonty.hatenablog.com/entry/2017/02/11/153820

隠れ層一層の、単純な NN

 

 RAM 使用量:ほぼ 0GB

 

    Panasonic laptop ('12):   2.55 sec (2.63, 2.48, 2.53)

                Ubuntu14.4 第三世代 core i5, 16GB, SATA3-SSD

    Lenovo laptop ('16):        1.31 sec (1.30, 1.31, 1.31)

                Win10 第六世代 core i7, 20GB, SATA3-SSD

    Laptop ('16):                    1.28 sec (1.36, 1.22, 1.26)

                Win7 第六世代 core i7, 4GB, m2-NVMe SSD 

   Ubuntu14 on VMware      1.99 sec (1.95, 2.01, 2.00)

                on Lenovo Win10

    BTO desktop ('17):          Coming soon !

 

ハイスペックほど速い、順当な結果。

第三世代 core i5 から第六世代 core i7 にかけて、クロック周波数とコア数は変わってなかったけれど、明らかな速度差が出ました。また、m2-NVMe SSD が一番速い結果。

Ubuntu 14 on VMware もそれほど遅くないですが、このネットワークでは。

 

 

 

TensorFlow, tutorial, MNIST, CNN

http://pmonty.hatenablog.com/entry/2017/02/13/103000

 

    RAM使用量:5.4GB

 

 

 

    Panasonic laptop ('12) with Ubuntu:    2272 sec (37min 52 sec)

        (2165,  2379,  2107, 2088 sec)

    Lenovo laptop ('16) with Win10:          2936 sec (48 min 56 sec)

        (2995, 3095, 2781, 2873 sec)

    Laptop ('16 RAM 4GB):                      走らず!

    Ubuntu14 on VMware                         5 hr  (186.2, 177.8 sec x100)

        on Lenovo Win10, 1/100 session のみ行い100倍。超遅い!

    BTO desktop ('17) with Ubuntu:     Coming soon !

 

メモリ(RAM)が足りないとクラッシュすることを確認。また、新しい Lenovo laptop が、古い Pana に負けるという衝撃の結果。

Panasonic連続2回走らせると、2回目に 10% 程度遅くなり、排気がものすごく熱くなります。冷却が間に合わず、クロックに上限かかってそうな経過です。

3回目の途中から、排気がスムーズになるよう、排気口を少し持ち上げ、テーブルの端に設置。排気の温度は下がり、速くなりました。

再現性を見るため、同条件で4回目を再検。最初から排気が良い状況ですと、さらに速くなりました。

 

Lenovo laptop (2016) は当初、3面ディスプレイ環境。Jupyter Notebook:  2995 sec、2回目、コマンドプロンプト、3005sec,)。Web 見たりもしてました。

3回目からは外部ディスプレイを切断、ほぼ無操作で計測。約 2800 秒、これが実力に近いのでしょうか。それにしたって Pana よりも遅すぎます。

 

そして Ubuntu14 on VMware はむちゃくちゃ遅い。少し複雑なネットワークになると圧倒的に遅くなってしまいますね。

速く、 GPGPU を試してみたい。。。

 

 

 

RAM と Windows, どちらのせいで遅いのか

先ほどの結果、最新の Lenovo は遅く、古い Pana の PC の方が速い。こりゃおかしいわけです。

さしあたって考えられる原因は2つ

  1.RAM dual channel

  2.Windows

Lenovo は 4 + 16 GB ですが、Pana は 8 + 8 GB できちんとデュアルチャンネルにしています。Lenovo の方がシングルチャンネル。この影響で、遅いのかもしれません。

 

また、Windows の影響かもしれません。Windows では様々なプロセスが動いているはずで、それで遅い可能性もあります。

とりあえず、検証してみます。

 

    Lenovo laptop ('16) with Ubuntu:      1917 sec (32min 22 sec)

                1893, 1870, 1980 sec

    Pana ('12) with Ubuntu:                    2272 sec (37min 52 sec) (再掲)

    Panasonic laptop ('12) with Win7:     2824 sec (48min 13sec)

                 2714, 3072, 2687 sec

    Lenovo ('16) with Win10:                   2936 sec (48 min 56 sec) (再掲)

 

やはりというべきか・・・

Deep Learning やるなら Linux、みたいなことが書いてあったりしますが、なぜ先人がそのように言うのか確認できました。

 

最新の Windows ほど遅いという結果が得られました(Win10 の名誉のために言うと、3面ディスプレイ環境もあっての2936秒です。おそらく 2800sec、Win7 同等のスピードだと思います。といっても、圧倒的にスペックで勝るのに Win7 と同等とは褒められたものではありません)

 

同一 OS での速度差を考えてみます。

Ubuntu 14 を使えば、Pana より Lenovo の方が速い結果。Pana は中古で買えば 5万円くらいかな、というスペック。Lenovo のは新品で、パーツ交換含め、20万程度だろうと。ディープラーニングのハード整備で言えば、中古の方が圧倒的にコスパ良さそうですね。

 

 

 

検討マシン

Panasonic laptop (2012)

    core i5-3320M  @ 2.60 GHz, 2 core, 4 core with hyperthreding (HT)

    RAM 16GB  DDR3L-1600 (8+8GB)

    SSD (SATA3)

    Ubuntu 14.4LTS日本語Remix, Anaconda 4.2.0, Python 3.5, TF 1.0.1

  ※ Win7/Ubuntu14 デュアルブート

 

Lenovo laptop (2016)

    core i7 6600U  @ 2.60 GHz 2 core, 4 core with HT

    RAM 20GB, DDR3L-1600 (4 + 16GB)

    SSD (SATA3)

    Windows 10, Anaconda 4.2.0, Python 3.5, TF 1.0.1

        ※ Win10/Ubuntu14 デュアルブート

 

BTO desktop (2017) coming soon!!

    core i5-7600K  @ 3.80 GHz, 4  core, no HT

    RAM 40 GB, DDR4-2400

    SSD m2-NVMe

    GeForce GTX 1080Ti

    Ubuntu 14.4, Anaconda, Python 3.5, TF1.0.1, CUDA 8.1, CuDNN 5.1

*1:タスクマネージャ等の目視で、最大使用量-ベース使用量

ついに Deep Learning 用パソコンをオーダーしました。

表題通り。

 

基本スペック

 OS なし(Ubuntu14LTS or CentOS 7 予定)

 Core i5-7600K

 RAM 8GB (32GB追加予定)

 HDD 3TB (SSD 追加予定)

 GeForce GTX 1080Ti

 Chipset Z270 (2 way-SLI可能、RAM max 64GB)

 Cosair Carbite 300R

 

以上で約20万円。

さんざん悩んだのが

 

CPU, RAM, GPU

 

CPU/RAM は、

 Xeon (RAM 最大 1T 以上)

 i7-6800K (RAM 最大 128GB, 6 cores 12 threads)

 i7-7700K (RAM 最大 64GB, 4 cores 8 threads)

 i5-7600K (RAM 最大 64GB, 4 cores 4 threads) 

 

GPU は、

 1080 (空冷 or 水冷)

 1080 SLI (空冷 or 水冷)

 1080ti

 

選択肢がありすぎる(選択肢がありあまる)。

ただ、GTX 10系では、値段と速さ、値段と RAM 量が相関するので、悩んだら高いのを買っておけば良い。マザボにさせるグラボの数は決まっているので、高いのを選んでおかないと、速く上限に達してしまう。

(1070-1080間を除く。1070-1080間は、値段と速さは比例してるけど、RAM 重視なら 1070 の方がコスパ良さそう)

 

 

悩んだ原因になったのが

gihyo.jp

 

お勧め構成として、

 「RAM 128 GB 程度を推奨」

とある。

 

これを読む前は、

Lenovo Ideacentre Y710 cube 

kakaku.com

みたいな、コンパクトデスクトップを買おうと思ってたんですけど・・・

この本読んで早々に除外。なぜなら、RAMmax は 32GB。

 

しかし、本お勧めの通り、RAM 128 GB で買おうとすると、

 CPU Core i7-6800K 以上 (5万円以上)

になるので、必然的に高くなります。

マザーボードも高いし。

 

d.hatena.ne.jp

しかし、注文してから気づきましたが、同著者の過去のブログには

 SSD 480GB

 RAM 32GB

 GPU 980ti

位で良いと書いていますね。

980ti って、今で言えば 1080 相当程度でしょう。1080 は 980ti からメモリが増えてて、NN 設計の自由度も上がってます。

 

こっちを参考に、1080 で良かったかも。

 

いずれにせよ、core i5-7600K, RAM max 64GB にしました。7600K と 7700K で悩みましたが、一万円以上の差があり、core i5 に。

冷却はシンプルに空冷のみ。その代わり、ケースファン(14cm)を多めに装着。

 

水冷は、

 トラブル面倒。

 重い(水冷1個で 1kg 。重いのは嫌い)

なので却下。

 

CPU クーラーもこだわらず、Intel 純正。

 

数日連続で GPU を走らせる状況では、冷却水も熱くなり、クロックに制限がかかりそう。水冷のメリットは少ないと判断。 

 

基本的リモートで使う予定なので、水冷で静音化必要なし。

 

BTOで選べるパソコンケース、ゲーミングPC だけあって、

側面透明なタイプが多かったですが、

kakaku.com

(こんな感じの)

 

かっこいいですが、GPU 空冷効率も考えて、側面は透明ではないパネルで、開口があるタイプ、14cm大口径ファン対応を選びました。

jisakutech.com

 

側面透明タイプは、アクリル部分の強度を保つためか重い傾向があり(10kg程度。自分が選んだ、側面不透明タイプは7kg台)ました。また、透明モデルは側面開口なしがほとんど。空冷に不安あり。

 

速く遊んでみたいです。

突然のトラブル

日記

ThinkpadUbuntu 14.04.5 にトラブルが起こり、急ぎ検証しました。

 

しばらくタッチパッドをオフにして、トラックポインタのみにしていました。あるときトラックポインタとボタンが効かなくなり、電源ボタンにてシャットダウンを余儀なくされました。

 

また、日本語入力の切り替え(日本語入力←→直接入力)ができなくなりました(Mozc + iBus)。

 

・・・

日本語入力に関しては、Mozc + fcitx が一般に勧められているようで、そちらへの移行を試しましたが、どうにもうまくいきません。

 

日本語入力の切り替えができないのは、terminal、chromeでした。

gedit では切り替え可能でしたので、アプリの種類も関連しているようです。

Terminalはネット記事を参考に解決しましたが、肝心の Chrome のが解決できませんでした。

 

クリーンインストールになれた Win user としては、クリーンインストールしたくなります。

・・・

 

日本語入力のトラブルは、日本語Remixをインストールすれば防げます(プリインストールされていますので)。

日本語 Remix ブータブルディスクを使って起動してみます。すると、問題がありました。

 

 16.04 LTS 日本語リミックス : 画像解析ソフトインストールに必要な、一部パッケージがインストールできない。解析ソフトというのは AFNI ですが、

  libmotif4, libXp6

 というパッケージが、 sudo apt-get install にてインストールできません。

 libmotif4 は、ネットに落ちているのを拾うことができましたが、libXp6 は見つかりませんでした。AFNI を入れない、という割り切りもありですが、大変高機能なので一応入れておきたいわけです。

 

 14.04 LTS 日本語リミックス:LAN を認識しない。

 古い PC, Ivybridge を積んだ laptop にインストールすると、問題なく LAN を認識してくれますので、ドライバ周りのトラブルかと思いました。自分でドライバを見つけられれば解決する問題ですが、大変そうなのでチャレンジしませんでした。

 また、トラックポインタとクリックボタンが作動しないという致命的問題もありました。

 AFNI は問題なくインストールできました。

 

 

・・・

解決策は

 Ubuntu 14.04.5(英語版) を使うこと

です。

 

 これは、当初 2014 年に出た Ubuntu 14.04 をアップデートしたもので、 2016 年に発表されました。

 AFNI の問題と LAN の問題は解決します。

 なお、この OS を入れていた現在のパソコンでトラックポインタが効かなくなったので、その点は心配です。また、日本語入力で再びトラブルが起きる可能性があります。

 

Ubuntu14.04 のセットアップで参考にしているページがあるのですが、

Ubuntu 14.04 LTSをインストールした直後に行う設定 & インストールするソフト

 

この中での 日本語入力の fcitx-Mozc の設定はやっていませんでした(iBus-Mozc使用)。

この設定をきちんとやれば、問題は起こらない、かもしれません。

 

d.hatena.ne.jp

d.hatena.ne.jp

 

Ubuntu のリカバリの記事はいくつか見つかりましたが。

まだ入れて日が経ってないし、今回はブータブルUSBからクリーンインストールしようかと。

 

・・・

2016/3/14追記

 

Ubuntu 14.04.5 を再インストールしまして、上記の問題は解決しました。

ただし、今後、長期に使って行くには、よりサポート期間の長い CentOS7 に移行した方がいいのかな、と 最近は思っております*1

 

*1: Ubuntu のサポート期間は 2年または 5年:長期サポートを約束している14 LTS, 16 LTS は5年、そのほかは 2年。私の使っている Ubuntu 14 は 2019 年まで。CentOS のサポート期間は 10年。現行の CentOS 7 は 2024 年まで!

Ubuntu 14.04 dual boot 初期設定

UNIX/Linux/Bash 日記

 

ThinkpadUbuntu 14 を入れて dual boot としました。

軽い OS で使いやすいですね。

 

Windows 側のパーティションは簡単にマウントできるため、Win10 のファイルも扱うことができます。逆に Windows 側からは Ubuntu 側が見えません。

このため、今後は Ubuntu がメイン OS になりそうです。

 

さておき、やったことを、リカバリー時のため、備忘録として残しておきます。

 

 

1.  パーティションを切る*1

 

2.  Ubuntu 14.04.5 をインストール*2

 

3.  バッテリー管理ツールのインストール*3

 

4.  インストール後、まずやること*4

 

5.  Chrome のインストール*5

 

6.  LINE のインストール*6

 

7.  AFNI のインストール*7

 

8.  freesurfer のインストール*8

 

9.  FSL のインストール*9

 

10.  exFAT を認識できるようにする*10

 

11.  Anaconda のインストール*11

 

12.  RStudio のインストール*12

 

13.  TensorFlow のインストール*13

 

14.  ウィンドウズの復元ドライブを 1GB → 11GB に拡大*14

 

15.  ファイアーウォールを設定する(gufw)

 

16.  アンチウイルスをインストールする (ClamTK)*15

 

17.  ターミナルのプロンプトの色変更。*16

 

18.  ブータブルディスク作成(USB)

 

19.  Mozc を default の IME に設定。IME の ON/OFF を、「Ctrl + `」に割り当て

 

現状を確認しておく。

 

SSD使用 35GB, 空き 56GB

 

$ free -h

RAM は total 19G, used 6.3G

Swap は total 29G, used 0B

 Swap こんなにいらないのかな?

 ハイバーネート、しなそうですし。 

 今後の課題です。

 

 

$ sudo parted -l

モデル: ATA Crucial_CT2050MX (scsi)
ディスク /dev/sda: 2050GB
セクタサイズ (論理/物理): 512B/512B
パーティションテーブル: gpt

番号 開始 終了 サイズ ファイルシステム 名前 フラグ
1 17.4kB 134MB 134MB msftres                       # ブートローダ
2 135MB 408MB 273MB fat32 boot                   # Windows ブート領域?
3 408MB 1910GB 1909GB ntfs msftdata          # Windows 10
5 1910GB 1910GB 256MB ext4                        # Ubuntu 14.04.5 ブート領域
7 1910GB 2007GB 97.4GB ext4                       # Ubuntu 14.04.5 データ領域?
6 2007GB 2039GB 31.2GB linux-swap(v1)       # Lnux Swap 領域
4 2039GB 2050GB 11.8GB ntfs msftdata          # WinRE DRV

 

SSD 2TB はたまらんです。

データにずいぶん余裕があります。

でもやっぱり高いので、次の買い替えでは 1TB に断捨離したいです。。。

 

*1:Windows 管理ツールにて。Ubuntu 用に 100GB, Swap に 30 GB 、合計 130GB を「未割り当て領域」として確保

デュアルブートと言っても、こんな複雑なことはしないで| ライフハッカー[日本版]  データは Windows 領域に保存する方針です

*2:最初 BIOS に入れなくて焦る。画面には「スタートアップを妨げるには press enter」  と出るのだけれど、本当は「F1」!!。

途中でインストールが何度か止まって焦った。コマンドラインで「Enter」を押したり、「Skip」をクリックしたりしたけど、良かったのか分からない。

*3:ThinkPadのバッテリーの充電・放電閾値をLinuxから設定tpacpi-bat と言うソフトを使い、バッテリー充電開始と充電終了を管理できる。

ブログによっては tp-smapi というソフトを押しているが、最近の thinkpad では tp-smapi は使えないtp_smapi - ArchWiki

なお、どちらも "tp" が示すとおり、thinkpad 専用ユーティリティ。他社では使えるか不明

*4:Ubuntu 14.04 LTSをインストールした直後に行う設定 ブログを参考に、気になるものだけ適当に設定。日本語入力は第297回 Ubuntu 13.10でインプットメソッドFcitxを活用する:Ubuntu Weekly Recipe|gihyo.jp … 技術評論社を愚直に実行する

*5:Ubuntu 14 と 16 とで方法が違い、これに失敗するとその後のインストールに差し障りが出るので本当はやりたくなかった。が、その後の setup に必要なので、仕方なく

Ubuntu 14Ubuntu16

*6:Chrome 用の拡張機能Ubuntu:LINEを使う方法。Webベースで動く。これも後にしたかったが必要だったので。

Wineを使ってデスクトップアプリ版の LINE もインストールできるらしい。【Ubuntu14.04】LINEインストール

*7:HP 記載通りで簡単に終了1.1.2. The essential system setup for: Ubuntu Linux — AFNI

*8:HP 記載通りで簡単に終了Ubuntu 14.04 へのFreeSurferのインストール

*9:こちらHow to install FSL on Ubuntuでは一部パッケージがインストールできず、英語だけどこちらからInstall a package — Debian Neuroscience Package Repositoryのほうが良い。と言ってもコピペするだけなので楽。

*10:外部 HDD, SDXC 認識のためUbuntu 14.04 でexFATをマウントする

*11:最新版 4.3.0 (Python 3.6) は起動しなかった。Python 3.5 版の Anaconda3-4.2.0-Linux-x86_64.sh インストール にて無事 起動

*12:ダウンロード、ダブルクリックで簡単にインストール完了Download RStudio – RStudio

*13:

conda create -n TF

source activate TF

pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.0.0-cp35-cp35m-linux_x86_64.wh

*14:こんな恐ろしいブログ記事を見つけた。Win10 のアップグレードの際に回復パーティションの容量が足りないと、アプデ時に新たなパーティションを作るということ。これによって Ubuntu をブートするパーティションの位置が変わってしまい、ブートローダーの情報と合わなくなることで Ubuntu が起動しなくなるということ。

元々 1GB だった Windows の 回復パーティション(WinRE DRV)を、Ubuntu 14 ライブ CD の GParted を使い、10GB まで広げておきました。現在使用料が 300MB くらいなので、Ubuntut 14 のサポートが切れる 2019 Apr までは問題なく保ってくれるはず

*15:スタートアップを試したが、結局手動で使うことにした。

自動で起動・ウイルスデータアップデートするが、scan は時刻固定か手動。起動時 Window 最小化もできず(ソフト: devilspie, gdevilspie を試す。python2 らしく、今の python 3 環境では動かない。アンインストール。今から思えば

$ conda create -n py2 python=2.7

$ source activate py2

で仮想環境を作って、動くか試してみれば良かった。

*16:

~/ にある .bashrc に一行追加する。

PS1="\e[1;32m\u@\h$\e[0m "    # light green は acceptable.

PS1="\e[1;33m\u@\h$\e[0m "    # light yellow はかぶらないしこれにしようか。

PS1="\e[1;34m\u@\h$\e[0m "    # light blue は ディレクトリと色がかぶる

PS1="\e[1;36m\u@\h$\e[0m "    # 結局 light cyan は ln -s と色がかぶる。

 上記の 1:36m とかの "1:" の部分を削除すると、濃い色になるみたい。良く分かってないので嘘かも。

結局

# to change color of the prompt on terminal

PS1="\e[1;36m\u@\h \e[1;24m\w \e[0m$ "

とした (名前がシアン、ディレクトリがブルー。プロンプトは白)。

編集には、

nano ~/.bashrc

sudo gedit ~/.bashrc

などを使用。

TensorFlow "高度な" MNISTチュートリアル2

DNN

前半はこちら。

pmonty.hatenablog.com

※前半(上記リンク先)のコードが入力されていないと、以下のコードは実行できません。ご注意ください。

※最下部に、対話型環境で実行可能なコードをまとめています。コピペにて走ります。 

 

 

原文はこちら

Deep MNIST for Experts  |  TensorFlow

 

TensorFlowの学習のため、チュートリアルの翻訳を行いました。

誤っている点があれば教えてください。

 

 

ディープニューラルネットワークの作成 *1 

 

重みの初期化

 

多層のニューラルネットワークを実装します。それぞれの層が重み W と バイアス b を持っています。

0勾配を予防するために(to prevent 0 gradient)、少量のノイズで重みを初期化する必要があります*2

今回、活性化関数に ReLU*3を使っているので、小さな正の値で初期化するのが有効とのこと。

 

ニューラルネットの構築に便利な2つの関数を作成。

 

def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

 

def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

 

 

畳み込みとプーリング

 

TensorFlow では、関数を用いて柔軟に畳み込み(convolution)とプーリング(pooling)を行うことができます。 今回は、非常にシンプルな方法(vanilla version バニラ (ソフトウェア) - Wikipedia )を使っているとのことです。

ストライドは 1 で、 0 をパディングを行います (zero padded) *4。アウトプットはインプットと同じサイズです。

プーリングも、昔ながらの(plain old) 2x2 マックスプーリングです。

 

関数として定義します。

 

def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

 

def max_pool_2x2(x):

    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

 

 

第一の畳み込み層(First Convolutional Layer)

 

第一層を実装します。畳み込み層とマックスプーリング層からなります。

畳み込みでは 5x5 の大きさのパッチを使い、32 の 特徴マップ(feature map)を計算します。

テンソルの形は、 [5, 5, 1, 32] となります。最初の二つの次元がパッチサイズ、次に入力するチャンネル数、最後に出力のチャンネル数です。

 

同様に、バイアスも作成します。

 

W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

 

レイヤー(畳み込み+プーリング)を適用するために、MNIST の画像を変形します。幅と高さに対応する 2,3 番目の次元、カラーチャネルの数に対応する最後の次元を設定し、4次元のテンソルに変形します。

 

x_image = tf.reshape(x, [-1,28,28,1])

 

x_image に対して 重みテンソル(W_conv1)で畳み込み、バイアス(b_conv1)を加え、活性化関数(ReLU)を適用。

マックスプーリングを行います。

 

画像の画素数は 14x14 に縮小されます。

 

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

h_pool1 = max_pool_2x2(h_conv1)

 

 

第2の畳み込み層

 

この層でも、5x5 のサイズのパッチを使ます。

前の層で計算した32 の特徴マップを使い、64 の特徴マップを計算します。

 

W_conv2 = weight_variable([5, 5, 32, 64])

b_conv2 = bias_variable([64])

 

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

h_pool2 = max_pool_2x2(h_conv2)

 

 

高密度接続層(Densely Connected Layer)

 

7×7に縮小された画像から、画像全体を処理できる、1024個のニューロンを備えた完全連結レイヤーを追加します。

プール層のテンソルを、ベクトルのバッチに再構成し、活性化関数に ReLU を適用します。

 

W_fc1 = weight_variable([7 * 7 * 64, 1024])

b_fc1 = bias_variable([1024])

 

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])

h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

 

 

ドロップアウト(Dropout)

 

過学習(overfit)を防ぐために、ドロップアウトを使います*5

ドロップアウトを適用する時、ニューロンからのアウトプットが保たれる確率を新たに設定した placeholder に保持します。これにより、学習中にはドロップアウトをオンに、テスト中にはオフにすることができます。

TensorFlow  の tf.nn.dropout 関数は、マスキングに加えてニューロンのスケーリングを自動的に処理するため、ドロップアウトは追加のスケーリングを行わずに動作します*6

 

keep_prob = tf.placeholder(tf.float32)

h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

 

 

読み出し層(readout layer)

 

W_fc2 = weight_variable([1024, 10])

b_fc2 = bias_variable([10])

 

y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

 

 

モデルのトレーニングと評価

 

モデルをトレーニングして評価するために、上記の単純な一層の Softmax ネットワークとほぼ同じコードを使います。

 

違いは

 Optimizer として、SGD の代わりに、より洗練された Adam を使います。

 ドロップアウトを制御するするパラメータ、Keep_prob を feed_dict 内に設定します。

 100回のトレーニング毎にログを表示します。

 

次のコードを実行してみてください。ただし、20000 回のトレーニングを行うと、(コンピュータによりますが)恐らく最大で30分程度の時間がかかります*7

 

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_conv, y_))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
sess.run(tf.global_variables_initializer())
for i in range(20000):
    batch = mnist.train.next_batch(50)
    if i%100 == 0:
        train_accuracy = accuracy.eval(feed_dict={
            x:batch[0], y_: batch[1], keep_prob: 1.0})
        print("step %d, training accuracy %g"%(i, train_accuracy))
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

 

このコードを実行した後、精度は最終的に約 99.2% となります。

 

 

 

*******************************************************

コードのまとめ

import tensorflow as tf

 

from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

 

## 時間経過の測定
import time

start = time.time()

time.ctime(start) 

 

def weight_variable(shape):

    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

 


def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

 


def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

 


def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

 


x = tf.placeholder(tf.float32, shape=[None, 784])
x_image = tf.reshape(x, [-1,28,28,1])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
y = tf.matmul(x,W) + b

W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
for i in range(20000):
    batch = mnist.train.next_batch(50)
    if i%100 == 0:
        train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})

        print("step %d, training accuracy %g"%(i, train_accuracy))
        train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
        print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

 


## 時間経過の表示

print("start time = " + (time.ctime(start)))
print("fin time = " + (time.ctime(time.time())))
elapsed_time = time.time() - start
print ("elapsed_time:{0} sec".format(elapsed_time))

 

 

 

 

 

*1:Build a Multilayer Convolutional Network

*2:初期値が 0 など偏った値だと、学習が上手く進みにくいらしい

*3:Rectified Linear Unit: ゼロ以下は0を返し、0を超える数値はそのままの値を返す。ニューラルネットワークの層が深くなっても学習がうまくいきやすい。以前使われていた "Sigmoid" 関数では、層が深くなると学習が上手くいかなくなる問題があった

*4:ストライド・パディングについては別途ご確認ください。たとえばこの本に、大変詳しく書いてあります

*5:ドロップアウトについては別途ご確認ください。たとえばこの本に、詳しく書いてあります

*6:すみません、直訳です。私は意味が分かりませんでした。原文:TensorFlow's tf.nn.dropout op automatically handles scaling neuron outputs in addition to masking them, so dropout just works without any additional scaling.

なお、更にコメントとして「この小さな畳み込みネットワークでは、精度はドロップアウトの有無にかかわらず同程度です。ドロップアウトは非常に大きなネットワークを訓練する場合に有用です。と記載されていました

*7:私のノートパソコンでは、1時間15分程度かかりました。CPU: 6 Gen Core i7, 20GB RAM, SSD, accuracy は 0.9916 でした

TensorFlow "高度な" MNISTチュートリアル1

DNN

原文:Deep MNIST for Experts  |  TensorFlow

 

ディープラーニング・ディープニューラルネットワークの勉強のために、MNIST のチュートリアルの日本語訳(意訳・直訳のちゃんぽん+自分のコメントも時々まじる)を作成。今回前半部分のみ。

 

初心者なので誤りがあるかもしれません。

気づかれたら教えてください。

当方 Windows 10 + Python 3.5 (Anaconda) という環境です。

クリエイティブ・コモンズなので、著作権的に大丈夫と思いますが、問題あれば教えてください) 

 

コード全体は、最下段にまとめています。

対話型環境へのコピペだけで、走るようにしてあります。

 

 

MNISTデータを読み込みましょう。

 

まず、TensorFlow をインストールしていること、"簡単な" MNIST チュートリアルを終えているなど、Deep Learning の理解が必要と始める前に念押しされます。

 

まず、MNISTのデータをダウンロードします。

 

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

 

 

インターアクティブセッションを初めましょう

 

通常は グラフを作ってからセッションを始めるのだが、今回はもっと便利で柔軟な、インターアクティブセッションという方法でやってみるとのこと。この方法では、計算グラフ(computation graph)を作るのと、グラフを走らせる(launch graph)ことを交互に行えると。これを使わないなら、"launch graph" の前に、計算グラフを完成させないといけないそうです。

IPython (現 Jupyter Notebook?)で使う時に便利なんだそうです。

 

 

セッション(Session)というのは、C++で実装されたバックエンドとの連絡(connection)のこと(原文:*1)。

どうやら「セッション」のなかで作業が行われるようです*2

 

import tensorflow as tf
sess = tf.InteractiveSession()

 

 

計算グラフ (Computation Graph)

 

Python を使って計算をする時、NumPy のようなライブラリを使うわけですが、処理をしてから Python に戻ってくる(switching back)時に大きな負荷(a lot of overhead)がかかると。特に GPU に分散させて (distributed manner) 処理する時に負荷が大きいそう。

TensorFlow ではこの負荷を避けるために、処理の表(graph)を作るのだと(Theano や Torch など、他の DNN*3  ライブラリと同様とのこと)。

Python コードの役割は、外部で行う作業の表(external computation graph)を作成し、その表のどの部分を実行するかを指示すること。詳しくは、Basic Usage の Computation Graph Computation Graph  |  Basic Usage  |  TensorFlow を参照のこと。

 

 

Softmax 回帰モデル

 

このセクションで、一層の線形の層を持った(with a single linear layer) Softmax 回帰モデルを作成し、次のセクションでこれを、convolutionan deep neural network に拡張するとのことです(原文:multilayer convolutional network)。わくわくしますね!

 

 

Placeholders について*4

 

まず、画像データやアウトプットを挿入するためのノードを作成。

 

x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])

 

ここで、"x" と "y_" は特定の値ではなく、placeholder であり、あとで数字を代入して使うことができます。

 

解析する画像を表す "x" は浮動小数点を含んだ二次元のテンソルで、784 という数字は、MNIST 画像が 28 x 28 ピクセルで作成されていることから来ています。

 

最初に代入した None はバッチサイズで、None にすることで、後からどんな数字でも挿入することができます。

 

アウトプットを示す "y_" もまた二次元のテンソル。各々の列(row)は one-hot 表現*5 の十次元のベクトル。0-9 の、どれかの数字を表す。*6

 

tf.placeholder 関数で [shape] はオプションなので書かなくても良いが、指定することでバグを回避することができる。

 

 

変数(Variables)

 

重み W とバイアス b を設定します(原文を読むと、他のやり方もありそうですが、今回はこの方法を使う、というニュアンスを受けます)。

 

W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))

 

W と b の初期値にゼロを入れ、初期化します。
セッションで Variable を使う前に、初期化する必要があります。初期化作業では、最初の値を設定します(今回はゼロ)。

 

なお、次のコードを実行すると、全ての Variable を一度に初期化することができます。

 

sess.run(tf.global_variables_initializer())

 

 

クラスの予測と損失関数

 

では、回帰モデル(regression model)を設定しましょう。たった一行で設定できます。ベクトルの情報 x と 重み W を掛け合わせ、バイアス b を加えます。

 

y = tf.matmul(x,W) + b

 

# tf.matmul はベクトル内積の計算です*7

 

損失関数は簡単に設定できます。

損失関数は、モデルの予測がいかに悪いかを表すもので、この値を小さくすることを目標に学習を行います。

今回、損失関数として交差エントロピー誤差*8 を利用し、活性化関数(activation function)として Softmax 関数*9 を利用します。

 

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))

 

 計算結果に対して、 "tf.nn.softmax_cross_entropy_with_logits" の部分でソフトマックスの計算と各々の予測の結果を加算し、tf.reduce_mean の部分でその平均を取ります。

 

 

モデルの学習 (Train the Model)

 

以上でモデルと学習方法を定義しました。この例では、 TensorFlow の自動微分を使用して損失の勾配を検出し、steepest gradient descent アルゴリズムを使い、ステップ長さ 0.5 で学習していきます。


TensorFlow には、他にも多数の最適化アルゴリズムがビルトイン*10されています。

 

train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

 

この一行で、新しい処理を計算グラフに追加します。この処理には、こで勾配を計算し、パラメータ更新ステップを計算し、パラメータを更新する操作が含まれています。

上記の train_step を実行すると、勾配降下法を用いてパラメータを更新します。これを繰り返すことでモデルを訓練(training)することができます。

 

for i in range(1000):
    batch = mnist.train.next_batch(100)
    train_step.run(feed_dict={x: batch[0], y_: batch[1]})

 

 

100例からなるサンプルを使って、繰り返し学習します。次にトレーニング例(training example)を使って feed_dict で placeholder テンソルである x と y_ を置き換えて train_step を実行します(分かりにくくてすみません。まず100例でトレーニングを行い、次にその次の100例を使ってトレーニングする、という作業を繰り返す ようです)。

なお、feed_dict を使えば計算グラフにあるどんなテンソルでも置き換えることができます。Placeholder だけではありません。

 

 

モデルの評価

 

最初にどれだけ正しく判断できたか確認します。
tf.argmax はとても便利な関数で、複数の軸を持つテンソルの中で、最も高い数字が入力されたラベルを示すことができます。例えば、tf.argmax(y,1) は最も可能性が高いラベルを返し、tf.argmax(y_,1)は回答を示します。tf.equalを使って、回答が合っていたを確認します。

 

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

 

この計算式は、ブール値(booleans)を返します。
どの程度正確だったのかを示すため、結果を浮動小数点数で表し、その平均を計算します。例えば、[True, False, True, True] は [1, 0, 1, 1] として表すことができ、0.75 となります。

 

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


最終的に、精度(accuracy)を計算します。今回の方法では 92% 程度でしょう。

 

print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

 

------------------------------------------------------------------- 

 

 コードのまとめ

上記コードをまとめたもの、さらに、経過時間を計測できるようにしています。

python の interactive session にコピペするだけで動きます。

 

 # コードのまとめ、時間計測付き

 

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

 

## 時間経過の測定

import time

start = time.time()
time.ctimes(start)

 

sess = tf.InteractiveSession()

 

x = tf.placeholder(tf.float32, shape=[None, 784])

y_ = tf.placeholder(tf.float32, shape=[None, 10])

 

W = tf.Variable(tf.zeros([784,10]))

b = tf.Variable(tf.zeros([10]))

 

sess.run(tf.global_variables_initializer())

y = tf.matmul(x,W) + b

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))

 

train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

 

for i in range(1000):

    batch = mnist.train.next_batch(100)

    train_step.run(feed_dict={x: batch[0], y_: batch[1]})

 


correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

 

 

## 時間経過の表示

print("start time = " + (time.ctime(start)))
print("fin time = " + (time.ctime(time.time())))
elapsed_time = time.time() - start
print ("elapsed_time:{0} sec".format(elapsed_time))

 

 

 

 

続いて

pmonty.hatenablog.com

多層のCNN作成へと続きます。

 

 

------------------------------------------------------------------- 

今回は前半部分のみで以上です。

ここまで、隠れ層なしのネットワークである "簡単な" MNIST チュートリアル

 MNIST For ML Beginners  |  TensorFlow の詳しい解説になっていました。

これだけでも 92% の精度が出るのはすごいと思いますが、次回はいよいよ Deep Neural Network を作成し、より高い診断能を目指すものと思います。

*1:TensorFlow relies on a highly efficient C++ backend to do its computation. The connection to this backend is called a session.

*2:The common usage for TensorFlow programs is to first create a graph and then launch it in a session.

*3:Deep Neural Network

*4:プレースホルダー。代理人・代用語。後で文字や数字を代入する場所を示す。

*5:一つのデータだけが True で、他のデータは False を示す表現法 

*6:

 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0] が 0

 [0, 0, 0, 1, 0, 0, 0, 0, 0, 0] が 3

 [0, 0, 0, 0, 0, 0, 0, 1, 0, 0] が 7

 といった表記法

*7:https://www.tensorflow.org/api_docs/python/math_ops/matrix_math_functions#matmul

*8:結果の自然対数計算し、それを加算したもの

*9:結果の和が 1 になるように正規化を行う

*10:Training  |  TensorFlow

Udemy の講義「【世界で2万人が受講】実践 Python データサイエンス」 について

Python 機械学習 統計/解析

ブコメで質問受けて、長くなるのでエントリーにしました。

Udemy の講義「【世界で2万人が受講】実践 Python データサイエンス 」

https://www.udemy.com/python-jp/learn/v4/overview

について

 

 

Python 3 を Anaconda ディストリビューションでインストールして、Jupyter Note book でデータサイエンスの基本を学ぶ、という講義です。

講演の仕方は、良く練られていると思います。下の方に、他に受けた Udemy 講義 一言感想を書きましたが、そちらと比べても良かったです。どこが・・・って言われると難しいですが。

 

17 時間と長いですが、扱っている範囲が広いので、内容はそこまで深くはないと思います。

ブコメ追記したように、根気があるならオライリーの、IPythonデータサイエンスクックブックを写経したほうが、知識はつきそうです。

 

この講義が向いている人は、
Python(含め、その他のプログラミング言語) を全く触ったことがなくて、どうもPython って科学技術計算で良いみたいなのでかじってみたい」
という方だと思います。

 

また、この講義だけでは情報量は浅いので、Python 本買うことになると思います。

 

もし R言語とかで、CUIでデータサイエンスの経験がおありなら、本で勉強したほうが良いかもしれません。

 

私が見た範囲で最安値は1000円でした。11月下旬? だったかな? のブラックフライデーセールです。

今おいくらで売られてるか分かりませんが(ログアウトしないと確認できなくて)、多分年に何回かセールしてるので、とりあえず Udemy に登録だけしといて、セールのメールが来るのを待つのも一案です。

 

 

他の Udemy の講義の一言感想

 

プログラミング言語 Python 3 入門」

https://www.udemy.com/intro-to-python3/learn/v4/content

悪くなかった。

ただ、ほんとに「勉強」って言う感じなので、やや退屈な感じ。

キーボードのカタカタ言う音がやたら良い。聞いてて気持ちいい。

 

 

「【R言語をゼロから理解していく】データサイエンスの実践」

https://www.udemy.com/r-datascience/learn/v4/overview

R言語を全く触ったことない人なら、多少学ぶことがある。

でも情報が浅すぎる。

この知識だけで論文書いたら、統計解析で Reviewer に突っ返されそう。

t検定だけでも、Student と Welch は抑えとかないと、困るじゃないですか。

Mann-Whitney U もないし、3群以上の統計解析もない。

95% 信頼区間の計算方法とか生存分析とかも欲しかった。

 

 

Python機械学習:scikit-learnで学ぶ識別入門」

https://www.udemy.com/python-scikit-learn/learn/v4/content

講演者がわざわざ視界に入ってきて気が散る。

講師は爽やか系男性だけど、ヘッドセットマイクをつけてるのがオタク感を出している。「キモイ」と感じる人もいるかも。

完遂できず。

Scikit-learn は「実践 Python データサイエンス」でちょっとやったし、あとは教科書で学べばよかったな。

オススメしない。

 

 

 

 

Python3 (+R), システムコマンド, 仮想環境

Python R Win10/Bash

自分のためのコマンドまとめ。

Bash でいう pwd, cd, ls, mv/cp/mkdir/rmなど。

注:環境は Win10, Bash on Ubuntu on Win, Python 3.5

注:MacOSLinux では一部コマンドが違うので注意。

 

 

PIP で python にインストールしたパッケージ確認

注:コマンドプロンプト

> pip freeze

 

  

Conda で仮想環境

 注:コマンドプロンプト

仮想環境を作る

> conda create -n TF

※ TF の代わりに任意の名前を。

※ 色々オプションあり。詳しくは:[Python]Anacondaで仮想環境を作る - Qiita

※ Win10 では 大文字と小文字は同じく認識。上記は > conda create -n tf と同義

 

 

仮想環境を確認する

> conda info -e

 

仮想環境に入る

> activate TF

 

仮想環境から出る

> deactivate

 

仮想環境を削除する

> conda remove -n TF --all 

 

 

 

システムコマンド

$ Bash

>>> Python3

>R 

 

 

$ pwd

>>>import os
>>>os.path.abspath('.')

>getwd()

 

$ cd, ls

>>>import os
>>>os.chdir('Dropbox')
>>>os.listdir('.')

>setwd("c:user")

>getwd()

 

$ ls

>>>import os
>>>os.listdir('/Dropbox')

>list.files() 

 

$ mv (move)

?

 

$ mv (rename)

>>>import os
>>>os.rename('foo.txt', 'bar.txt')

 

$ cp

>>>import shutil
>>>shutil.copy('foo.txt', 'bar.txt')

 

$ rm

>>>import os
>>>os.remove('foo.txt')

 

$ mkdir

>>>import os
>>>os.mkdir('folder')

 

$ rmdir

>>>import os
>>>os.rmdir('folder')

 

$ln -s

>>>import os
>>>os.symlink('foo.txt' 'linkfoo')

 

 

 

TensorFlow "簡単な" MNISTチュートリアル

DNN

MNIST For ML Beginners  |  TensorFlow

より引用。

Python を使った、MNIST のチュートリアルです。

下記のスクリプトは、Python 3.5 で実行しています。

Python 2 系ですと、(私に言われるまでもないですが)

>>> from __future__ import division

など、Python 3 と互換性を保つ作業が必要です。

これは、下記 Github のコードなど、参照してください。

 

対話式の環境で、コピペして試しやすいよう、上記の引用先ページからコード部分のみを貼り付けたものです。

 

挙動を確認するのに、パラメーターをいじったり、関数を変更してみたりして勉強して行くわけですが、毎回一行一行コピペするのが大変なため、コード部分のみを抜き出したものです。

 

実際のコードを見てみると、ほとんど tensorflow で定義された関数が使われています。そのため、「試してみる」だけなら、Python の知識はほとんどいらないようです。

 

 

MNIST For ML Beginners  |  TensorFlow サイトは英語なので大変ですが、 

Chrome を使っている場合、「右クリック+t」で、簡単に翻訳できます。

 

ディープラーニングの各種の手順については、「ゼロから始める Deep Learning」が詳しいです。

pmonty.hatenablog.com

 

なお、TensorFlow で使える関数などは、こちらのページにまとまっています。

Tensorflow Python API  |  TensorFlow

ここを参考にコードを変更することで、挙動を勉強できそうです。

 

 

 以下、TensorFlow "簡単な" チュートリアルのコードです。

import tensorflow as tf

 

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 

 

x = tf.placeholder(tf.float32, [None, 784])

 

W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

 

y = tf.nn.softmax(tf.matmul(x, W) + b)

 

y_ = tf.placeholder(tf.float32, [None, 10])

 

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

 

train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

 

init = tf.global_variables_initializer()

 

sess = tf.Session()
sess.run(init)

 

for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

# コピペする場合は、一旦ここまで貼り付けて Enter すること。

# 全部をコピペすると、for loop が回ってくれませんでした。私の PC が遅いから かもですが。。。

 

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

 

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

 

print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

# accuracy 0.918 程度となる。

 

読了:ゼロから作るDeep Learning ―Pythonで学ぶディープラーニングの理論と実装

DNN Python

ゼロから作る Deep Learning: Amazon.co.jp 

 

 TensorFlow など Deep learning のライブラリを使わず、Python3 (numpyなど使いますが)のみで Deep Neural Network, (DNN) を実装する、という本です。

 Deep Learning ライブラリや、General-Purpose computing on GPU, (GPGPU) ライブラリの使い方は書いていないです。従って、 TensorFlow/CAFFE/TEANO などのライブラリや、CUDA/CuDNN/OpenCV などの GPGPU は自分で勉強する必要あります。

  本書では CNN やRNN は実装しません。恐らく実際に Neural Network で何かやるには、CNN や RNN でないとキビシイ。そのため、この本だけの知識では、 Deep Learning で新しい何かをやるのは難しそうです。

(余談ですが、Google 社の DL ライブラリ、TensorFlow のチュートリアルには CNN や RNN の例もあったと思います。TF は GPU の有無にかかわらず、同じようにスクリプトを書けるそうですので、初心者にはお勧めなのだろうと思います)

 

 Neural network の各要素に、詳細な説明と実装がされているのが良い点。

 パーセプトロン、AND/OR/NAND/XORgate などから、様々な activation function 、学習を効率化する仕組みや、過学習を防ぐ方法 など、様々な要素を紹介しています。

 

 DNN を全く知らなかったので、色々勉強になりました。

 Neural Network のそれぞれの層で、

  情報 * 重み + バイアス

 という計算が、

  ベクトルの内積

 として一発で計算できるということですとか(これには感動しました)。

 

 他に、 back-propagation も多分、革命的な手法だったのだろうと思います。

 

 因みにですが、

  甘利俊一先生の「脳・心・人工知能

脳・心・人工知能 数理で脳を解き明かす (ブルーバックス) | 甘利俊一 | コンピュータサイエンス | Kindleストア | Amazon

という本に、

「back-propagation」などと最近では言われているが、これを「確率降下法」として最初に発見したのは私である。

 ということが書いてありました。

 「アカデミアとはこういうもの」という感じで、プログラミングとの違いが大変興味深いところ。

 

 Wikipedia を見ると、この手法が多くの研究者によって「再発見」されてきたことが分かります。バックプロパゲーション - Wikipedia 

 

 話は変わるが、研究というのは特許と違い、「発見に利益を求めない」ところが大変素晴らしいとは思います。

 けれど、こういう第一発見者=第一主義みたいのが、息苦しい。

 

 自分は今、プログラミングに興味があり、

 プログラミングの世界では、先人のコードを使うことはむしろ推奨され、それを無料で世界に公開した「github」なんてサイトもあります。

 

 「第一作成者は誰か」とか、「コードのインパクトファクター」「コードの被引用数」なんて、私の知る限りでは存在せず、

 

 「私が発見」とか「私の業績」とか血眼にならなくて良いので、プログラミングはいいな、と思います(もちろん、「できるプログラマ」が正当に評価されないことにつながり、問題もあります)。

 

 

 この本では、CNN や RNN など含め、比較的最近の研究まで紹介されています。一通りの知識を得ることができます。

 

 第一章の、 Python の簡単な説明も素晴らしいです。Python 入門書が一冊かけて説明するのを一章に凝縮してるので、網羅はできていません。しかし、本書を理解するには十分な内容です。

 

 昨年たくさん買い込んだ Python 入門書のある一冊で、

>>> 1+ 1

2

 を実行して

おめでとうございます!

あなたは今、Python プログラミングの世界に足を踏み入れました!!

みたいのがありましたが、

「1 + 1 を実行するために、Python 始めたんじゃないよ!」

 

 それと比べ、本書は明確な目的があります。Python を学ぶにも、「Deep Learningのため」と範囲を限定しているため、頭に入りやすかったです。

 

 さて、一周目は理解しないまま、「なんとなく」読み進めました。現在は二周目に入り、著者のコードを確認、「O'Reilly 入門 Python 3」 も並行しながら、本格的に読み進めています。

www.amazon.co.jp

 

 二周目でも理解できなかった所もあります。

  例:class の使い方。

>>> class TEST():

>>>    def __init__(self, name):

>>>        self.name = name

 

__init__  初期化とは???

self って何??? 

 

>>> t = TEST('example')

 なぜ

>>> TEST('example')

ではダメで、

>>> t = .....

で t に代入しなければ?

 とか

>>> sys.path.append(os.pardir)

頭では理解できてるけど、まだ細かな挙動が分からず

とか。

 

  一方で、「へー、こんなことできるんだー」

と理解できたコードもあり、

 

>>> if __main__ == '__name__': 

#スクリプトとして実行されたかどうかを判断する

  

 大変勉強になっています。

 

 ただ、最初に この本のスクリプトを試してみる時、どうしても

github から著者のコードを落としてくる

のと

コマンドラインでカレントディレクトリーを移動

の必要があります。

 

 ここで挫折する人がいると思いました。

 コマンドプロンプトとターミナルの使い方について記載があると、更に良かったと思います。

 

 また、

著者のスクリプトコマンドラインで実行する

と走るけれど、

自分で対話式に打ち込んでみる

とエラーが出ることもありました。

 

 対話式でも実行できるようコードを書き直すか、対話式で走らないコードは明記していただくと、良かったと思います。

 

 

因みに どこでエラーが出るかというと、 

例:p65

>>> def init_network():

(中略)

>>>     network['b3'] = np.array([0.1, 0.2])

>>> # 空行

>>>     return network

 

対話式の環境では、上記の

>>> # 空行

で関数定義が終了したと解釈され、

>>>     return network

でエラーとなる。

 

 本書で唯一、残念なところは、

本書を読んでも、DNN を作れるようにはならないこと

 です。

 「ゼロから作る」という題名ではありますが、最終的に、本書では、

著者が作成したコードを実行するだけ

 となってしまいます。たしかに著者は「ゼロから作った」のかもしれません。しかし、私のような Python 初心者は、コードを見ても、難解で理解不可能。著者のコードをただ実行するだけ となってしまいます。

 知識の乏しい読者のことを考え、著者が自分で実装してしたのだと思いますが、本書の題名には反すると思いました。

 

 つまり、このブログ記事の表現を借りると

blog.tinect.jp

 「Deep Learning を『分かった気になれる』本」、ということですね。 *1

 

 以上まとめますと、Deep Learning をやってみたい人、Python 3 を学んでみたい人におすすめな本です。

*1:「この本を読んでも、"Deep Learning" を理解できない」と言っているわけではありません。この本に書かれたことは、 Deep Learning の「基本」的なことだと思います。ただし本書だけでは不十分ということです