def test_flatten_palams(self): model = MLP((10, 10, 10)) x = np.array([[1.0]]) model(x) d = {} model._flatten_params(d) self.assertIn('l0/W', d) self.assertIn('l0/b', d) self.assertIn('l1/W', d) self.assertIn('l1/b', d) self.assertIn('l2/W', d) self.assertIn('l2/b', d) for v in d.values(): self.assertIsInstance(v, Parameter)
def test_MomentumSDG(self): x = np.random.rand(100, 1) y = np.sin(2 * np.pi * x) + np.random.rand(100, 1) hidden_size = 10 model = MLP((hidden_size, 1)) optimizer = optimizers.MomentumSGD(lr) optimizer.setup(model) for i in range(max_iters): y_pred = model(x) loss = F.mean_squared_error(y, y_pred) model.cleargrads() loss.backward() optimizer.update() assert True
def test_SoftmaxCrossEntorpy(self): max_epoch = 0 batch_size = 30 hidden_size = 10 lr = 1.0 train_set = Spiral(train=True) test_set = Spiral(train=False) train_loader = DataLoader(train_set, batch_size) test_loader = DataLoader(test_set, batch_size, shuffle=False) model = MLP((hidden_size, hidden_size, hidden_size, 3)) optimizer = optimizers.SGD(lr).setup(model) 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: {:.4f}, accuracy: {:.4f}'.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: {:.4f}, accuracy: {:.4f}'.format( sum_loss / len(test_set), sum_acc / len(test_set)))
def test_MNIST(self): 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, 10)) model = MLP((hidden_size, hidden_size, 10), activation=F.relu) optimizer = optimizers.SGD().setup(model) if dezero.cuda.gpu_enable: train_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: {:.4f}, accuracy: {:.4f}'.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: {:.4f}, accuracy: {:.4f}'.format( sum_loss / len(test_set), sum_acc / len(test_set)))
import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import time import dezero import dezero.functions as F from dezero import optimizers from dezero import DataLoader from dezero.models import MLP max_epoch = 5 batch_size = 100 train_set = dezero.datasets.MNIST(train=True) train_loader = DataLoader(train_set, batch_size) model = MLP((1000, 10)) optimizer = optimizers.SGD().setup(model) # GPU mode if dezero.cuda.gpu_enable: train_loader.to_gpu() model.to_gpu() for epoch in range(max_epoch): start = time.time() sum_loss = 0 for x, t in train_loader: y = model(x) loss = F.softmax_cross_entropy(y, t) acc = F.accuracy(y, t)
import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import os import dezero import dezero.functions as F from dezero import optimizers from dezero import DataLoader from dezero.models import MLP max_epoch = 3 batch_size = 100 train_set = dezero.datasets.MNIST(train=True) train_loader = DataLoader(train_set, batch_size) model = MLP((1000, 10)) optimizer = optimizers.SGD().setup(model) # read params if exist if os.path.exists('my_nlp.npz'): model.load_weights('my_nlp.npz') else: for epoch in range(max_epoch): sum_loss = 0 for x, t in train_loader: y = model(x) loss = F.softmax_cross_entropy(y, t) acc = F.accuracy(y, t) model.cleargrads()
import numpy as np np.random.seed(0) from dezero import Variable, as_variable import dezero.functions as F from dezero.models import MLP def softmax1d(x): x = as_variable(x) y = F.exp(x) sum_y = F.sum(y) return y / sum_y model = MLP((2, 10, 3)) x = Variable(np.array([0.2, -0.4])) y = model(x) p = softmax1d(y) print(y) print(p) x = np.array([[0.2, -0.4], [0.3, 0.5], [1.3, -3.2], [2.1, 0.3]]) t = np.array([2, 0, 1, 0]) y = model(x) p = F.softmax(y) print(y) print(p) loss = F.softmax_cross_entropy(y, t)
from dezero.optimizers import SGD # MNIST 데이터 학습하기 max_epoch = 5 batch_size = 100 hidden_size = 1000 # /root/.dezero/t10k-images-idx3-ubyte.gz 경로에 있음 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, 10)) model = MLP((hidden_size, hidden_size, 10), activation=F.relu) optimizer = SGD().setup(model) 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)
import dezero import dezero.functions as F from dezero import optimizers from dezero.dataset import DatasetLoader from dezero.models import MLP max_epoch = 3 batch_size = 100 train_set, test_set = dezero.datasets.get_mnist() train_loader = DatasetLoader(train_set, batch_size) model = MLP((784, 1000, 10)) optimizer = optimizers.SGD().setup(model) # パラーメタの読み込み # model.load_weights('my_mlp.npz') for epoch in range(max_epoch): sum_loss = 0 for x, t in train_loader: y = model(x) loss = F.softmax_cross_entropy(y, t) model.cleargrads() loss.backward() optimizer.update() sum_loss += float(loss.data) * len(t) print('epoch: {}, loss: {:.4f}'.format(epoch + 1, sum_loss / len(train_set)))
sys.path.append(os.path.join(os.path.dirname(__file__), "..")) import os import time import dezero import dezero.functions as F from dezero import optimizers from dezero import DataLoader from dezero.models import MLP, Model max_epoch = 5 batch_size = 100 train_set = dezero.datasets.MNIST(train=True) train_loader = DataLoader(train_set, batch_size) model = MLP((1000, 10)) optimizer = optimizers.SGD().setup(model) # GPU mode if dezero.cuda.gpu_enable: train_loader.to_gpu() model.to_gpu() # 매개변수 읽기 if os.path.exists("my_mlp.npz"): model.load_weights("my_mlp.npz") for epoch in range(max_epoch): start = time.time() sum_loss = 0
import numpy as np from dezero import Variable from dezero import optimizers import dezero.functions as F from dezero.models import MLP np.random.seed(0) x = np.random.rand(100, 1) y = np.sin(2 * np.pi * x) + np.random.rand(100, 1) x, y = Variable(x), Variable(y) lr = 0.2 max_iter = 10000 hidden_size = 10 model = MLP((1, hidden_size, 1)) optimizer = optimizers.SGD(lr).setup(model) for i in range(max_iter): y_pred = model(x) loss = F.mean_squared_error(y, y_pred) model.cleargrads() loss.backward() optimizer.update() print(loss)
import dezero from dezero import optimizers import dezero.functions as F from dezero.models import MLP train_set, test_set = dezero.datasets.get_spiral() x = np.array([example[0] for example in train_set]) t = np.array([example[1] for example in train_set]) # ハイパーパラメータの設定 max_epoch = 300 batch_size = 30 hidden_size = 10 lr = 1.0 model = MLP((2, hidden_size, 3)) optimizer = optimizers.SGD(lr).setup(model) data_size = len(x) max_iter = math.ceil(data_size / batch_size) # 小数点の切り上げ for epoch in range(max_epoch): # データのシャッフル idx = np.random.permutation(data_size) x = x[idx] t = t[idx] sum_loss = 0 for i in range(max_iter): batch_x = x[i * batch_size:(i + 1) * batch_size]
import dezero import dezero.functions as F from dezero import DataLoader from dezero import optimizers 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 = optimizers.Adam().setup(model) # パラメータの読み込み if os.path.exists('my_mlp.npz'): model.load_weights('my_mlp.npz') 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.clear_grads() loss.backward()
if '__file__' in globals(): import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import math import numpy as np import dezero from dezero import optimizers import dezero.functions as F from dezero.models import MLP max_epoch = 100 batch_size = 30 hidden_size = 10 lr = 1.0 x, t = dezero.datasets.get_spiral(train=True) model = MLP((hidden_size, 3)) optimizer = optimizers.SGD(lr).setup(model)
sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import numpy as np np.random.seed(0) from dezero import Variable, as_variable import dezero.functions as F from dezero.models import MLP def softmax1d(x): x = as_variable(x) y = F.exp(x) sum_y = F.sum(y) return y / sum_y model = MLP((10, 3)) x = Variable(np.array([[0.2, -0.4]])) y = model(x) p = softmax1d(y) print(y) print(p) x = np.array([[0.2, -0.4], [0.3, 0.5], [1.3, -3.2], [2.1, 0.3]]) t = np.array([2, 0, 1, 0]) y = model(x) p = F.softmax_simple(y) print(y) print(p)
import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import math import numpy as np import dezero import dezero.functions as F from dezero import optimizers from dezero.models import MLP max_epoch = 20 batch_size = 100 hidden_size = 1000 train_set, test_set = dezero.datasets.get_mnist() model = MLP((hidden_size, 10)) optimizer = optimizers.SGD().setup(model) data_size = len(train_set) max_iter = math.ceil(data_size / batch_size) for epoch in range(max_epoch): # Shuffle data np.random.shuffle(train_set) for i in range(max_iter): # Create minibatch batch = train_set[i * batch_size:(i + 1) * batch_size] x = np.array([example[0] for example in batch]) t = np.array([example[1] for example in batch]) y = model(x)
import time # import math #import numpy as np import dezero import dezero.functions as F from dezero import optimizers from dezero import DataLoader from dezero.models import MLP max_epoch = 5 batch_size = 100 train_set = dezero.datasets.MNIST(train=True) train_loader = DataLoader(train_set, batch_size) model = MLP((1000, 10), activation=F.relu) optimizer = optimizers.SGD().setup(model) # GPU mode if dezero.cuda.gpu_enable: train_loader.to_gpu() model.to_gpu() for epoch in range(max_epoch): start = time.time() sum_loss = 0 for x, t in train_loader: y = model(x) loss = F.softmax_cross_entropy(y, t) model.cleargrads()
import matplotlib.pyplot as plt import numpy as np import dezero import dezero.functions as F from dezero import optimizers from dezero.models import MLP max_epoch = 300 batch_size = 30 hidden_size = 10 lr = 1.0 x, t = dezero.datasets.get_spiral(train=True) model = MLP((hidden_size, 3)) optimizer = optimizers.SGD(lr).setup(model) data_size = len(x) max_iter = math.ceil(data_size / batch_size) for epoch in range(max_epoch): index = np.random.permutation(data_size) sum_loss = 0 for i in range(max_iter): batch_index = index[i * batch_size:(i + 1) * batch_size] batch_x = x[batch_index] batch_t = t[batch_index] y = model(batch_x)
import dezero.functions as F from dezero import optimizers import numpy as np import dezero.layers as L from dezero.models import MLP np.random.seed(0) x = np.random.rand(100, 1) y = np.sin(2 * np.pi * x) + np.random.rand(100, 1) lr = 0.2 max_iter = 10000 hidden_size = 10 #モデルの定義 model = MLP((hidden_size, 1)) optimizer = optimizers.SGD(lr) optimizer.setup(model) #学習の開始 for i in range(max_iter): y_pred = model(x) loss = F.mean_squared_error(y, y_pred) model.cleargrads() loss.backward() optimizer.update() for p in model.params(): p.data -= lr * p.grad.data