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

【発売日も気になる】ゼロから作るDeep Learning 3:フレームワーク編 - サンプルコードはGitHubに公開済み

 

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

 

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

 

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

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

 

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

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

 

が販売予定のようです。

調べてみたところ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()

 




 

 

by 子供プログラマー | プログラミング入門ウェブ教室

 

JDLA E資格を受験予定の方は気になりますよね
【2020年版 – 10社】簡単比較!JDLA認定プログラム講座(最安費用・無料 – 受講料返金・合格保証・前提知識) 

 

これだけの内容を無料で… 今はすごい時代ですね
【無料で読める】「Deep Learning」(Ian Goodfellow et al.)関連動画・資料も嬉しい

 

コンピュータ・プログラミング関連記事