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) # model 作成 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())