def get_ddqn(env):
rda = RandomAgent(env)
q_func = QFunction()
opt = Adam(alpha=1e-3)
opt.setup(q_func)
opt.add_hook(optim.GradientClipping(1.0), 'hook')
rbuf = PrioritizedEpisodicReplayBuffer(5 * 10**5)
explorer = LinearDecayEpsilonGreedy(start_epsilon=1.0,
end_epsilon=0.3,
decay_steps=10000,
random_action_func=rda.random_action)
agent = DoubleDQN(q_func,
opt,
rbuf,
gamma=0.995,
explorer=explorer,
replay_start_size=500,
target_update_interval=1,
target_update_method='soft',
update_interval=4,
soft_update_tau=1e-2,
n_times_update=1,
gpu=0,
minibatch_size=128)
return agent
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model", default=None)
parser.add_argument("--gpu", type=int, default=0)
parser.add_argument("--batch_size", type=int, default=4)
parser.add_argument("--data_dir", type=str, default="./datasets")
parser.add_argument("--data_list", type=str, default="train.txt")
parser.add_argument("--n_class", type=int, default=5)
parser.add_argument("--n_steps", type=int, default=100)
parser.add_argument("--snapshot_dir", type=str, default="./snapshots")
parser.add_argument("--save_steps", type=int, default=50)
args = parser.parse_args()
print(args)
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
model = RefineResNet(n_class=args.n_class)
if args.model is not None:
serializers.load_npz(args.model, model)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
xp = cuda.cupy
else:
xp = np
optimizer = Adam()
#optimizer = MomentumSGD()
optimizer.setup(model)
optimizer.add_hook(WeightDecay(1e-5), "hook_wd")
train_dataset = ImageDataset(args.data_dir,
args.data_list,
crop_size=(320, 320))
train_iterator = MultiprocessIterator(train_dataset,
batch_size=args.batch_size,
repeat=True,
shuffle=True)
step = 0
for zipped_batch in train_iterator:
step += 1
x = Variable(xp.array([zipped[0] for zipped in zipped_batch]))
y = Variable(
xp.array([zipped[1] for zipped in zipped_batch], dtype=xp.int32))
pred = xp.array(model(x).data, dtype=xp.float32)
loss = F.softmax_cross_entropy(pred, y)
optimizer.update(F.softmax_cross_entropy, pred, y)
print("Step: {}, Loss: {}".format(step, loss.data))
if step % args.save_steps == 0:
serializers.save_npz(
os.path.join(args.snapshot_dir, "model_{}.npz".format(step)),
model)
if step >= args.n_steps:
break
def _setup_optimizer(config, model, comm):
optimizer_name = config['optimizer']
lr = float(config['init_lr'])
weight_decay = float(config['weight_decay'])
if optimizer_name == 'Adam':
optimizer = Adam(alpha=lr, weight_decay_rate=weight_decay)
elif optimizer_name in \
('SGD', 'MomentumSGD', 'CorrectedMomentumSGD', 'RMSprop'):
optimizer = eval(optimizer_name)(lr=lr)
if weight_decay > 0.:
optimizer.add_hook(WeightDecay(weight_decay))
else:
raise ValueError('Invalid optimizer: {}'.format(optimizer_name))
if comm is not None:
optimizer = chainermn.create_multi_node_optimizer(optimizer, comm)
optimizer.setup(model)
return optimizer
loss = 0
average_loss = []
accuracy_list = []
epochs = 50
batch_size = 128
num_data = len(train_x)
model = Seq2Seq(
vocab_size=len(vocab),
embed_size=512,
hidden_size=512,
)
optimizer = Adam()
optimizer.setup(model)
optimizer.add_hook(GradientClipping(5))
for c, i in vocab.items():
tmp_vocab[i] = c
# timer
start_at = time.time()
cur_at = start_at
# エポックを回す
for epoch in range(0, epochs):
print('EPOCH: {}/{}'.format(epoch+1, epochs))
perm = np.random.permutation(num_data) # ランダムサンプリング
# ミニバッチ単位で回す
loss = 0 gen_loss = [] dis_loss = [] n_train_data = len(train_x) # ハイパーパラメータ epochs = 1 batch_size = 100 n_hidden = 100 # Generator generator = Generator(n_hidden=n_hidden) opt_gen = Adam() opt_gen.setup(generator) opt_gen.add_hook(GradientClipping(5)) loss_gen = 0 # Discriminator discriminator = Discriminator() opt_dis = Adam() opt_dis.setup(discriminator) opt_dis.add_hook(GradientClipping(5)) loss_dis = 0 # time start_at = time.time() cur_at = start_at # エポックを回す for epoch in range(0, epochs):
def train(opt):
if opt.use_cpu:
device = -1
print('[Message] use CPU')
else:
device = 0
print('[Message] use GPU0')
annotated = get_dataset(opt)
unlabeled = get_unlabel_dataset(opt)
print('[Message] loaded options')
train_iter = SerialIterator(annotated, opt.batch_size, shuffle=True)
print('[Message] converted to iterator (train)')
semi_iter = SerialIterator(unlabeled, opt.batch_size, shuffle=True)
print('[Message] converted to iterator (semi)')
gen = ResNetDeepLab(opt)
#gen = DilatedFCN(opt)
#gen = UNet(opt)
if device != -1:
gen.to_gpu(device) #use GPU
g_optim = Adam(alpha=opt.g_lr, beta1=opt.g_beta1, beta2=opt.g_beta2)
g_optim.setup(gen)
if opt.g_weight_decay > 0:
g_optim.add_hook(WeightDecay(opt.g_weight_decay))
print('[Message] setuped Generator')
dis = FCN(opt)
if device != -1:
dis.to_gpu(device) #use GPU
d_optim = Adam(alpha=opt.d_lr, beta1=opt.d_beta1, beta2=opt.d_beta2)
d_optim.setup(dis)
print('[Message] setuped Discriminator')
updater = AdvSemiSeg_Updater(opt,
iterator={
'main': train_iter,
'semi': semi_iter
},
optimizer={
'gen': g_optim,
'dis': d_optim
},
device=device)
print('[Message] initialized Updater')
trainer = Trainer(updater, (opt.max_epoch, 'epoch'), out=opt.out_dir)
print('[Message] initialized Trainer')
#chainer training extensions
trainer.extend(ex.LogReport(log_name=None, trigger=(1, 'iteration')))
trainer.extend(ex.ProgressBar((opt.max_epoch, 'epoch'), update_interval=1))
trainer.extend(
ex.PlotReport(['gen/adv_loss', 'dis/adv_loss', 'gen/semi_adv_loss'],
x_key='iteration',
file_name='adversarial_loss.png',
trigger=(100, 'iteration')))
#test
trainer.extend(
ex.PlotReport(['gen/adv_loss'],
x_key='iteration',
file_name='adv_gen_loss.png',
trigger=(100, 'iteration')))
trainer.extend(
ex.PlotReport(['gen/ce_loss'],
x_key='iteration',
file_name='cross_entropy_loss.png',
trigger=(100, 'iteration')))
trainer.extend(
ex.PlotReport(['gen/semi_st_loss'],
x_key='iteration',
file_name='self_teach_loss.png',
trigger=(100, 'iteration')))
trainer.extend(
ex.PlotReport(['gen/loss', 'dis/loss', 'gen/semi_loss'],
x_key='iteration',
file_name='loss.png',
trigger=(100, 'iteration')))
trainer.extend(
ex.PlotReport(['gen/loss', 'dis/loss', 'gen/semi_loss'],
x_key='epoch',
file_name='loss_details.png',
trigger=(5, 'epoch')))
trainer.extend(
ex.PlotReport(['gen/semi_loss'],
x_key='epoch',
file_name='semi_loss.png',
trigger=(1, 'epoch')))
#snap
trainer.extend(ex.snapshot_object(
gen, 'gen_snapshot_epoch-{.updater.epoch}.npz'),
trigger=(opt.snap_interval_epoch, 'epoch'))
trainer.extend(ex.snapshot_object(
dis, 'dis_snapshot_epoch-{.updater.epoch}.npz'),
trigger=(opt.snap_interval_epoch, 'epoch'))
trainer.extend(lambda *args: updater.save_img(),
trigger=(opt.img_interval_iteration, 'iteration'),
priority=PRIORITY_READER)
trainer.extend(lambda *args: updater.ignition_semi_learning(),
trigger=(opt.semi_ignit_iteration, 'iteration'),
priority=PRIORITY_READER)
trainer.extend(lambda *args: adam_lr_poly(opt, trainer),
trigger=(100, 'iteration'))
print('[Message] initialized extension')
print('[Message] start training ...')
trainer.run() #start learning
def main(args):
args = prepare_log_dir(args)
# set dtype for training
chainer.global_config.dtype = args.dtype
train_dataset = BaseImageDataset(
args.train_file,
args.image_size,
root=os.path.dirname(args.train_file),
dtype=chainer.get_dtype(),
)
validation_dataset = BaseImageDataset(
args.val_file,
args.image_size,
root=os.path.dirname(args.val_file),
dtype=chainer.get_dtype(),
)
train_iter = MultiprocessIterator(train_dataset, batch_size=args.batch_size, shuffle=True)
validation_iter = MultiprocessIterator(validation_dataset, batch_size=args.batch_size, repeat=False)
net = HandwritingNet()
model = L.Classifier(net, label_key='has_text')
tensorboard_handle = SummaryWriter(log_dir=args.log_dir)
optimizer = Adam(alpha=args.learning_rate)
optimizer.setup(model)
if args.save_gradient_information:
optimizer.add_hook(
TensorboardGradientPlotter(tensorboard_handle, args.log_interval),
)
# log train information everytime we encouter a new epoch or args.log_interval iterations have been done
log_interval_trigger = (
lambda trainer:
(trainer.updater.is_new_epoch or trainer.updater.iteration % args.log_interval == 0)
and trainer.updater.iteration > 0
)
updater = StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = Trainer(updater, (args.num_epoch, 'epoch'), out=args.log_dir)
data_to_log = {
'log_dir': args.log_dir,
'image_size': args.image_size,
# 'num_layers': args.num_layers,
'keep_aspect_ratio': train_dataset.keep_aspect_ratio,
'net': get_import_info(net),
}
for argument in filter(lambda x: not x.startswith('_'), dir(args)):
data_to_log[argument] = getattr(args, argument)
def backup_train_config(stats_cpu):
iteration = stats_cpu.pop('iteration')
epoch = stats_cpu.pop('epoch')
elapsed_time = stats_cpu.pop('elapsed_time')
for key, value in stats_cpu.items():
tensorboard_handle.add_scalar(key, value, iteration)
if iteration == args.log_interval:
stats_cpu.update(data_to_log)
stats_cpu.update({
"epoch": epoch,
"iteration": iteration,
"elapsed_time": elapsed_time,
})
trainer.extend(
extensions.snapshot_object(net, net.__class__.__name__ + '_{.updater.iteration}.npz'),
trigger=lambda trainer: trainer.updater.is_new_epoch or trainer.updater.iteration % args.snapshot_interval == 0,
)
trainer.extend(
extensions.snapshot(filename='trainer_snapshot', autoload=args.resume is not None),
trigger=(args.snapshot_interval, 'iteration')
)
trainer.extend(
TensorboardEvaluator(
validation_iter,
model,
device=args.gpu,
tensorboard_handle=tensorboard_handle
),
trigger=(args.test_interval, 'iteration'),
)
logger = Logger(
os.path.dirname(os.path.realpath(__file__)),
args.log_dir,
postprocess=backup_train_config,
trigger=log_interval_trigger,
exclusion_filters=['*logs*', '*.pyc', '__pycache__', '.git*'],
resume=args.resume is not None,
)
trainer.extend(logger, trigger=log_interval_trigger)
trainer.extend(
extensions.PrintReport(
['epoch', 'iteration', 'main/loss', 'main/accuracy', 'validation/main/accuracy'],
log_report='Logger',
),
trigger=log_interval_trigger,
)
trainer.extend(extensions.ExponentialShift('alpha', 0.1, optimizer=optimizer), trigger=(10, 'epoch'))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.run()
loss = 0 gen_loss = [] dis_loss = [] n_train_data = len(train_x) # ハイパーパラメータ epochs = 1 batch_size = 100 n_hidden = 100 # Generator generator = Generator(n_hidden=n_hidden) opt_gen = Adam() opt_gen.setup(generator) opt_gen.add_hook(GradientClipping(5)) loss_gen = 0 # Discriminator discriminator = Discriminator() opt_dis = Adam() opt_dis.setup(discriminator) opt_dis.add_hook(GradientClipping(5)) loss_dis = 0 # time start_at = time.time() cur_at = start_at # エポックを回す for epoch in range(0, epochs):
