def get_log_dir(model_name, config_id, cfg):
name = '004_{}'.format(datetime.now().strftime('%b%d-%H:%M:%S'))
#name += '_xe_norm-mse'
name += '_instance_mse_FCN8_lr1e-7_xavier1e-4_norm_D21'
name += '_VCS-%s' % git_hash()
name += '_{}'.format(socket.gethostname().split('.')[0])
# create out
log_dir = osp.join(here, 'logs', name)
if not osp.exists(log_dir):
os.makedirs(log_dir)
with open(osp.join(log_dir, 'config.yaml'), 'w') as f:
yaml.safe_dump(cfg, f, default_flow_style=False)
return log_dir
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument('-g', '--gpu', type=int, required=True, help='gpu id')
parser.add_argument('--resume', help='checkpoint path')
# configurations (same configuration as original work)
# https://github.com/shelhamer/fcn.berkeleyvision.org
parser.add_argument(
'--max-iteration', type=int, default=100000, help='max iteration'
)
parser.add_argument(
'--lr', type=float, default=1.0e-12, help='learning rate',
)
parser.add_argument(
'--weight-decay', type=float, default=0.0005, help='weight decay',
)
parser.add_argument(
'--momentum', type=float, default=0.99, help='momentum',
)
parser.add_argument(
'--pretrained-model',
help='pretrained model of FCN32s',
)
args = parser.parse_args()
args.model = 'FCN16s'
args.git_hash = git_hash()
now = datetime.datetime.now()
args.out = osp.join(here, 'logs', now.strftime('%Y%m%d_%H%M%S.%f'))
os.makedirs(args.out)
with open(osp.join(args.out, 'config.yaml'), 'w') as f:
yaml.safe_dump(args.__dict__, f, default_flow_style=False)
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
cuda = torch.cuda.is_available()
torch.manual_seed(1337)
if cuda:
torch.cuda.manual_seed(1337)
# 1. dataset
#root = osp.expanduser('~/data/datasets')
kwargs = {'num_workers': 4, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(
torchfcn.datasets.SatelliteDataset(split='train', transform=True),
batch_size=1, shuffle=True, **kwargs)
val_loader = torch.utils.data.DataLoader(
torchfcn.datasets.SatelliteDataset(
split='val', transform=True),
batch_size=1, shuffle=False, **kwargs)
# 2. model
model = torchfcn.models.FCN16s(n_class=2)
start_epoch = 0
start_iteration = 0
# if args.resume:
# checkpoint = torch.load(args.resume)
# model.load_state_dict(checkpoint['model_state_dict'])
# start_epoch = checkpoint['epoch']
# start_iteration = checkpoint['iteration']
# else:
# fcn32s = torchfcn.models.FCN32s()
# state_dict = torch.load(args.pretrained_model)
# try:
# fcn32s.load_state_dict(state_dict)
# except RuntimeError:
# fcn32s.load_state_dict(state_dict['model_state_dict'])
# model.copy_params_from_fcn32s(fcn32s)
if cuda:
model = model.cuda()
# 3. optimizer
optim = torch.optim.SGD(
[
{'params': get_parameters(model, bias=False)},
{'params': get_parameters(model, bias=True),
'lr': args.lr * 2, 'weight_decay': 0},
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.resume:
optim.load_state_dict(checkpoint['optim_state_dict'])
trainer = torchfcn.Trainer(
cuda=cuda,
model=model,
optimizer=optim,
train_loader=train_loader,
val_loader=val_loader,
out=args.out,
max_iter=args.max_iteration,
interval_validate=4000,
)
trainer.epoch = start_epoch
trainer.iteration = start_iteration
trainer.train()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter, )
parser.add_argument('-g', '--gpu', type=int, required=True, help='gpu id')
parser.add_argument('--resume', help='checkpoint path')
# configurations (same configuration as original work)
# https://github.com/shelhamer/fcn.berkeleyvision.org
parser.add_argument('--max-iteration',
type=int,
default=3000,
help='max iteration')
parser.add_argument(
'--lr',
type=float,
default=1.0e-4,
help='learning rate',
)
parser.add_argument(
'--weight-decay',
type=float,
default=0.0005,
help='weight decay',
)
parser.add_argument(
'--momentum',
type=float,
default=0.99,
help='momentum',
)
args = parser.parse_args()
args.model = 'FCN8sAtOnce'
args.git_hash = git_hash()
now = datetime.datetime.now()
args.out = osp.join(here, 'logs', now.strftime('%Y%m%d_%H%M%S.%f'))
os.makedirs(args.out)
with open(osp.join(args.out, 'config.yaml'), 'w') as f:
yaml.safe_dump(args.__dict__, f, default_flow_style=False)
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
cuda = torch.cuda.is_available()
torch.manual_seed(1337)
if cuda:
torch.cuda.manual_seed(1337)
# 1. dataset
root = osp.expanduser('~/data/datasets')
kwargs = {'num_workers': 4, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(torchfcn.datasets.DAVISClassSeg(
root, split='train', transform=True, crf=False),
batch_size=1,
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(torchfcn.datasets.DAVISClassSeg(
root, split='val', transform=True, crf=False),
batch_size=1,
shuffle=False,
**kwargs)
loader = val_loader
# 2. model
model = torchfcn.models.FCN8sAtOnce(n_class=2)
epoch = 0
iteration = 0
checkpoint = torch.load(args.resume)
model.load_state_dict(checkpoint['model_state_dict'])
if cuda:
model = model.cuda()
training = False
model.eval()
n_class = len(loader.dataset.class_names)
val_loss = 0
visualizations = []
label_trues, label_preds = [], []
timestamp_start = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
for batch_idx, (data, target, img_file) in tqdm.tqdm(
enumerate(loader),
total=len(loader),
desc='Valid iteration=%d' % iteration,
ncols=80,
leave=False):
data, target = data.cuda(), target.cuda()
data, target = Variable(data), Variable(target)
img_file = img_file[0]
with torch.no_grad():
score = model(data)
loss = cross_entropy2d(score, target, size_average=False)
score = F.softmax(score, dim=1)
loss_data = loss.data.item()
if np.isnan(loss_data):
raise ValueError('loss is nan while validating')
val_loss += loss_data / len(data)
imgs = data.data.cpu()
np.save(img_file.replace('jpg', 'npy'),
np.squeeze(score.data.cpu().numpy(), 0))
lbl_pred = score.data.max(1)[1].cpu().numpy()[:, :, :]
lbl_true = target.data.cpu()
for img, lt, lp in zip(imgs, lbl_true, lbl_pred):
img, lt = loader.dataset.untransform(img, lt)
label_trues.append(lt)
label_preds.append(lp)
if len(visualizations) < 9:
viz = fcn.utils.visualize_segmentation(lbl_pred=lp,
lbl_true=lt,
img=img,
n_class=n_class)
visualizations.append(viz)
metrics = torchfcn.utils.label_accuracy_score(label_trues, label_preds,
n_class)
out = osp.join(args.out, 'visualization_viz')
if not osp.exists(out):
os.makedirs(out)
out_file = osp.join(out, 'iter%012d.jpg' % iteration)
scipy.misc.imsave(out_file, fcn.utils.get_tile_image(visualizations))
val_loss /= len(loader)
with open(osp.join(args.out, 'log.csv'), 'a') as f:
elapsed_time = (datetime.datetime.now(pytz.timezone('Asia/Tokyo')) -
timestamp_start).total_seconds()
log = [epoch, iteration] + [''] * 5 + \
[val_loss] + list(metrics) + [elapsed_time]
log = map(str, log)
f.write(','.join(log) + '\n')
mean_iu = metrics[2]
print(mean_iu)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter, )
parser.add_argument('-g', '--gpu', type=int, required=True, help='gpu id')
parser.add_argument('--resume', help='checkpoint path')
# configurations (same configuration as original work)
# https://github.com/shelhamer/fcn.berkeleyvision.org
parser.add_argument('--max-iteration',
type=int,
default=25,
help='max iteration')
parser.add_argument(
'--lr',
type=float,
default=1.0e-7,
help='learning rate',
)
parser.add_argument(
'--weight-decay',
type=float,
default=0.0005,
help='weight decay',
)
parser.add_argument(
'--momentum',
type=float,
default=0.99,
help='momentum',
)
args = parser.parse_args()
args.model = 'FCN8sAtOnce'
args.git_hash = git_hash()
now = datetime.datetime.now()
args.out = osp.join(here, 'logs', now.strftime('%Y%m%d_%H%M%S.%f'))
os.makedirs(args.out)
with open(osp.join(args.out, 'config.yaml'), 'w') as f:
yaml.safe_dump(args.__dict__, f, default_flow_style=False)
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
cuda = torch.cuda.is_available()
torch.manual_seed(1337)
if cuda:
torch.cuda.manual_seed(1337)
# 1. dataset
root = osp.expanduser('~/data/datasets')
kwargs = {'num_workers': 4, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(torchfcn.datasets.DAVISClassSeg(
root, split='train', transform=True),
batch_size=100,
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(torchfcn.datasets.DAVISClassSeg(
root, split='val', transform=True),
batch_size=100,
shuffle=False,
**kwargs)
# 2. model
config = convcrf.default_conf
config['filter_size'] = 5
config['pyinn'] = False
config['trainable'] = True
logging.info("Build ConvCRF.")
##
# Create CRF module
model = convcrf.GaussCRF(conf=config, shape=[224, 224], nclasses=2)
start_epoch = 0
start_iteration = 0
if args.resume:
checkpoint = torch.load(args.resume)
model.load_state_dict(checkpoint['model_state_dict'])
start_epoch = checkpoint['epoch']
start_iteration = checkpoint['iteration']
if cuda:
model = model.cuda()
# for m in model.modules():
# print(dir(m))
# for p in model.parameters():
# print(p.name)
optim = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.resume:
optim.load_state_dict(checkpoint['optim_state_dict'])
trainer = crftrainer.Trainer(
cuda=cuda,
model=model,
optimizer=optim,
train_loader=train_loader,
val_loader=val_loader,
out=args.out,
max_iter=args.max_iteration,
)
trainer.epoch = start_epoch
trainer.iteration = start_iteration
trainer.train()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter, )
parser.add_argument('-g', '--gpu', type=int, required=True, help='gpu id')
parser.add_argument('--resume', help='checkpoint path')
# configurations (same configuration as original work)
# https://github.com/shelhamer/fcn.berkeleyvision.org
parser.add_argument('--max-iteration',
type=int,
default=100000,
help='max iteration')
parser.add_argument(
'--lr',
type=float,
default=1.0e-10,
help='learning rate',
)
parser.add_argument(
'--weight-decay',
type=float,
default=0.0005,
help='weight decay',
)
parser.add_argument(
'--momentum',
type=float,
default=0.99,
help='momentum',
)
args = parser.parse_args()
args.model = 'FCN8sAtOnce'
args.git_hash = git_hash()
now = datetime.datetime.now()
args.out = osp.join(here, 'logs', now.strftime('%Y%m%d_%H%M%S.%f'))
os.makedirs(args.out)
with open(osp.join(args.out, 'config.yaml'), 'w') as f:
yaml.safe_dump(args.__dict__, f, default_flow_style=False)
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
cuda = torch.cuda.is_available()
torch.manual_seed(1337)
if cuda:
torch.cuda.manual_seed(1337)
# 1. dataset
root = osp.expanduser('~/facades_datasets/5.ECP')
kwargs = {'num_workers': 4, 'pin_memory': True} if cuda else {}
# use our dataset and defined transformations
dataset_train = facade_dataset.ECP_Dataset(root, split='train')
dataset_val = facade_dataset.ECP_Dataset(root, split='val')
# define training and validation data loaders
loader_train = torch.utils.data.DataLoader(dataset_train,
batch_size=8,
shuffle=True,
**kwargs)
loader_val = torch.utils.data.DataLoader(dataset_val,
batch_size=1,
shuffle=False,
**kwargs)
# 2. model
model = torchfcn.models.FCN8sAtOnce(n_class=9)
start_epoch = 0
start_iteration = 0
if args.resume:
checkpoint = torch.load(args.resume)
model.load_state_dict(checkpoint['model_state_dict'])
start_epoch = checkpoint['epoch']
start_iteration = checkpoint['iteration']
else:
vgg16 = torchfcn.models.VGG16(pretrained=True)
model.copy_params_from_vgg16(vgg16)
if cuda:
model = model.cuda()
# 3. optimizer
optim = torch.optim.SGD([
{
'params': get_parameters(model, bias=False)
},
{
'params': get_parameters(model, bias=True),
'lr': args.lr * 2,
'weight_decay': 0
},
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.resume:
optim.load_state_dict(checkpoint['optim_state_dict'])
trainer = torchfcn.Trainer(
cuda=cuda,
model=model,
optimizer=optim,
train_loader=loader_train,
val_loader=loader_val,
out=args.out,
max_iter=args.max_iteration,
interval_validate=5000,
)
trainer.epoch = start_epoch
trainer.iteration = start_iteration
trainer.train()