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))
