def main(args): train_set, valid_set, test_set = prepare_dataset(args.data_dir) train_x, train_y = train_set test_x, test_y = test_set # train_y = get_one_hot(train_y, 2) net = Net([Dense(100), ReLU(), Dense(30), ReLU(), Dense(1)]) model = Model(net=net, loss=SigmoidCrossEntropyLoss(), optimizer=Adam(lr=args.lr)) iterator = BatchIterator(batch_size=args.batch_size) evaluator = AccEvaluator() loss_list = list() for epoch in range(args.num_ep): t_start = time.time() for batch in iterator(train_x, train_y): pred = model.forward(batch.inputs) loss, grads = model.backward(pred, batch.targets) model.apply_grad(grads) loss_list.append(loss) print("Epoch %d time cost: %.4f" % (epoch, time.time() - t_start)) for timer in model.timers.values(): timer.report() # evaluate model.set_phase("TEST") test_y_idx = np.asarray(test_y).reshape(-1) test_pred = model.forward(test_x) test_pred[test_pred > 0] = 1 test_pred[test_pred <= 0] = 0 test_pred_idx = test_pred.reshape(-1) res = evaluator.evaluate(test_pred_idx, test_y_idx) print(res) model.set_phase("TRAIN")
def main(args): train_set, valid_set, test_set = prepare_dataset(args.data_dir) train_x, train_y = train_set test_x, test_y = test_set train_y = get_one_hot(train_y, 10) if args.model_type == "cnn": train_x = train_x.reshape((-1, 28, 28, 1)) test_x = test_x.reshape((-1, 28, 28, 1)) if args.model_type == "cnn": net = Net([ Conv2D(kernel=[5, 5, 1, 8], stride=[2, 2], padding="SAME"), ReLU(), Conv2D(kernel=[5, 5, 8, 16], stride=[2, 2], padding="SAME"), ReLU(), Conv2D(kernel=[5, 5, 16, 32], stride=[2, 2], padding="SAME"), ReLU(), Flatten(), Dense(10) ]) elif args.model_type == "dense": net = Net([ Dense(200), ReLU(), Dense(100), ReLU(), Dense(70), ReLU(), Dense(30), ReLU(), Dense(10) ]) else: raise ValueError( "Invalid argument model_type! Must be 'cnn' or 'dense'") model = Model(net=net, loss=SoftmaxCrossEntropyLoss(), optimizer=Adam(lr=args.lr)) iterator = BatchIterator(batch_size=args.batch_size) evaluator = AccEvaluator() loss_list = list() for epoch in range(args.num_ep): t_start = time.time() for batch in iterator(train_x, train_y): pred = model.forward(batch.inputs) loss, grads = model.backward(pred, batch.targets) model.apply_grad(grads) loss_list.append(loss) print("Epoch %d time cost: %.4f" % (epoch, time.time() - t_start)) # evaluate model.set_phase("TEST") test_pred = model.forward(test_x) test_pred_idx = np.argmax(test_pred, axis=1) test_y_idx = np.asarray(test_y) res = evaluator.evaluate(test_pred_idx, test_y_idx) print(res) model.set_phase("TRAIN")
def main(args): if args.seed >= 0: random_seed(args.seed) # data preparing data_path = os.path.join(args.data_dir, args.file_name) train_x, train_y, img_shape = prepare_dataset(data_path) net = Net([ Dense(30), ReLU(), Dense(60), ReLU(), Dense(60), ReLU(), Dense(30), ReLU(), Dense(3), Sigmoid() ]) model = Model(net=net, loss=MSELoss(), optimizer=Adam()) mse_evaluator = MSEEvaluator() iterator = BatchIterator(batch_size=args.batch_size) for epoch in range(args.num_ep): t_start = time.time() for batch in iterator(train_x, train_y): preds = model.forward(batch.inputs) loss, grads = model.backward(preds, batch.targets) model.apply_grad(grads) # evaluate preds = net.forward(train_x) mse = mse_evaluator.evaluate(preds, train_y) print(mse) if args.paint: # generate painting preds = preds.reshape(img_shape[0], img_shape[1], -1) preds = (preds * 255.0).astype("uint8") filename, ext = os.path.splitext(args.file_name) output_filename = "output" + ext output_path = os.path.join(args.data_dir, output_filename) Image.fromarray(preds).save(output_path) print("Epoch %d time cost: %.2f" % (epoch, time.time() - t_start))
def main(args): if args.seed >= 0: random_seed(args.seed) # data preparing train_x, train_y, img_shape = prepare_dataset(args.img) net = Net([ Dense(30), ReLU(), Dense(100), ReLU(), Dense(100), ReLU(), Dense(30), ReLU(), Dense(3), Sigmoid() ]) model = Model(net=net, loss=MSE(), optimizer=Adam()) iterator = BatchIterator(batch_size=args.batch_size) for epoch in range(args.num_ep): for batch in iterator(train_x, train_y): preds = model.forward(batch.inputs) loss, grads = model.backward(preds, batch.targets) model.apply_grad(grads) # evaluate preds = net.forward(train_x) mse = mean_square_error(preds, train_y) print("Epoch %d %s" % (epoch, mse)) # generate painting if epoch % 5 == 0: preds = preds.reshape(img_shape[0], img_shape[1], -1) preds = (preds * 255.0).astype("uint8") name, ext = os.path.splitext(args.img) filename = os.path.basename(name) out_filename = filename + "-paint-epoch" + str(epoch) + ext if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) out_path = os.path.join(args.output_dir, out_filename) Image.fromarray(preds).save(out_path) print("save painting to %s" % out_path)
def test_parameters_change(fake_dataset): # make sure the parameters does change after apply gradients # fake dataset X, y = fake_dataset # simple model net = Net([Dense(10), Dense(1)]) loss = MSE() opt = SGD(lr=1.0) model = Model(net, loss, opt) # forward and backward pred = model.forward(X) loss, grads = model.backward(pred, y) # parameters change test params_before = model.net.params.values model.apply_grad(grads) params_after = model.net.params.values for p1, p2 in zip(params_before, params_after): assert np.all(p1 != p2)
def main(args): train_set, valid_set, test_set = prepare_dataset(args.data_dir) train_x, train_y = train_set test_x, test_y = test_set train_y = get_one_hot(train_y, 10) net = Net([ Dense(784, 200), ReLU(), Dense(200, 100), ReLU(), Dense(100, 70), ReLU(), Dense(70, 30), ReLU(), Dense(30, 10) ]) model = Model(net=net, loss=SoftmaxCrossEntropyLoss(), optimizer=Adam(lr=args.lr)) iterator = BatchIterator(batch_size=args.batch_size) evaluator = AccEvaluator() loss_list = list() for epoch in range(args.num_ep): t_start = time.time() for batch in iterator(train_x, train_y): pred = model.forward(batch.inputs) loss, grads = model.backward(pred, batch.targets) model.apply_grad(grads) loss_list.append(loss) t_end = time.time() # evaluate test_pred = model.forward(test_x) test_pred_idx = np.argmax(test_pred, axis=1) test_y_idx = np.asarray(test_y) res = evaluator.evaluate(test_pred_idx, test_y_idx) print("Epoch %d time cost: %.4f\t %s" % (epoch, t_end - t_start, res))
class DQN(object): def __init__(self, env, args): self.args = args # Init replay buffer self.replay_buffer = deque(maxlen=args.buffer_size) # Init parameters self.global_step = 0 self.epsilon = args.init_epsilon self.state_dim = env.observation_space.shape[0] self.action_dim = env.action_space.n self.gamma = args.gamma self.learning_rate = args.lr self.batch_size = args.batch_size self.target_network_update_interval = args.target_network_update def build_net(self): q_net = Net([Dense(100), ReLU(), Dense(self.action_dim)]) return q_net def construct_model(self): self.q_net = self.build_net() self.model = Model(net=self.q_net, loss=MSELoss(), optimizer=RMSProp(self.args.lr)) # Target network self.target_q_net = self.build_net() self.target_q_net.initialize() def sample_action(self, state, policy): self.global_step += 1 # Q value of all actions output_q = self.model.forward([state])[0] if policy == "egreedy": if random.random() <= self.epsilon: # random action return random.randint(0, self.action_dim - 1) else: # greedy action return np.argmax(output_q) elif policy == "greedy": return np.argmax(output_q) elif policy == "random": return random.randint(0, self.action_dim - 1) def learn(self, state, action, reward, next_state, done): onehot_action = np.zeros(self.action_dim) onehot_action[action] = 1 # Store experience in deque self.replay_buffer.append( np.array([state, onehot_action, reward, next_state, done])) if len(self.replay_buffer) > self.batch_size: self.update_model() def update_model(self): if self.global_step % self.target_network_update_interval == 0: # Update target network. Assign params in q_net to target_q_net q_net_params = self.q_net.get_parameters() self.target_q_net.set_parameters(q_net_params) # Sample experience minibatch = random.sample(self.replay_buffer, self.batch_size) # Transpose minibatch s_batch, a_batch, r_batch, next_s_batch, done_batch = \ np.array(minibatch).T.tolist() next_s_all_action_Q = self.target_q_net.forward(next_s_batch) next_s_Q_batch = np.max(next_s_all_action_Q, 1) # Calculate target_Q_batch target_Q_batch = [] for i in range(self.batch_size): done_state = done_batch[i] if done_state: target_Q_batch.append(r_batch[i]) else: target_Q_batch.append(r_batch[i] + self.gamma * next_s_Q_batch[i]) # Train the network preds = self.model.forward(np.asarray(s_batch)) preds = np.multiply(preds, a_batch) targets = np.reshape(target_Q_batch, (-1, 1)) targets = np.tile(targets, (1, 2)) targets = np.multiply(targets, a_batch) loss, grads = self.model.backward(preds, targets) self.model.apply_grad(grads)
def main(args): if args.seed >= 0: random_seed(args.seed) train_set, valid_set, test_set = mnist(args.data_dir) train_x, train_y = train_set test_x, test_y = test_set train_y = get_one_hot(train_y, 10) if args.model_type == "cnn": train_x = train_x.reshape((-1, 28, 28, 1)) test_x = test_x.reshape((-1, 28, 28, 1)) if args.model_type == "cnn": # a LeNet-5 model with activation function changed to ReLU net = Net([ Conv2D(kernel=[5, 5, 1, 6], stride=[1, 1], padding="SAME"), ReLU(), MaxPool2D(pool_size=[2, 2], stride=[2, 2]), Conv2D(kernel=[5, 5, 6, 16], stride=[1, 1], padding="SAME"), ReLU(), MaxPool2D(pool_size=[2, 2], stride=[2, 2]), Flatten(), Dense(120), ReLU(), Dense(84), ReLU(), Dense(10) ]) elif args.model_type == "dense": net = Net([ Dense(200), ReLU(), Dense(100), ReLU(), Dense(70), ReLU(), Dense(30), ReLU(), Dense(10) ]) else: raise ValueError("Invalid argument: model_type") model = Model(net=net, loss=SoftmaxCrossEntropy(), optimizer=Adam(lr=args.lr)) iterator = BatchIterator(batch_size=args.batch_size) loss_list = list() for epoch in range(args.num_ep): t_start = time.time() for batch in iterator(train_x, train_y): pred = model.forward(batch.inputs) loss, grads = model.backward(pred, batch.targets) model.apply_grad(grads) loss_list.append(loss) print("Epoch %d time cost: %.4f" % (epoch, time.time() - t_start)) # evaluate model.set_phase("TEST") test_pred = model.forward(test_x) test_pred_idx = np.argmax(test_pred, axis=1) test_y_idx = np.asarray(test_y) res = accuracy(test_pred_idx, test_y_idx) print(res) model.set_phase("TRAIN")
def train(args): # prepare dataset train_, valid, test = mnist(args.data_dir) X = np.concatenate([train_[0], valid[0], test[0]]) y = np.concatenate([train_[1], valid[1], test[1]]) fix_noise = get_noise(size=(args.batch_size, args.nz)) loss = SigmoidCrossEntropy() # TODO: replace mlp with cnn G = Model(net=mlp_G(), loss=loss, optimizer=Adam(args.lr_g, beta1=args.beta1)) D = Model(net=mlp_D(), loss=loss, optimizer=Adam(args.lr_d, beta1=args.beta1)) running_g_err, running_d_err = 0, 0 iterator = BatchIterator(batch_size=args.batch_size) for epoch in range(args.num_ep): for i, batch in enumerate(iterator(X, y)): # --- Train Discriminator --- # feed with real data (maximize log(D(x))) d_pred_real = D.forward(batch.inputs) label_real = np.ones_like(d_pred_real) d_real_err, d_real_grad = D.backward(d_pred_real, label_real) # feed with fake data (maximize log(1 - D(G(z)))) noise = get_noise(size=(len(batch.inputs), args.nz)) g_out = G.forward(noise) d_pred_fake = D.forward(g_out) label_fake = np.zeros_like(d_pred_fake) d_fake_err, d_fake_grad = D.backward(d_pred_fake, label_fake) # train D d_err = d_real_err + d_fake_err d_grads = d_real_grad + d_fake_grad D.apply_grad(d_grads) # ---- Train Generator --- # maximize log(D(G(z))) d_pred_fake = D.forward(g_out) g_err, d_grad = D.backward(d_pred_fake, label_real) g_grads = G.net.backward(d_grad.wrt_input) G.apply_grad(g_grads) running_d_err = 0.9 * running_d_err + 0.1 * d_err running_g_err = 0.9 * running_g_err + 0.1 * g_err if i % 100 == 0: print("epoch-%d iter-%d d_err: %.4f g_err: %.4f" % (epoch + 1, i + 1, running_d_err, running_g_err)) # sampling print("epoch: %d/%d d_err: %.4f g_err: %.4f" % (epoch + 1, args.num_ep, running_d_err, running_g_err)) samples = G.forward(fix_noise) img_name = "ep%d.png" % (epoch + 1) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) save_path = os.path.join(args.output_dir, img_name) save_batch_as_images(save_path, samples) # save generator model_path = os.path.join(args.output_dir, args.model_name) G.save(model_path) print("Saving generator ", model_path)