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