def main(args): if args.seed >= 0: random_seed(args.seed) if args.train: train(args) if args.evaluate: evaluate(args)
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_grads(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 main(args): if args.seed >= 0: random_seed(args.seed) dataset = prepare_dataset(args.data_dir) if args.train_teacher: model = Model(net=teacher_net, loss=SoftmaxCrossEntropy(), optimizer=Adam(lr=args.lr)) train_single_model(model, dataset, args, name="teacher") if args.train_student: model = Model(net=student_net, loss=SoftmaxCrossEntropy(), optimizer=Adam(lr=args.lr)) train_single_model(model, dataset, args, name="student") train_distill_model(dataset, args)
def main(): if args.seed >= 0: random_seed(args.seed) # data preparation train_set, valid_set, test_set = mnist(args.data_dir, one_hot=True) # init ray ray.init() # init model model = get_model(args.lr) # init parameter server and workers ps = ParamServer.remote(model=copy.deepcopy(model), test_set=test_set) workers = [] for rank in range(1, args.num_workers + 1): worker = Worker.remote(model=copy.deepcopy(model), train_set=train_set) workers.append(worker) start_time = time.time() iter_each_epoch = len(train_set[0]) // args.batch_size + 1 iterations = args.num_ep * iter_each_epoch if args.mode == "async": print("Run asynchronous training.") # Workers repeatedly fetch global parameters, train one batch locally # and send their local gradients to the parameter server. # The parameter server updates global parameters once it receives # gradients from any workers. for i in range(iterations): global_params = ps.get_params.remote() for worker in workers: worker.set_params.remote(global_params) # compute local grads grads = worker.compute_grads.remote() # update global model asynchronously ps.apply_grads.remote(grads) # evaluate model.net.params = ray.get(ps.get_params.remote()) acc = evaluate(test_set, model) print("[%.2fs] accuracy after %d iterations: \n %s" % (time.time() - start_time, i + 1, acc)) elif args.mode == "sync": print("Run synchronous training.") # In each iteration, workers request for the global model, # compute local gradients and then send to the parameter server. # The parameter server gathers grads from all workers, # updates the global model and broadcasts to workers synchronously. for i in range(iterations): all_grads = [] global_params = ps.get_params.remote() for worker in workers: # grab global params worker.set_params.remote(global_params) # compute local grads grads = worker.compute_grads.remote() all_grads.append(grads) # gathers grads from all workers all_grads = ray.get(all_grads) # update global model ps.apply_grads.remote(sum(all_grads)) # evaluate model.net.params = ray.get(ps.get_params.remote()) acc = evaluate(test_set, model) print("[%.2fs] accuracy after %d iterations: \n %s" % (time.time() - start_time, i + 1, acc)) else: raise ValueError("Invalid train mode. Suppose to be 'sync' or 'async'.")
"""test unit for core/initializer.py""" import runtime_path # isort:skip from tinynn.core.initializer import * from tinynn.utils.seeder import random_seed random_seed(0) TEST_SHAPE = (100000, 1) TOR = 1e-2 def test_get_fans(): fan_in, fan_out = get_fans(shape=(100, 10)) assert fan_in == 100 and fan_out == 10 fan_in, fan_out = get_fans(shape=(64, 5, 5, 128)) assert fan_in == 5 * 5 * 128 assert fan_out == 64 def test_normal_init(): val = Normal(mean=0.0, std=1.0).init(TEST_SHAPE) assert -TOR <= val.mean() <= TOR assert 1.0 - TOR <= val.std() <= 1.0 + TOR def test_truncated_normal_init(): val = TruncatedNormal(mean=0.0, std=1.0).init(TEST_SHAPE) assert -TOR <= val.mean() <= TOR
def main(args): env = gym.make("CartPole-v0") if args.seed >= 0: random_seed(args.seed) env.seed(args.seed) agent = DQN(env, args) model = get_model(out_dim=env.action_space.n, lr=args.lr) agent.set_model(model) rewards_history, steps_history = [], [] train_steps = 0 # Training for ep in range(args.max_ep): state = env.reset() ep_rewards = 0 for step in range(env.spec.timestep_limit): # sample action action = agent.sample_action(state, policy="egreedy") # apply action next_state, reward, done, debug = env.step(action) train_steps += 1 ep_rewards += reward # modified reward to speed up learning reward = 0.1 if not done else -1 # train agent.train(state, action, reward, next_state, done) state = next_state if done: break steps_history.append(train_steps) if not rewards_history: rewards_history.append(ep_rewards) else: rewards_history.append(rewards_history[-1] * 0.9 + ep_rewards * 0.1) # Decay epsilon if agent.epsilon > args.final_epsilon: decay = (args.init_epsilon - args.final_epsilon) / args.max_ep agent.epsilon -= decay # Evaluate during training if ep % args.log_every == args.log_every - 1: total_reward = 0 for i in range(args.test_ep): state = env.reset() for j in range(env.spec.timestep_limit): if args.render: env.render() action = agent.sample_action(state, policy="greedy") state, reward, done, _ = env.step(action) total_reward += reward if done: break current_mean_rewards = total_reward / args.test_ep print("Episode: %d Average Reward: %.2f" % (ep + 1, current_mean_rewards)) # plot training rewards plt.plot(steps_history, rewards_history) plt.xlabel("steps") plt.ylabel("running avg rewards") plt.show()
def test_random_seed(): with pytest.raises(ValueError): random_seed(2**32 + 1)
def main(args): if args.seed >= 0: random_seed(args.seed) train_set, _, test_set = mnist(args.data_dir, one_hot=True) train_x, train_y = train_set test_x, test_y = test_set if args.model_type == "mlp": # A multilayer perceptron model net = Net([ Dense(200), ReLU(), Dense(100), ReLU(), Dense(70), ReLU(), Dense(30), ReLU(), Dense(10) ]) elif args.model_type == "cnn": # A LeNet-5 model with activation function changed to ReLU train_x = train_x.reshape((-1, 28, 28, 1)) test_x = test_x.reshape((-1, 28, 28, 1)) net = Net([ Conv2D(kernel=[5, 5, 1, 6], stride=[1, 1]), ReLU(), MaxPool2D(pool_size=[2, 2], stride=[2, 2]), Conv2D(kernel=[5, 5, 6, 16], stride=[1, 1]), ReLU(), MaxPool2D(pool_size=[2, 2], stride=[2, 2]), Flatten(), Dense(120), ReLU(), Dense(84), ReLU(), Dense(10) ]) elif args.model_type == "rnn": # A simple recurrent neural net to classify images. train_x = train_x.reshape((-1, 28, 28)) test_x = test_x.reshape((-1, 28, 28)) net = Net([RNN(num_hidden=50, activation=Tanh()), 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_grads(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.argmax(test_y, axis=1) res = accuracy(test_pred_idx, test_y_idx) print(res) model.set_phase("TRAIN") # save model if not os.path.isdir(args.model_dir): os.makedirs(args.model_dir) model_name = "mnist-%s-epoch%d.pkl" % (args.model_type, args.num_ep) model_path = os.path.join(args.model_dir, model_name) model.save(model_path) print("model saved in %s" % model_path)
def main(args): if args.seed >= 0: random_seed(args.seed) # create output directory for saving result images if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) # prepare and read dataset train_set, _, test_set = mnist(args.data_dir) train_x, train_y = train_set test_x, test_y = test_set # specify the encoder and decoder net structure encoder_net = Net([ Dense(256), ReLU(), Dense(64) ]) decoder_net = Net([ ReLU(), Dense(256), Tanh(), Dense(784), Tanh() ]) nets = (encoder_net, decoder_net) optimizers = (Adam(args.lr), Adam(args.lr)) model = AutoEncoder(nets, loss=MSE(), optimizer=optimizers) # for pre-trained model, test generated images from latent space if args.load_model is not None: # load pre-trained model model.load(os.path.join(args.output_dir, args.load_model)) print("Loaded model fom %s" % args.load_model) # transition from test[from_idx] to test[to_idx] in n steps idx_arr, n = [2, 4, 32, 12, 82], 160 print("Transition in numbers", [test_y[i] for i in idx_arr], "in %d steps ..." % n) stops = [model.en_net.forward(test_x[i]) for i in idx_arr] k = int(n / (len(idx_arr) - 1)) # number of code per transition # generate all transition codes code_arr = [] for i in range(len(stops) - 1): t = [c.copy() for c in transition(stops[i], stops[i+1], k)] code_arr += t # apply decoding all n "code" from latent space... batch = None for code in code_arr: # translate latent space to image genn = model.de_net.forward(code) # save decoded results in a batch if batch is None: batch = np.array(genn) else: batch = np.concatenate((batch, genn)) output_path = os.path.join(args.output_dir, "genn-latent.png") save_batch_as_images(output_path, batch) quit() # train the auto-encoder iterator = BatchIterator(batch_size=args.batch_size) for epoch in range(args.num_ep): for batch in iterator(train_x, train_y): origin_in = batch.inputs # make noisy inputs m = origin_in.shape[0] # batch size mu = args.gaussian_mean # mean sigma = args.gaussian_std # standard deviation noises = np.random.normal(mu, sigma, (m, 784)) noises_in = origin_in + noises # noisy inputs # forward genn = model.forward(noises_in) # back-propagate loss, grads = model.backward(genn, origin_in) # apply gradients model.apply_grads(grads) print("Epoch: %d Loss: %.3f" % (epoch, loss)) # save all the generated images and original inputs for this batch noises_in_path = os.path.join( args.output_dir, "ep%d-input.png" % epoch) genn_path = os.path.join( args.output_dir, "ep%d-genn.png" % epoch) save_batch_as_images(noises_in_path, noises_in, titles=batch.targets) save_batch_as_images(genn_path, genn, titles=batch.targets) # save the model after training model.save(os.path.join(args.output_dir, args.save_model))