def test10RandomImgs():
# 读取测试集结果
dl = DataLoader('MNIST', './datasets/MNIST/')
test_images, test_labels = dl.Load('test')
# 生成10个连续的随机数
idx = np.random.randint(0, test_images.shape[0] - 10)
random_image = test_images[idx:idx + 10, :]
# testlabel = nn.test(random_image.T)
MNIST_test = NN()
MNIST_test.loadParams()
out = MNIST_test.forward(random_image.T - 33.318421, 'test')
exp_out = np.exp(out)
softmax_out = exp_out / np.sum(exp_out, axis=0)
# 找到最大值索引，作为分类结果
cls_res = np.argmax(softmax_out, axis=0)
# 显示图像
for i in range(0, 10):
plt.subplot(2, 5, i + 1)
plt.title('分类: %d' % cls_res[i])
# 关闭坐标刻度
plt.xticks([])
plt.yticks([])
plt.imshow(np.reshape(random_image[i], [28, 28]), cmap='gray')
plt.show()
def __init__(self, state_n, action_n):
super(Model, self).__init__()
self.model = NN(state_n + action_n, state_n)
self.optimizer = optimizers.MomentumSGD(lr=1e-4)
self.optimizer.setup(self.model)
self.train_data = deque()
self.train_data_size_max = 2000
class Actor(object):
def __init__(self, n_st, n_act):
super(Actor, self).__init__()
self.n_st = n_st
self.n_act = n_act
self.model = NN(n_st, n_act)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.noise = ou_process(np.zeros((n_act), dtype=np.float32))
def action(self, st, noise=False):
a = self.model(st, norm=True)
if noise:
n = next(self.noise)
a = np.clip(a.data + n, -1, 1)
return a
else:
return a.data
def update(self, st, dqda):
mu = self.model(st, norm=True)
self.model.cleargrads()
mu.grad = -dqda
mu.backward()
self.optimizer.update()
def update_target(self, tau, current_NN):
self.model.weight_update(tau, current_NN)
def save_model(self, outputfile):
serializers.save_npz(outputfile, self.model)
def load_model(self, inputfile):
serializers.load_npz(inputfile, self.model)
def __init__(self, n_st, n_act):
super(Critic, self).__init__()
self.n_st = n_st
self.n_act = n_act
self.model = NN(n_st + n_act, 1)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.log = []
def __init__(self, n_st, n_act):
super(Actor, self).__init__()
self.n_st = n_st
self.n_act = n_act
self.model = NN(n_st, n_act)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.noise = ou_process(np.zeros((n_act), dtype=np.float32))
def __init__(self, in_dim, out_dim, interdims):
'''
Creates a neural network
:param in_dim: dimension of the state space
:param out_dim: dimension of the action space
:param interdims: {list of int} dimensions of intermediate layers
'''
NN.__init__(self, in_dim, out_dim, interdims)
#self.model[-1].weight.data.mul_(0.1)
#self.model[-1].bias.data.mul_(0.0)
self.model.log_std = torch.nn.Parameter(
2.4 * torch.ones(self.out_dim, requires_grad=True))
def init_population(self):
initial_population = {}
for i in range(self.population_size):
nn = NN()
initial_population[self.nn_id] = [self.n_gen, nn, 0] # 0 is the score
self.nn_id += 1
return initial_population
def mate(self, nn_1, nn_2):
nn_1_weight_1 = nn_1.model.layers[:][1].get_weights()
nn_2_weight_0 = nn_2.model.layers[:][0].get_weights()
nn = NN()
nn.model.layers[:][0].set_weights(nn_2_weight_0)
nn.model.layers[:][1].set_weights(nn_1_weight_1)
return nn
def make_score_hist(title):
Ascores = np.array([NN.output(Ai) for Ai in A])
Bscores = np.array([NN.output(Bi) for Bi in B])
plt.figure()
bins = np.linspace(0, 1, 20)
plt.hist(Ascores,
bins = bins,
color = 'r',
label = 'A',
histtype = 'step')
plt.hist(Bscores,
bins = bins,
color = 'b',
label = 'B',
histtype = 'step')
plt.title(title)
plt.xlabel("score")
plt.legend()
def train():
# 读取训练数据集
dl = DataLoader('MNIST', './datasets/MNIST/')
train_images, train_labels = dl.Load('train')
# 预处理 (0 均值化)
mean = np.mean(train_images)
print('数据集读取结束，训练数据均值: %f' % mean)
train_images -= mean
print('训练数据集数量: %d' % len(train_labels))
# 训练
startTime = time.time()
# 初始化网络
MNIST_Net = NN()
MNIST_Net.train(momentum=0.9,
learning_rate=0.01,
batchsize=100,
data_loader=dl,
valid_rate=10,
epoch=10,
alpha=0)
endTime = time.time()
print('训练时间：%d' % (endTime - startTime))
def test(mean=33.318421):
# 读取测试数据集，注意：测试时的均值仍然要与训练时均值相同
dl = DataLoader('MNIST', './datasets/MNIST/')
test_images, test_labels = dl.Load('test')
# 预处理 (0 均值化)
test_images -= mean
print('测试数据集数量: %d' % len(test_labels))
# 测试
MNIST_Net = NN()
MNIST_Net.loadParams()
MNIST_Net.valid(test_images.T, test_labels, 100, mode='test')
def predict(self, div, epoch=-1, model_name='nn'):
"""
epoch == -1: load from latest saved model
"""
data_gen = self.get_sample_generator(div, opt.infer_batch_size)
total_steps = int(
np.ceil(self.h5[div]['pid'].shape[0] / opt.infer_batch_size))
use_n_gpus = set_num_gpus(1)
nn = NN(model_name, len(self.char_dict))
with tf.Session() as sess:
# 주의: predict를 multi gpu에서 실행 시 batch split 시 문제 발생
nn.build_model(sess, use_n_gpus=use_n_gpus)
sess.run(tf.global_variables_initializer())
nn.load(epoch)
y_preds = nn.predict(data_gen, total_steps)
self.write_prediction_result(div, y_preds)
class Critic(object):
def __init__(self, n_st, n_act):
super(Critic, self).__init__()
self.n_st = n_st
self.n_act = n_act
self.model = NN(n_st + n_act, 1)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.log = []
def Q_value(self, st, act):
state_action_vector = np.concatenate((st, act), axis=1)
Q = self.model(state_action_vector).data
return Q
def return_dqda(self, st, act):
state_action_vector = Variable(np.concatenate((st, act), axis=1))
self.model.cleargrads()
Q = self.model(state_action_vector)
Q.grad = np.ones((state_action_vector.shape[0], 1), dtype=np.float32)
Q.backward()
grad = state_action_vector.grad[:, self.n_st:]
return grad
def update(self, y, st, act):
self.model.cleargrads()
state_action_vector = np.concatenate((st, act), axis=1)
Q = self.model(state_action_vector)
loss = F.mean_squared_error(Q, Variable(y))
loss.backward()
self.optimizer.update()
self.log.append('Q:{0},y:{1}\n'.format(Q.data.T, y.T))
return loss.data
def update_target(self, tau, current_NN):
self.model.weight_update(tau, current_NN)
def save_model(self, outputfile):
serializers.save_npz(outputfile, self.model)
def load_model(self, inputfile):
serializers.load_npz(inputfile, self.model)
def train(self, use_n_gpus, resume=-1, model_name='nn', reverse=False):
"""
resume == 0: not load
resume == -1: load from latest saved model (not from last epoch model)
resume > 0: load {resume}th epoch model
"""
train_gen = self.get_sample_generator('train',
opt.batch_size,
reverse=reverse)
train_steps = int(np.ceil(self.train_data_len / opt.batch_size))
val_gen = self.get_sample_generator('val', opt.batch_size)
val_steps = int(np.ceil(self.val_data_len / opt.batch_size))
use_n_gpus = set_num_gpus(use_n_gpus)
nn = NN(model_name, len(self.char_dict))
with tf.Session() as sess:
nn.build_model(sess, use_n_gpus)
sess.run(tf.global_variables_initializer())
nn.fit(train_gen, train_steps, val_gen, val_steps, opt.num_epochs,
resume)
class Model(object):
"""Model for predicting next state based on current state and action.
Args:
state_n: dimension of state
action_n: dimension of action
Result:
next state = f(state, action) = NN(state + action)
"""
def __init__(self, state_n, action_n):
super(Model, self).__init__()
self.model = NN(state_n + action_n, state_n)
self.optimizer = optimizers.MomentumSGD(lr=1e-4)
self.optimizer.setup(self.model)
self.train_data = deque()
self.train_data_size_max = 2000
def predict(self, state, action):
state_action = np.concatenate((state, action),
axis=0).astype(np.float32)
state_action = Variable(
state_action.reshape((1, state_action.shape[0])))
next_state = self.model(state_action)
return next_state
def store_data(self, state, action, next_state):
state_action = np.concatenate((state, action), axis=0)
self.train_data.append((state_action, next_state))
if len(self.train_data) > self.train_data_size_max:
self.train_data.popleft()
def shuffle_data(self):
data = np.array(self.train_data)
return np.random.permutation(data)
def train(self, n_epoch, batch_size):
print('Train start!')
for epoch in range(n_epoch):
# print(f'epoch: {epoch}')
perm = self.shuffle_data()
sum_loss = 0.
# Train
for i in range(0, len(perm), batch_size):
batch_data = perm[i:i + batch_size]
x_batch = np.array(list(batch_data[:, 0]), dtype=np.float32)
t_batch = np.array(list(batch_data[:, 1]), dtype=np.float32)
x_batch, t_batch = Variable(x_batch), Variable(t_batch)
y = self.model(x_batch)
loss = F.mean_squared_error(y, t_batch)
self.model.cleargrads()
loss.backward()
self.optimizer.update()
sum_loss += loss.data
# print(f'train loss: {sum_loss}')
self.save_model()
@property
def train_data_size(self):
return len(self.train_data)
def dump_data(self, file='train_data/train_data.txt'):
with open(file, 'wb') as f:
pickle.dump(self.train_data, f)
def load_data(self, file='train_data/train_data.txt'):
with open(file, 'rb') as f:
self.train_data = pickle.load(f)
@staticmethod
def exist_data(file='train_data/train_data.txt'):
return os.path.exists(file)
def save_model(self, file='model/model.model'):
serializers.save_npz(file, self.model)
def load_model(self, file='model/model.model'):
serializers.load_npz(file, self.model)
@staticmethod
def exist_model(file='model/model.model'):
return os.path.exists(file)
def ensemble(self, div, *model_epochs):
"""
model_epoch = ('model_name1', epoch_num, 'model_name2', epoch_num, ...)
epoch_num이 -1이면 제일 마지막 epoch 사용
"""
softmax_file_names = []
print(model_epochs)
for i in range(0, len(model_epochs), 2):
model_name = model_epochs[i]
epoch = model_epochs[i + 1]
self.logger.info('{}: {} epoch'.format(model_name, epoch))
data_gen = self.get_sample_generator(div, opt.infer_batch_size)
total_data_len = self.h5[div]['pid'].shape[0]
total_steps = int(np.ceil(total_data_len / opt.infer_batch_size))
use_n_gpus = set_num_gpus(1)
nn = NN(model_name, len(self.char_dict))
with tf.Session(graph=tf.Graph()) as sess:
nn.build_model(sess, use_n_gpus=use_n_gpus)
sess.run(tf.global_variables_initializer())
epoch = nn.load(epoch)
y_softmaxs = nn.predict(data_gen, total_steps, softmax=True)
file_name = '%s_%dep_%s_softmax.tmp' % (model_name, epoch, div)
softmax_file_names.append(file_name)
with h5py.File(file_name, 'w') as fout:
fout.create_dataset('b',
shape=(total_data_len,
opt.num_bcate + 1))
fout.create_dataset('m',
shape=(total_data_len,
opt.num_mcate + 1))
fout.create_dataset('s',
shape=(total_data_len,
opt.num_scate + 1))
fout.create_dataset('d',
shape=(total_data_len,
opt.num_dcate + 1))
fout['b'][:] = np.array(y_softmaxs['b'])
fout['m'][:] = np.array(y_softmaxs['m'])
fout['s'][:] = np.array(y_softmaxs['s'])
fout['d'][:] = np.array(y_softmaxs['d'])
del y_softmaxs
# load softmax.tmp, sum, argmax
chunk_size = 50000
steps = int(np.ceil(total_data_len / chunk_size))
y_preds = {'b': [], 'm': [], 's': [], 'd': []}
softmax_files = [h5py.File(name, 'r') for name in softmax_file_names]
for cate in ['b', 'm', 's', 'd']:
self.logger.info('%s category processing...' % cate)
for i in range(steps):
# softmax h5파일을 chunk_size만큼 읽어서 메모리에 올린다.
softmax_per_model = []
for softmax_file in softmax_files:
softmax = softmax_file[cate][i * chunk_size:(i + 1) *
chunk_size]
softmax_per_model.append(softmax)
for j in range(len(softmax_per_model[0])):
softmax_sum = np.zeros_like(softmax_per_model[0][0])
for softmax in softmax_per_model:
softmax_sum += softmax[j]
y_preds[cate].append(np.argmax(softmax_sum))
del softmax_per_model
self.write_prediction_result(div, y_preds)
# データ整形
data = np.genfromtxt('data/train.csv', delimiter=',',
skip_header=1) # data.shape => (42001, 785)
x = data[:, 1:].astype(np.float32)
y = data[:, 0].astype(np.int32)[:, None]
y = np.ndarray.flatten(y)
train, test = datasets.split_dataset_random(datasets.TupleDataset(x, y),
int(x.shape[0] * .7))
# iterator 作成
train_itr = iterators.SerialIterator(train, 100)
test_itr = iterators.SerialIterator(test, 100, repeat=False, shuffle=False)
# ｍodel 作成
model = L.Classifier(NN(100, 10), lossfun=F.softmax_cross_entropy)
# どこかのソースから拾ってきて sigmoid_cross_entropy, binary_accuracy を設定したらハマった
# しっかりドキュメント読むこと
# optimizer 作成
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# updater 作成
updater = training.updaters.StandardUpdater(train_itr,
optimizer,
device=-1)
# trainer 作成
trainer = training.Trainer(updater, (20, 'epoch'), out='results')
trainer.extend(extensions.Evaluator(test_itr, model,
from loader import mnist from network import NN from op import Fullyconnected, Sigmoid, SimpleBatchNorm, Relu, Dropout import numpy as np # Set hyper-params here batch_size = 20 learning_rate = 0.01 learning_step = [6] weight_decay = 0. total_epoch = 12 model_path = './model/' # Construct nn MLP = NN(learning_rate=learning_rate) MLP.add(SimpleBatchNorm(name='data_batchnorm', istraining=True)) MLP.add(Dropout(ratio=0.3, name='data_dropout')) MLP.add(Fullyconnected(784, 512, name="fc1")) MLP.add(SimpleBatchNorm(name='fc1_batchnorm')) MLP.add(Relu(name="fc1_relu")) MLP.add(Fullyconnected(512, 512, name="fc2")) MLP.add(Relu(name="fc2_relu")) MLP.add(Fullyconnected(512, 10, name="fc3")) MLP.set_wd(weight_decay) MLP.set_lr(learning_rate) # Load mnist data mnist = mnist(path="./data/", batch_size=batch_size) num_imgs = mnist.get_num() epoch = 0
import numpy as np
import os
from PIL import Image
from network import NN
from op import Fullyconnected, Sigmoid, SimpleBatchNorm, Relu
img_dir = "./imgs/"
model_path = './model/mnist_mlp_epoch9.model'
# Construct nn
MLP = NN()
MLP.add(SimpleBatchNorm(name="data_batchnorm", istraining=False))
MLP.add(Fullyconnected(784, 512, name="fc1"))
MLP.add(Relu(name="fc1_relu"))
MLP.add(SimpleBatchNorm(name='fc1_batchnorm'))
MLP.add(Fullyconnected(512, 512, name="fc2"))
MLP.add(Relu(name="fc2_relu"))
MLP.add(Fullyconnected(512, 10, name="fc3"))
# Load model
MLP.load_model(model_path)
for parent, dirnames, filenames in os.walk(img_dir):
for filename in filenames:
if filename.endswith("jpg") or filename.endswith("png"):
img_path = os.path.join(parent, filename)
pil_img = Image.open(img_path).convert('L')
pil_img = pil_img.resize((28, 28), Image.ANTIALIAS)
img = np.array(pil_img)
out_data = MLP.forward(img.reshape((1, 784)))
import numpy as np
import matplotlib.pyplot as plt
import chainer
from chainer import serializers
import chainer.links as L
from network import NN
if __name__ == '__main__':
# モデルの読み込み
model = L.Classifier(NN(100, 10))
serializers.load_npz('digit_recognizer.model', model)
# 推定対象の読み込み
test_data = np.genfromtxt('data/test.csv', delimiter=',',
skip_header=1) # data.shape => (28000, 784)
target = test_data[np.random.randint(0, 28000)].astype(np.float32)
# 推定対象の確認（画像表示）
plt.imshow(np.reshape(target, (28, 28)), cmap='gray') # 対象の画像を表示
plt.show()
# 推定
prediction = model.predictor(chainer.Variable(np.array([target]))).data[0]
print(prediction.argmax())
