【発売日も気になる→発売開始】ゼロから作るDeep Learning 3：フレームワーク編

Contents - 目次（もくじ）

1 既にサンプルコードは公開中：ゼロから作るDeep Learning 3
2 DeZeroとは？
3 【動画】DeZeroを使ってみた – サンプルコードRNN/LSTM・MNIST・GAN
- 3.1 動画で実装したコード
- 3.2 共有:

既にサンプルコードは公開中：ゼロから作るDeep Learning 3

ゼロから作るDeep Learningというと、人工知能・機械学習プログラミングに関心のある方は、お世話になっている方も多いのではないかと思いますが、2020年に

ゼロから作るDeep Learning 3：フレームワーク編
斎藤康毅（著）
出版社：オライリージャパン

ゼロから作るDeep Learning ❸ ―フレームワーク編

Amazon.co.jpで詳しくみてみる：（2020年4月20日販売開始）
ゼロから作るDeep Learning ❸ ―フレームワーク編

＊　2020年5月14日23時確認時点：Amazon販売/出品分 “在庫あり” レビュー6件
＊ 2020年4月29日PM3時05分確認時点：Amazon販売/出品分”一時的に在庫切れ入荷時期は未定です” のようでした。高いですが、他出品者の新品・中古が販売されているようでした。レビューの投稿が開始されているようです。
＊ 2020年4月27日PM7時40分確認時点：Amazon販売/出品分の記載がなくなったようでした。高いですが、他出品者の新品・中古が販売されているようでした。
＊ 2020年4月25日PM4時45分確認時点：Amazon販売/出品分”一時的に在庫切れ入荷時期は未定です” のようでした。
＊ 2020年4月22日PM10時30分確認時点：Amazon販売/出品分”一時的に在庫切れ入荷時期は未定です” のようでした。早く入荷されるといいですね。他の販売者の出品もあるようですが、5月到着+値段が高い…
＊ 2020年4月21日AM1時30分確認時点：Amazon販売/出品分は”一時的に在庫切れ入荷時期は未定です” のようでした。

楽天ブックスで詳しくみてみる：（2020年4月20日頃販売開始）
ゼロから作るDeep Learning 3 – フレームワーク編（斎藤康毅著）

＊ 2020年4月29日PM3時05分確認時点：”ご注文できない商品”のようでした。再入荷待ちですね。
＊ 2020年4月27日PM7時40分確認時点：”在庫あり”（残りあと4個）のようでした。売れてますね。
＊ 2020年4月25日PM4時45分確認時点：”在庫あり”（残りあと22個）のようでした。
＊ 2020年4月22日PM10時30分確認時点：”在庫あり”（残りあと6個）のようでした。徐々に売れてますね。
＊ 2020年4月21日AM1時30分確認時点：”在庫あり”（残りあと15個）のようでした。

楽天市場で詳しくみてみる：
「ゼロから作るdeep learning 3 フレームワーク」検索ページへ | 楽天市場

＊　2020年4月29日PM3時05分確認時点：1つのショップで販売されているようでした。
＊　2020年4月27日PM7時40分確認時点：いくつかのショップで販売されているようでした。

Yahoo!ショッピングで詳しくみてみる：
「ゼロから作るDeep Learning 3 フレームワーク編」検索ページへ | Yahoo!ショッピング

＊ 2020年4月29日PM3時05分確認時点：1つのショップで販売されているようでした。
＊ 2020年4月27日PM7時40分確認時点：3つのショップでの販売が確認出来ました。
＊ 2020年4月25日PM4時45分確認時点：2つのショップでの販売が確認出来ました。
＊ 2020年4月22日PM10時30分確認時点：2つのショップでの販売が確認出来ました。

が販売予定のようです。

調べてみたところGitHubでは既にサンプルコードが公開されているようでした。

Github
oreilly-japan/deep-learning-from-scratch-3（MIT License）

まだ知らない方はチェックしてみてください。

DeZeroとは？

情報を調べてみると「DeZero」（ディゼロ）というディープラーニングのフレームワークをゼロから作るようです。
ここで

「 DeZeroって何？ 」

と思われる方も多いのではないかと思います。
自分も、始めは

「 最新のディープラーニング技術？ 」

「 ゼロから作るDeep Learning系ということは、機械学習のトピックス？ 」

と勘違いしていましたが、

・ゼロから作るDeep Learning 3：フレームワーク編のオリジナルフレームワーク

のようです。
書籍の商品説明を読んでみると

フレームワークを、全部で60のステップで完成させます。それによって、PyTorch、TensorFlow、Chainerなどの現代のフレームワークに通じる知識を深めます。

出典：
Amazon.co.jp
ゼロから作るDeep Learning ❸ ―フレームワーク編
2020年3月8日利用

とのことでしたので、機械学習プログラミングを深めたい方にとっては気になりますね。
今から発売が楽しみです。

【動画】DeZeroを使ってみた – サンプルコードRNN/LSTM・MNIST・GAN

以下に、実際にDeZeroを使ってみた様子をまとめておきました。書籍のために作られたDeZeroで、色々出来るようです。すごいですね。

【刊行前に使える !?】ゼロから作るDeep Learning 3のオリジナルフレームワーク
DeZeroサンプルコード – RNN/LSTM・MNIST・GAN（動画）

視聴時間：2分37病

動画で試しているDeZeroのサンプルコード

GitHub – oreilly-japan/deep-learning-from-scratch-3
The MIT License (MIT)　Copyright (c) 2019 Koki Saitoh
https://github.com/oreilly-japan/deep-learning-from-scratch-3

・全60ステップの最終ステップの「step60.py」
時系列データ予測：
再帰型ニューラルネットワーク（RNN：Recurrent Neural Network）
LSTM（Long short-term memor）

・examplesの「mnist.py」
0〜9までの手書き数字画像認識

・examplesの「gan.py」
敵対的生成ネットワーク（GAN・GANs：Generative adversarial networks）
手書き数字画像の生成

等をGoogle Colaboratoryの環境で動かしています。

動画で実装したコード

動画で実装したコード
DeZero_Sample.ipynb | Google Colaboratory共有リンク

以下のサンプルコードを基にさせていただきました。

GitHub – oreilly-japan/deep-learning-from-scratch-3
https://github.com/oreilly-japan/deep-learning-from-scratch-3
2020年3月9日利用時点

The MIT License (MIT)
Copyright (c) 2019 Koki Saitoh
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

DeZeroをインストールします。

pip install dezero

時系列データ予測：step60.pyのサンプルコード

＊注：import os, sys; sys.path.append(os.path.join(os.path.dirname(file), '..')) は削除してあります。

import numpy as np import matplotlib.pyplot as plt import dezero from dezero import Model from dezero import SeqDataLoader import dezero.functions as F import dezero.layers as L

max_epoch = 100 batch_size = 30 hidden_size = 100 bptt_length = 30

train_set = dezero.datasets.SinCurve(train=True) dataloader = SeqDataLoader(train_set, batch_size=batch_size) seqlen = len(train_set)

class BetterRNN(Model): def __init__(self, hidden_size, out_size): super().__init__() self.rnn = L.LSTM(hidden_size) self.fc = L.Linear(out_size)

def reset_state(self): self.rnn.reset_state()

def __call__(self, x): y = self.rnn(x) y = self.fc(y) return y

model = BetterRNN(hidden_size, 1) optimizer = dezero.optimizers.Adam().setup(model)

for epoch in range(max_epoch): model.reset_state() loss, count = 0, 0

for x, t in dataloader: y = model(x) loss += F.mean_squared_error(y, t) count += 1

if count % bptt_length == 0 or count == seqlen: model.cleargrads() loss.backward() loss.unchain_backward() optimizer.update() avg_loss = float(loss.data) / count print('| epoch %d | loss %f' % (epoch + 1, avg_loss))

# Plot xs = np.cos(np.linspace(0, 4 * np.pi, 1000)) model.reset_state() pred_list = [] with dezero.no_grad(): for x in xs: x = np.array(x).reshape(1, 1) y = model(x) pred_list.append(float(y.data)) plt.plot(np.arange(len(xs)), xs, label='y=cos(x)') plt.plot(np.arange(len(xs)), pred_list, label='predict') plt.xlabel('x') plt.ylabel('y') plt.legend() plt.show()

手書き数字画像認識：examples内のmnist.pyのサンプルコード

import dezero import dezero.functions as F from dezero import DataLoader from dezero.models import MLP

max_epoch = 5 batch_size = 100 hidden_size = 1000

train_set = dezero.datasets.MNIST(train=True) test_set = dezero.datasets.MNIST(train=False) train_loader = DataLoader(train_set, batch_size) test_loader = DataLoader(test_set, batch_size, shuffle=False)

model = MLP((hidden_size, hidden_size, 10), activation=F.relu) optimizer = dezero.optimizers.Adam().setup(model) optimizer.add_hook(dezero.optimizers.WeightDecay(1e-4)) # Weight decay

if dezero.cuda.gpu_enable: train_loader.to_gpu() test_loader.to_gpu() model.to_gpu()

for epoch in range(max_epoch): sum_loss, sum_acc = 0, 0

for x, t in train_loader: y = model(x) loss = F.softmax_cross_entropy(y, t) acc = F.accuracy(y, t) model.cleargrads() loss.backward() optimizer.update()

sum_loss += float(loss.data) * len(t) sum_acc += float(acc.data) * len(t)

print('epoch: {}'.format(epoch+1)) print('train loss: {}, accuracy: {}'.format( sum_loss / len(train_set), sum_acc / len(train_set)))

sum_loss, sum_acc = 0, 0 with dezero.no_grad(): for x, t in test_loader: y = model(x) loss = F.softmax_cross_entropy(y, t) acc = F.accuracy(y, t) sum_loss += float(loss.data) * len(t) sum_acc += float(acc.data) * len(t)

print('test loss: {}, accuracy: {}'.format( sum_loss / len(test_set), sum_acc / len(test_set)))

敵対的生成ネットワーク – 手書き数字画像の生成：examples内のgan.pyのサンプルコード

import numpy as np import matplotlib.pyplot as plt import dezero import dezero.functions as F import dezero.layers as L from dezero import DataLoader from dezero.models import Sequential from dezero.optimizers import Adam

use_gpu = dezero.cuda.gpu_enable max_epoch = 5 batch_size = 128 hidden_size = 62

fc_channel, fc_height, fc_width = 128, 7, 7

gen = Sequential( L.Linear(1024), L.BatchNorm(), F.relu, L.Linear(fc_channel * fc_height * fc_width), L.BatchNorm(), F.relu, lambda x: F.reshape(x, (-1, fc_channel, fc_height, fc_width)), L.Deconv2d(fc_channel // 2, kernel_size=4, stride=2, pad=1), L.BatchNorm(), F.relu, L.Deconv2d(1, kernel_size=4, stride=2, pad=1), F.sigmoid )

dis = Sequential( L.Conv2d(64, kernel_size=4, stride=2, pad=1), F.leaky_relu, L.Conv2d(128, kernel_size=4, stride=2, pad=1), L.BatchNorm(), F.leaky_relu, F.flatten, L.Linear(1024), L.BatchNorm(), F.leaky_relu, L.Linear(1), F.sigmoid )

def init_weight(dis, gen, hidden_size): # Input dummy data to initialize weights batch_size = 1 z = np.random.rand(batch_size, hidden_size) fake_images = gen(z) dis(fake_images)

for l in dis.layers + gen.layers: classname = l.__class__.__name__ if classname.lower() in ('conv2d', 'linear', 'deconv2d'): l.W.data = 0.02 * np.random.randn(*l.W.data.shape)

init_weight(dis, gen, hidden_size)

opt_g = Adam(alpha=0.0002, beta1=0.5).setup(gen) opt_d = Adam(alpha=0.0002, beta1=0.5).setup(dis)

transform = lambda x: (x / 255.0).astype(np.float32) train_set = dezero.datasets.MNIST(train=True, transform=transform) train_loader = DataLoader(train_set, batch_size)

if use_gpu: gen.to_gpu() dis.to_gpu() train_loader.to_gpu() xp = dezero.cuda.cupy else: xp = np

label_real = xp.ones(batch_size).astype(np.int) label_fake = xp.zeros(batch_size).astype(np.int) test_z = xp.random.randn(25, hidden_size).astype(np.float32)

def generate_image(): with dezero.test_mode(): fake_images = gen(test_z)

img = dezero.cuda.as_numpy(fake_images.data) plt.figure() for i in range(0, 25): ax = plt.subplot(5, 5, i+1) ax.axis('off') plt.imshow(img[i][0], 'gray') plt.show() #plt.savefig('gan_{}.png'.format(idx))

for epoch in range(max_epoch): avg_loss_d = 0 avg_loss_g = 0 cnt = 0

for x, t in train_loader: cnt += 1 if len(t) != batch_size: continue

# (1) Update discriminator z = xp.random.randn(batch_size, hidden_size).astype(np.float32) fake = gen(z) y_real = dis(x) y_fake = dis(fake.data) loss_d = F.binary_cross_entropy(y_real, label_real) + \ F.binary_cross_entropy(y_fake, label_fake) gen.cleargrads() dis.cleargrads() loss_d.backward() opt_d.update()

# (2) Update generator y_fake = dis(fake) loss_g = F.binary_cross_entropy(y_fake, label_real) gen.cleargrads() dis.cleargrads() loss_g.backward() opt_g.update()

# Print loss & visualize generator avg_loss_g += loss_g.data avg_loss_d += loss_d.data interval = 100 if use_gpu else 5 if cnt % interval == 0: epoch_detail = epoch + cnt / train_loader.max_iter print('epoch: {:.2f}, loss_g: {:.4f}, loss_d: {:.4f}'.format( epoch_detail, float(avg_loss_g/cnt), float(avg_loss_d/cnt))) generate_image()