def main():
# data
train, test = get_mnist(withlabel=False)
n_x = train.shape[1]
# model
model = create_sample_model(n_x)
n_batch = 256
train_iter = SerialIterator(train, n_batch)
# TODO: report test loss
# test_iter = SerialIterator(test, n_batch)
optimizer = Adam()
optimizer.setup(model)
gpu = 0
updater = StandardUpdater(train_iter, optimizer, device=gpu)
n_epoch = 50
trainer = Trainer(updater, (n_epoch, 'epoch'))
trainer.extend(
snapshot_object(
model, filename='snapshot_epoch_{.updater.epoch:03d}.npz'),
trigger=(1, 'epoch'))
trainer.extend(LogReport())
trainer.extend(PrintReport([
'epoch', 'main/loss', 'main/iaf_loss', 'main/rec_loss',
]))
trainer.run()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--device', type=int, default=0, help='gpu id')
parser.add_argument('--modelfile', help='pretrained model file of FCN8', required=True)
parser.add_argument('--lr', type=float, default=5e-5, help='init learning rate')
parser.add_argument('--name', type=str, default='FCN8_SEG', help='name of the experiment')
parser.add_argument('--resume', type=bool, default=False, help='resume training or not')
parser.add_argument('--snapshot', type=str, help='snapshot file to resume from')
parser.add_argument('--lambda1', default=1, type=float, help='lambda1 param')
parser.add_argument('--lambda2', default=1, type=float, help='lambda2 param')
parser.add_argument('--lambda3', default=1.5, type=float, help='lambda3 param')
#total_loss = self.lambd1 * cl_loss + self.lambd2 * am_loss + self.lambd3*segment_loss
args = parser.parse_args()
resume = args.resume
device = args.device
if resume:
load_snapshot_path = args.snapshot
load_model_path = args.modelfile
print("Resuming from model {}, snapshot {}".format(load_model_path, load_snapshot_path))
else:
pretrained_model_path = args.modelfile
experiment = args.name
lr = args.lr
optim = Adam
training_interval = (20000, 'iteration')
snapshot_interval = (1000, 'iteration')
lambd1 = args.lambda1
lambd2 = args.lambda2
lambd3 = args.lambda3
updtr = VOC_SEG_Updater_v2
os.makedirs('result/'+experiment, exist_ok=True)
f = open('result/'+experiment+'/details.txt', "w+")
f.write("lr - "+str(lr)+"\n")
f.write("optimizer - "+str(optim)+"\n")
f.write("lambd1 - "+str(lambd1)+"\n")
f.write("lambd2 - "+str(lambd2)+"\n")
f.write("lambd3 - "+str(lambd3)+"\n")
f.write("training_interval - "+str(training_interval)+"\n")
f.write("Updater - "+str(updtr)+"\n")
f.close()
if resume:
model = FCN8s_hand()
chainer.serializers.load_npz(load_model_path, model)
else:
model = FCN8s_hand()
chainer.serializers.load_npz(pretrained_model_path, model)
if device >= 0:
model.to_gpu(device)
dataset = MyTrainingDataset()
iterator = SerialIterator(dataset, 1, shuffle=False)
optimizer = Adam(alpha=lr)
optimizer.setup(model)
updater = updtr(iterator, optimizer, device=device, lambd1=lambd1, lambd2=lambd2)
trainer = Trainer(updater, training_interval)
log_keys = ['epoch', 'iteration', 'main/SG_Loss', 'main/TotalLoss']
trainer.extend(extensions.LogReport(log_keys, (10, 'iteration'), log_name='log'+experiment))
trainer.extend(extensions.PrintReport(log_keys), trigger=(100, 'iteration'))
trainer.extend(extensions.ProgressBar(training_length=training_interval, update_interval=100))
trainer.extend(extensions.snapshot(filename=experiment+'_snapshot_{.updater.iteration}'), trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(trainer.updater._optimizers['main'].target,
experiment+'_model_{.updater.iteration}'), trigger=snapshot_interval)
trainer.extend(
extensions.PlotReport(['main/SG_Loss'], 'iteration', (20, 'iteration'), file_name=experiment + '/sg_loss.png',grid=True, marker=" "))
trainer.extend(extensions.PlotReport(['main/TotalLoss'], 'iteration',(20, 'iteration'), file_name=experiment+'/total_loss.png', grid=True, marker=" "))
trainer.extend(extensions.PlotReport(log_keys[2:], 'iteration',(20, 'iteration'), file_name=experiment+'/all_loss.png', grid=True, marker=" "))
if resume:
chainer.serializers.load_npz(load_snapshot_path, trainer)
print("Running - - ", experiment)
print('initial lr ',lr)
print('optimizer ', optim)
print('lambd1 ', lambd1)
print('lambd2 ', lambd2)
print('lambd3', lambd3)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--out', default='result')
parser.add_argument('--n-epoch', type=int, default=30)
parser.add_argument('--gamma', type=float, default=1e-2)
parser.add_argument('--device', type=int, default=-1)
args = parser.parse_args()
dset = create_dataset(figpath=Path(args.out) / 'train.png')
iterator = SerialIterator(dset, batch_size=512, shuffle=True, repeat=True)
model = Model()
opt = Adam(alpha=args.gamma).setup(model)
initializer = UniformInitializer((512, 2))
sampler = LangevinSampler(initializer)
updater = MCMCMLLUpdater(sampler, iterator, opt, device=args.device)
trainer = Trainer(updater, (args.n_epoch, 'epoch'))
trainer.extend(plot_sample(sampler))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.observe_lr())
trainer.extend(
extensions.PrintReport(
['epoch', 'main/loss', 'main/logq', 'main/logp']))
trainer.run()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--device', type=int, default=-1, help='gpu id')
parser.add_argument('--lr_init',
type=float,
default=1 * 1e-7,
help='init learning rate')
# parser.add_argument('--lr_trigger', type=float, default=5, help='trigger to decreace learning rate')
# parser.add_argument('--lr_target', type=float, default=5*1e-5, help='target learning rate')
# parser.add_argument('--lr_factor', type=float, default=.75, help='decay factor')
parser.add_argument('--name',
type=str,
default='classifier_gain_dropout',
help='name of the experiment')
parser.add_argument(
'--modelfile',
type=str,
help='name of the model to resume from or if starting anew, the '
'pretrained FCN8s_Hand model with empty final layers',
required=True)
parser.add_argument('--resume',
type=bool,
default=False,
help='resume training or not')
parser.add_argument('--snapshot',
type=str,
default=None,
help='snapshot file of the trainer to resume from')
args = parser.parse_args()
if args.resume:
assert args.snapshot is not None
resume = args.resume
device = args.device
#os.environ["CUDA_VISIBLE_DEVICES"]=str(device)
if resume:
load_snapshot_path = args.snapshot
experiment = args.name
lr_init = args.lr_init
# lr_target = args.lr_target
# lr_factor = args.lr_factor
# lr_trigger_interval = (args.lr_trigger, 'epoch')
os.makedirs('result/' + experiment, exist_ok=True)
f = open('result/' + experiment + '/details.txt', "w+")
f.write("lr - " + str(lr_init) + "\n")
f.write("optimizer - " + str(Adam))
# f.write("lr_trigger_interval - "+str(lr_trigger_interval)+"\n")
f.close()
# if resume:
model_own = FCN8s_hand()
chainer.serializers.load_npz(args.modelfile, model_own)
if device >= 0:
print('sending model to gpu ' + str(device))
model_own.to_gpu(device)
dataset = MyTrainingDataset()
iterator = SerialIterator(dataset, 1)
optimizer = Adam(alpha=lr_init)
optimizer.setup(model_own)
updater = VOC_ClassificationUpdater_v2(iterator,
optimizer,
device=device,
dropout=0.5)
trainer = Trainer(updater, (100, 'epoch'))
log_keys = ['epoch', 'iteration', 'main/Loss']
trainer.extend(
extensions.LogReport(log_keys, (100, 'iteration'),
log_name='log_' + experiment))
trainer.extend(extensions.PrintReport(log_keys),
trigger=(100, 'iteration'))
trainer.extend(extensions.snapshot(filename=experiment +
"_snapshot_{.updater.iteration}"),
trigger=(1, 'epoch'))
trainer.extend(extensions.snapshot_object(
trainer.updater._optimizers['main'].target,
experiment + "_model_{.updater.iteration}"),
trigger=(1, 'epoch'))
trainer.extend(
extensions.PlotReport(['main/Loss'],
'iteration', (100, 'iteration'),
file_name=experiment + '/loss.png',
grid=True,
marker=" "))
# trainer.extend(extensions.ExponentialShift('lr', lr_factor, target=lr_target), trigger=lr_trigger_interval)
if resume:
chainer.serializers.load_npz(load_snapshot_path, trainer)
print("Running - - ", experiment)
print('initial lr ', lr_init)
# print('lr_trigger_interval ', lr_trigger_interval)
trainer.run()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--gpu', type=int, default=0, help='gpu id')
parser.add_argument('--modelfile', help='pretrained model file of FCN8')
parser.add_argument('--lr',
type=float,
default=5 * 1e-4,
help='init learning rate')
parser.add_argument('--name',
type=str,
default='exp',
help='init learning rate')
parser.add_argument('--resume',
type=int,
default=0,
help='resume training or not')
parser.add_argument('--snapshot',
type=str,
help='snapshot file to resume from')
args = parser.parse_args()
resume = args.resume
device = args.gpu
if resume:
load_snapshot_path = args.snapshot
load_model_path = args.modelfile
else:
load_model_path = args.modelfile
experiment = args.name
lr = args.lr
lr_trigger_interval = (5, 'epoch')
optim = Adam
os.makedirs('result/' + experiment, exist_ok=True)
f = open('result/' + experiment + '/details.txt', "w+")
f.write("lr - " + str(lr) + "\n")
f.write("optimizer - " + str(optim))
f.write("lr_trigger_interval - " + str(lr_trigger_interval) + "\n")
f.close()
if not resume:
# Add the FC layers to original FConvN for GAIN
model_own = FCN8s()
model_original = fcn.models.FCN8s()
model_file = fcn.models.FCN8s.download()
chainer.serializers.load_npz(model_file, model_original)
for layers in model_original._children:
setattr(model_own, layers, getattr(model_original, layers))
del (model_original, model_file)
else:
model_own = FCN8s()
chainer.serializers.load_npz(load_model_path, model_own)
if device >= 0:
model_own.to_gpu(device)
dataset = VOCSemanticSegmentationDataset()
iterator = SerialIterator(dataset, 1)
optimizer = Adam(alpha=lr)
optimizer.setup(model_own)
updater = VOC_ClassificationUpdater(iterator, optimizer, device=device)
trainer = Trainer(updater, (50, 'epoch'))
log_keys = ['epoch', 'iteration', 'main/Loss']
trainer.extend(
extensions.LogReport(log_keys, (100, 'iteration'),
log_name='log' + experiment))
trainer.extend(extensions.PrintReport(log_keys),
trigger=(100, 'iteration'))
trainer.extend(
extensions.ProgressBar(training_length=(50, 'epoch'),
update_interval=500))
trainer.extend(extensions.snapshot(filename='snapshot' + experiment),
trigger=(5, 'epoch'))
trainer.extend(extensions.snapshot_object(
trainer.updater._optimizers['main'].target, "model" + experiment),
trigger=(5, 'epoch'))
trainer.extend(
extensions.PlotReport(['main/Loss'],
'iteration', (100, 'iteration'),
file_name=experiment + '/loss.png',
grid=True,
marker=" "))
if resume:
chainer.serializers.load_npz(load_snapshot_path, trainer)
print("Running - - ", experiment)
print('initial lr ', lr)
print('lr_trigger_interval ', lr_trigger_interval)
trainer.run()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--device', type=int, default=-1, help='gpu id')
parser.add_argument('--lr_init',
type=float,
default=5 * 1e-5,
help='init learning rate')
# parser.add_argument('--lr_trigger', type=float, default=5, help='trigger to decreace learning rate')
# parser.add_argument('--lr_target', type=float, default=5*1e-5, help='target learning rate')
# parser.add_argument('--lr_factor', type=float, default=.75, help='decay factor')
parser.add_argument('--name',
type=str,
default='classifier',
help='name of the experiment')
parser.add_argument('--resume',
type=bool,
default=False,
help='resume training or not')
parser.add_argument('--snapshot',
type=str,
help='snapshot file of the trainer to resume from')
args = parser.parse_args()
resume = args.resume
device = args.device
if resume:
load_snapshot_path = args.snapshot
experiment = args.name
lr_init = args.lr_init
# lr_target = args.lr_target
# lr_factor = args.lr_factor
# lr_trigger_interval = (args.lr_trigger, 'epoch')
os.makedirs('result/' + experiment, exist_ok=True)
f = open('result/' + experiment + '/details.txt', "w+")
f.write("lr - " + str(lr_init) + "\n")
f.write("optimizer - " + str(Adam))
# f.write("lr_trigger_interval - "+str(lr_trigger_interval)+"\n")
f.close()
if not resume:
# Add the FC layers to original FCN for GAIN
model_own = FCN8s()
model_original = fcn.models.FCN8s()
model_file = fcn.models.FCN8s.download()
chainer.serializers.load_npz(model_file, model_original)
for layers in model_original._children:
setattr(model_own, layers, getattr(model_original, layers))
del (model_original, model_file)
else:
model_own = FCN8s()
if device >= 0:
model_own.to_gpu(device)
dataset = VOCSemanticSegmentationDataset()
iterator = SerialIterator(dataset, 1)
optimizer = Adam(alpha=lr_init)
optimizer.setup(model_own)
updater = VOC_ClassificationUpdater(iterator, optimizer, device=device)
trainer = Trainer(updater, (100, 'epoch'))
log_keys = ['epoch', 'iteration', 'main/Loss']
trainer.extend(
extensions.LogReport(log_keys, (100, 'iteration'),
log_name='log_' + experiment))
trainer.extend(extensions.PrintReport(log_keys),
trigger=(100, 'iteration'))
trainer.extend(extensions.snapshot(filename=experiment +
"_snapshot_{.updater.iteration}"),
trigger=(5, 'epoch'))
trainer.extend(extensions.snapshot_object(
trainer.updater._optimizers['main'].target,
experiment + "_model_{.updater.iteration}"),
trigger=(5, 'epoch'))
trainer.extend(
extensions.PlotReport(['main/Loss'],
'iteration', (100, 'iteration'),
file_name='trainer_' + experiment + '/loss.png',
grid=True,
marker=" "))
# trainer.extend(extensions.ExponentialShift('lr', lr_factor, target=lr_target), trigger=lr_trigger_interval)
if resume:
chainer.serializers.load_npz(load_snapshot_path, trainer)
print("Running - - ", experiment)
print('initial lr ', lr_init)
# print('lr_trigger_interval ', lr_trigger_interval)
trainer.run()