def make_submission(cfg):
predictions = []
# setting dataset ---------------------------
loader_test = dataset_factory.get_dataloader(cfg.data.test)
## model ------------------------------------
model = model_factory.get_model(cfg)
util.load_model(model_paths[0], model)
model.to(device)
model.eval()
train_df = pd.read_csv(cfg.train_csv)
regr_model = kaggle.get_regr_model(train_df)
for img, _, _ in tqdm(loader_test):
with torch.no_grad():
output = model(img.to(device))
output = output.data.cpu().numpy()
for out in output:
coords = kaggle.extract_coords(out, regr_model)
s = kaggle.coords2str(coords)
predictions.append(s)
test = pd.read_csv(cfg.data.test.dataframe)
test['PredictionString'] = predictions
test.to_csv('predictions.csv', index=False)
log.info(test.head())
def load_net(img, hde_arr, model, weight_path, device):
model.to(device)
util.load_model(model, weight_path)
hde_distance = model(img, hde_arr)
return hde_distance
def run():
queries_folder = '/media/alberto/DATA/ExperimentalCollections/Robust04/processed/topics'
documents_folder = '/media/alberto/DATA/ExperimentalCollections/Robust04/processed/corpus'
stop_word_path = '/home/alberto/PycharmProjects/probabilisticir/indri_stoplist_eng.txt'
gt_file = '/media/alberto/DATA/ExperimentalCollections/Robust04/processed/qrels.robust2004.txt'
run_to_rerank = '/home/alberto/PycharmProjects/probabilisticir/robust.terrier.krovetz.qld.2k.run'
queries, query_names = input_output.load_texts(queries_folder,
stop_word_path)
# documents, doc_names = input_output.load_texts(documents_folder, stop_word_path)
# idf_scores, word_index = input_output.compute_idf(documents, 10, 0.5)
# util.save_json(word_index, 'word_index_json')
idf_scores = util.load_model('idf_scores')
word_index = util.load_json('word_index_json')
encoded_idf_scores = {
word_index[k]: v
for k, v in idf_scores.items() if k in word_index.keys()
}
# encoded_docs = [[word_index[w] for w in d if w in word_index.keys()] for d in documents]
# encoded_queries = [[word_index[w] for w in q if w in word_index.keys()] for q in queries]
# util.save_model(encoded_docs, 'encoded_docs')
# util.save_model(encoded_queries, 'encoded_queries')
# util.save_model(query_names, 'q_names')
# util.save_model(doc_names, 'd_names')
query_names = util.load_model('q_names')
doc_names = util.load_model('d_names')
# query_names = util.load_model('q_names')
# doc_names = util.load_model('d_names')
query_names = [n.split(r'.txt')[0] for n in query_names][:50]
doc_names = [n.split(r'.txt')[0] for n in doc_names]
encoded_queries = util.load_model('encoded_queries')[:50]
encoded_docs = util.load_model('encoded_docs')
evaluate_ranking(encoded_idf_scores, encoded_queries, encoded_docs,
query_names, doc_names, gt_file, run_to_rerank)
def save_mask_multiprocess(num, data_size):
process_id = os.getpid()
print('process {} starts...'.format(process_id))
if args.num_gpu == 1:
gpu_id = args.gpu_id
elif args.num_gpu == 2:
if num >= data_size // args.num_gpu:
gpu_id = args.gpu_id + 0
else:
gpu_id = args.gpu_id + 1
elif args.num_gpu == 4:
if num >= data_size // args.num_gpu * 3:
gpu_id = args.gpu_id + 0
elif num >= data_size // args.num_gpu * 2:
gpu_id = args.gpu_id + 1
elif num >= data_size // args.num_gpu * 1:
gpu_id = args.gpu_id + 2
else:
gpu_id = args.gpu_id + 3
else:
raise Exception("ERROR")
base_model = models.__dict__[args.arch](num_classes=21)
model = base_model
model = load_model(model, args.trained)
model = model.cuda(gpu_id)
model.eval()
if num == data_size - 1:
sub_image_ids = image_ids[num * len(image_ids) // data_size:]
else:
sub_image_ids = image_ids[num * len(image_ids) // data_size: (num + 1) * len(image_ids) // data_size]
if num == 0:
print(len(sub_image_ids), 'images per each process...')
for idx, img_id in enumerate(sub_image_ids):
if num == 0 and idx % 10 == 0:
print("[{0} * {3}]/[{1} * {3}] : {2} is done.".format(idx, len(sub_image_ids), img_id, args.split_size))
image_file = os.path.join(image_path, img_id + '.jpg')
cls_label = cls_list[img_id]
if args.color_mask:
output, pred = predict_color_mask(image_file, model, args.smooth, gpu_id, cls_label)
save_path = os.path.join(args.pred_path, "output" ,img_id + '_output.png')
cv2.imwrite(save_path, cv2.cvtColor(output, cv2.COLOR_RGB2BGR))
save_path = os.path.join(args.pred_path, "pred", img_id + '_pred.png')
cv2.imwrite(save_path, cv2.cvtColor(pred, cv2.COLOR_RGB2BGR))
else:
labelmap = predict_label_mask(image_file, model, args.smooth, gpu_id)
save_path = os.path.join(args.pred_path, "label_mask" ,img_id + '_labelmask.png')
cv2.imwrite(save_path, labelmap)
def initialize_from_saved_model(args):
print('Training on saved model')
if args.device is not None:
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.device)
model, optimizer, epoch = load_model(args)
train_loader = COVIDxDataset(mode='train',
n_classes=args.classes,
dataset_path=args.dataset,
dim=(224, 224))
#print(train_loader.)
#------ Class weigths for sampling and for loss function -----------------------------------
labels = np.unique(train_loader.labels)
#print(labels)
class_weight = compute_class_weight('balanced', labels,
train_loader.labels)
class_weight = class_weight[::-1]
#class_weight[2]=50
#weights = torch.DoubleTensor(class_weight.copy())
#sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(train_loader.labels))
if (args.cuda):
class_weight = torch.from_numpy(class_weight.astype(float)).cuda()
else:
class_weight = torch.from_numpy(class_weight.astype(float))
#print(class_weight.shape)
#-------------------------------------------
val_loader = COVIDxDataset(mode='test',
n_classes=args.classes,
dataset_path=args.dataset,
dim=(224, 224))
#------------------------------------------------------------------------------------
train_params = {
'batch_size': args.batch_size,
'shuffle': True,
'num_workers': 4
} #'sampler' : sampler
test_params = {
'batch_size': args.batch_size,
'shuffle': False,
'num_workers': 4
}
#------------------------------------------------------------------------------------------
training_generator = DataLoader(train_loader, **train_params)
val_generator = DataLoader(val_loader, **test_params)
return model, optimizer, training_generator, val_generator, class_weight, epoch
def save_mask_multiprocess(num, data_size):
process_id = os.getpid()
print('process {} starts...'.format(process_id))
if args.num_gpu == 1:
gpu_id = args.gpu_id
elif args.num_gpu == 2:
if num >= data_size // args.num_gpu:
gpu_id = args.gpu_id + 0
else:
gpu_id = args.gpu_id + 1
elif args.num_gpu == 4:
if num >= data_size // args.num_gpu * 3:
gpu_id = args.gpu_id + 0
elif num >= data_size // args.num_gpu * 2:
gpu_id = args.gpu_id + 1
elif num >= data_size // args.num_gpu * 1:
gpu_id = args.gpu_id + 2
else:
gpu_id = args.gpu_id + 3
else:
raise Exception("ERROR")
model = models.__dict__[args.arch](21)
model = model.cuda(gpu_id)
model = load_model(model, args.trained)
model.eval()
if num == data_size - 1:
sub_image_ids = image_ids[num * len(image_ids) // data_size:]
else:
sub_image_ids = image_ids[num * len(image_ids) // data_size: (num + 1) * len(image_ids) // data_size]
if num == 0:
print(len(sub_image_ids), 'images per each process...')
for idx, img_id in enumerate(sub_image_ids):
if num == 0 and idx % 10 == 0:
print("[{0} * {3}]/[{1} * {3}] : {2} is done.".format(idx, len(sub_image_ids), img_id, args.split_size))
image_file = os.path.join(image_path, img_id + '.jpg')
mask = predict_mask(image_file, model, args.smooth, gpu_id)
save_path = os.path.join(args.pred_path, img_id + '.png')
cv2.imwrite(save_path, mask)
def __init__(self, bb, image_data, plot, args, nn_fname=''):
# Pretrained Kernel (for Sliders)
# kernel = ConstantKernel(0.005, constant_value_bounds=(0.005, 0.005)) * RBF(length_scale=(0.247, 0.084, 0.0592), length_scale_bounds=(0.0592, 0.247)) + WhiteKernel(noise_level=1e-5, noise_level_bounds=(1e-5, 1e2))
# Pretrained Kernel (for Doors)
# 0.0202**2 * RBF(length_scale=[0.0533, 0.000248, 0.0327, 0.0278]) + WhiteKernel(noise_level=1e-05)
self.xs, self.ys, self.moves = {'Prismatic': [], 'Revolute': []}, \
{'Prismatic': [], 'Revolute': []}, \
{'Prismatic': [], 'Revolute': []}
self.plot = plot
self.nn = None
if nn_fname != '':
self.nn = util.load_model(nn_fname, args.hdim, use_cuda=False)
self.bb = bb
self.image_data = image_data
self.mech = self.bb._mechanisms[0]
self.gps = {'Prismatic': GaussianProcessRegressor(kernel=self.get_kernel('Prismatic'), #args.type),
n_restarts_optimizer=1),
'Revolute': GaussianProcessRegressor(kernel=self.get_kernel('Revolute'), #args.type),
n_restarts_optimizer=1)}
self.optim = GPOptimizer(args.urdf_num, self.bb, self.image_data, \
args.n_gp_samples, BETA, self.gps, nn=self.nn)
def train(args):
#prepare_data_loaders(configs)
cuda = torch.device('cuda')
step = 0
loss_list = list()
plt.rc('font', family='Malgun Gothic')
model = Model(configs).cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
if args.load != '':
model, optimizer, step = util.load_model(args.load, model, optimizer)
util.mkdir(args.save)
for epoch in range(100):
train_data_loader, valid_data_loader = get_data_loaders(configs)
for i, data in tqdm(enumerate(train_data_loader),
total=int(
len(train_data_loader.dataset) /
train_data_loader.batch_size)):
step += 1
path_list, mel_batch, encoded_batch, text_list, mel_length_list, encoded_length_list = data
# mel_out, stop_tokens = model(torch.tensor(encoded_batch), torch.tensor(mel_batch))
mel_out, stop_tokens, enc_attention, dec_attention = model(
encoded_batch, mel_batch)
loss = nn.L1Loss()(mel_out.cuda(), mel_batch.cuda())
loss_list.append(loss.item())
if step % LOGGING_STEPS == 0:
writer.add_scalar('loss', np.mean(loss_list), step)
writer.add_text('script', text_list[0], step)
# writer.add_image('mel_in', torch.transpose(mel_batch[:1], 1, 2), step) # (1, 80, T)
# writer.add_image('mel_out', torch.transpose(mel_out[:1], 1, 2), step) # (1, 80, T)
#attention_image = matrix_to_plt_image(enc_attention[0].cpu().detach().numpy().T, text_list[0])
#writer.add_image('attention', attention_image, step, dataformats="HWC")
for i, prob in enumerate(enc_attention):
for j in range(4):
x = torchvision.utils.make_grid(prob[j * 4] * 255)
writer.add_image('ENC_Attention_%d_0' % step, x, step)
print(dec_attention[0].shape)
for i, prob in enumerate(dec_attention):
for j in range(4):
x = torchvision.utils.make_grid(prob[j * 4] * 255)
writer.add_image('DEC_Attention_%d_0' % step, x, step)
image = matrix_to_plt_image(
mel_batch[0].cpu().detach().numpy().T, text_list[0])
writer.add_image('mel_in', image, step,
dataformats="HWC") # (1, 80, T)
image = matrix_to_plt_image(
mel_out[0].cpu().detach().numpy().T, text_list[0])
writer.add_image('mel_out', image, step,
dataformats="HWC") # (1, 80, T)
# print(torch.min(mel_batch), torch.max(mel_batch))
# print(torch.min(mel_out), torch.max(mel_out))
# AssertionError: size of input tensor and input format are different.
# tensor shape: (578, 80), input_format: CHW
# print(mel_batch.shape)
# print(mel_out.shape) # torch.Size([24, 603, 80]) # B = 24
# print(attn_dot_list[0].shape) # torch.Size([96, 603, 603]) # 96 = B * 4 (num att. heads)
# print(attn_dec_list[0].shape) # torch.Size([96, 603, 603])
# https://tutorials.pytorch.kr/intermediate/tensorboard_tutorial.html
# https://www.tensorflow.org/tensorboard/image_summaries
util.save_model(model, optimizer, args.save, step)
loss_list = list()
# print(nn.L1Loss()(mel_out.cuda(), mel_batch.cuda()).item())
optimizer.zero_grad()
loss.backward()
# YUNA! Do not miss the gradient update!
# https://tutorials.pytorch.kr/beginner/pytorch_with_examples.html
optimizer.step()
# break
loss_list_test = list()
for i, data in tqdm(enumerate(valid_data_loader),
total=int(
len(valid_data_loader.dataset) /
valid_data_loader.batch_size)):
path_list, mel_batch, encoded_batch, text_list, mel_length_list, encoded_length_list = data
mel_out, stop_tokens = model(encoded_batch, mel_batch)
loss = nn.L1Loss()(mel_out.cuda(), mel_batch.cuda())
loss_list_test.append(loss.item())
writer.add_scalar('loss_valid', np.mean(loss_list), step)
writer.add_text('script_valid', text_list[0], step)
image = matrix_to_plt_image(mel_batch[0].cpu().detach().numpy().T,
text_list[0])
writer.add_image('mel_in_valid', image, step,
dataformats="HWC") # (1, 80, T)
image = matrix_to_plt_image(mel_out[0].cpu().detach().numpy().T,
text_list[0])
writer.add_image('mel_out_valid', image, step,
dataformats="HWC") # (1, 80, T)
loss_list_test = list()
for i, data in tqdm(enumerate(valid_data_loader),
total=int(
len(valid_data_loader.dataset) /
valid_data_loader.batch_size)):
path_list, mel_batch, encoded_batch, text_list, mel_length_list, encoded_length_list = data
zero_batch = torch.zeros_like(mel_batch)
mel_out, stop_tokens = model(encoded_batch, zero_batch)
loss = nn.L1Loss()(mel_out.cuda(), mel_batch.cuda())
loss_list_test.append(loss.item())
writer.add_scalar('loss_infer', np.mean(loss_list), step)
writer.add_text('script_infer', text_list[0], step)
image = matrix_to_plt_image(mel_batch[0].cpu().detach().numpy().T,
text_list[0])
writer.add_image('mel_in_infer', image, step,
dataformats="HWC") # (1, 80, T)
image = matrix_to_plt_image(mel_out[0].cpu().detach().numpy().T,
text_list[0])
writer.add_image('mel_out_infer', image, step,
dataformats="HWC") # (1, 80, T)
# break
# torch.save(model, PATH)
return
batch_size=args.batch,
shuffle=True,
num_workers=4,
drop_last=False)
loader_val = DataLoader(dataset_val,
batch_size=args.batch,
shuffle=True,
num_workers=4,
drop_last=False)
loader_seg = DataLoader(dataset_seg,
batch_size=args.batch,
shuffle=True,
num_workers=4,
drop_last=False)
model = util.load_model('rgb', device, args.ckpt, args.img_size)
if args.ckpt is not None: print('Resuming training...')
model.train()
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = None
if args.sched == 'cycle':
scheduler = CycleScheduler(optimizer,
args.lr,
n_iter=len(loader) * args.epoch,
momentum=None)
current_best = 999999
for i in range(args.epoch):
train(i, loader_train, loader_seg, model, optimizer, scheduler, device,
args.img_size)
def main():
args = get_args()
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
# number of classes for each dataset.
if args.dataset == 'PascalVOC':
num_classes = 20
else:
raise Exception("No dataset named {}.".format(args.dataset))
# Select Model & Method
model = models.__dict__[args.arch](pretrained=args.pretrained,
num_classes=num_classes)
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
# define loss function (criterion) and optimizer
criterion = nn.MultiLabelSoftMarginLoss().cuda(args.gpu)
# criterion = nn.BCEWithLogitsLoss().cuda(args.gpu)
# Take apart parameters to give different Learning Rate
param_features = []
param_classifiers = []
if args.arch.startswith('vgg'):
for name, parameter in model.named_parameters():
if 'features.' in name:
param_features.append(parameter)
else:
param_classifiers.append(parameter)
elif args.arch.startswith('resnet'):
for name, parameter in model.named_parameters():
if 'layer4.' in name or 'fc.' in name:
param_classifiers.append(parameter)
else:
param_features.append(parameter)
else:
raise Exception("Fail to recognize the architecture")
# Optimizer
optimizer = torch.optim.SGD([
{'params': param_features, 'lr': args.lr},
{'params': param_classifiers, 'lr': args.lr * args.lr_ratio}],
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=args.nest)
# optionally resume from a checkpoint
if args.resume:
model, optimizer = load_model(model, optimizer, args)
train_loader, val_loader, test_loader = data_loader(args)
saving_dir = os.path.join(args.log_folder, args.name)
if args.evaluate:
# test_ap, test_loss = evaluate_cam(val_loader, model, criterion, args)
# test_ap, test_loss = evaluate_cam2(val_loader, model, criterion, args)
test_ap, test_loss = evaluate_cam3(val_loader, model, criterion, args)
print_progress(test_ap, test_loss, 0, 0, prefix='test')
return
# Training Phase
best_m_ap = 0
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch, args)
# Train for one epoch
train_ap, train_loss = \
train(train_loader, model, criterion, optimizer, epoch, args)
print_progress(train_ap, train_loss, epoch+1, args.epochs)
# Evaluate classification
val_ap, val_loss = validate(val_loader, model, criterion, epoch, args)
print_progress(val_ap, val_loss, epoch+1, args.epochs, prefix='validation')
# # Save checkpoint at best performance:
is_best = val_ap.mean() > best_m_ap
if is_best:
best_m_ap = val_ap.mean()
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_m_ap': best_m_ap,
'optimizer': optimizer.state_dict(),
}, is_best, saving_dir)
save_progress(saving_dir, train_ap, train_loss, val_ap, val_loss, args)
def load_w2v_model(wi_path, we_path):
we = util.load_model(we_path)
wi = util.load_model(wi_path)
return we, wi
def do_train(cfg, model):
# get criterion -----------------------------
criterion = criterion_factory.get_criterion(cfg)
# get optimization --------------------------
optimizer = optimizer_factory.get_optimizer(model, cfg)
# initial -----------------------------------
best = {
'loss': float('inf'),
'score': 0.0,
'epoch': -1,
}
# resume model ------------------------------
if cfg.resume_from:
log.info('\n')
log.info(f're-load model from {cfg.resume_from}')
detail = util.load_model(cfg.resume_from, model, optimizer, cfg.device)
best.update({
'loss': detail['loss'],
'score': detail['score'],
'epoch': detail['epoch'],
})
# scheduler ---------------------------------
scheduler = scheduler_factory.get_scheduler(cfg, optimizer, best['epoch'])
# fp16 --------------------------------------
if cfg.apex:
amp.initialize(model, optimizer, opt_level='O1', verbosity=0)
# setting dataset ---------------------------
loader_train = dataset_factory.get_dataloader(cfg.data.train)
loader_valid = dataset_factory.get_dataloader(cfg.data.valid)
# start trainging ---------------------------
start_time = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
log.info('\n')
log.info(f'** start train [fold{cfg.fold}th] {start_time} **\n')
log.info(
'epoch iter rate | smooth_loss/score | valid_loss/score | best_epoch/best_score | min'
)
log.info(
'-------------------------------------------------------------------------------------------------'
)
for epoch in range(best['epoch'] + 1, cfg.epoch):
end = time.time()
util.set_seed(epoch)
## train model --------------------------
train_results = run_nn(cfg.data.train,
'train',
model,
loader_train,
criterion=criterion,
optimizer=optimizer,
apex=cfg.apex,
epoch=epoch)
## valid model --------------------------
with torch.no_grad():
val_results = run_nn(cfg.data.valid,
'valid',
model,
loader_valid,
criterion=criterion,
epoch=epoch)
detail = {
'score': val_results['score'],
'loss': val_results['loss'],
'epoch': epoch,
}
if val_results['loss'] <= best['loss']:
best.update(detail)
util.save_model(model, optimizer, detail, cfg.fold[0],
os.path.join(cfg.workdir, 'checkpoint'))
log.info('%5.1f %5d %0.6f | %0.4f %0.4f | %0.4f %6.4f | %6.1f %6.4f | %3.1f min' % \
(epoch+1, len(loader_train), util.get_lr(optimizer), train_results['loss'], train_results['score'], val_results['loss'], val_results['score'], best['epoch'], best['score'], (time.time() - end) / 60))
scheduler.step(
val_results['loss']) # if scheduler is reducelronplateau
# scheduler.step()
# early stopping-------------------------
if cfg.early_stop:
if epoch - best['epoch'] > cfg.early_stop:
log.info(f'=================================> early stopping!')
break
time.sleep(0.01)
import os
from utils.metric import evaluate
from utils.data_container import get_data_loader
from utils.load_config import get_attribute
from utils.util import convert_to_gpu
from train.train_main import create_model
from utils.util import load_model
if __name__ == '__main__':
model_path = f"../save_model_folder/{get_attribute('data')}/{get_attribute('save_model_folder')}" \
f"/model_epoch_19.pkl"
print(f'model path -> {model_path}')
model = create_model()
model = load_model(model, model_path)
model = convert_to_gpu(model)
print(model)
test_data_loader = get_data_loader(
data_path=get_attribute('data_path'),
data_type='test',
batch_size=get_attribute('batch_size'),
item_embedding_matrix=model.item_embedding)
print('===== Test predict result =====')
scores = evaluate(model, test_data_loader)
scores = sorted(scores.items(), key=lambda item: item[0], reverse=False)
scores = {item[0]: item[1] for item in scores}
vectors = torch.cat([vectors, vectors[0].unsqueeze(0)], 0)
vectors = torch.cat([vectors, vectors[0].unsqueeze(0)], 0)
vectors[0] = torch.zeros(dim)
n_words = len(vectors)
n_rel = len(r2id)
rel_emb = torch.from_numpy(np.loadtxt(args.rel_kg_vec))
ent_cand_s = 100
model = E2E_entity_linker(num_words=n_words, emb_dim=dim, hidden_size=args.hidden_size, num_layers=args.num_layer,
emb_dropout=args.emb_drop, pretrained_emb=vectors, train_embed=False, kg_emb_dim=50,
rel_size=n_rel, ent_cand_size=ent_cand_s, pretrained_rel=rel_emb, dropout=args.rnn_dropout,
use_cuda=args.gpu)
model = load_model(model, model_name, gpu=args.gpu)
model.eval()
def interact(question):
question = clean_str(question)
if question!="":
wikiid,elabel,predfb = infer(question,model, e2id=e2id, e_1hop=e_1hop, stoi=stoi)
return wikiid, elabel, predfb
else:
print("Please ask something !!")
return "","",""
@app.route('/elidi')
def home():
return render_template('index.html')
def main():
args = get_args()
log_folder = os.path.join('train_log', args.name)
writer = SummaryWriter(log_folder)
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
# number of classes for each dataset.
if args.dataset == 'PascalVOC':
num_classes = 21
elif args.dataset == 'COCO':
num_classes = 81
else:
raise Exception("No dataset named {}.".format(args.dataset))
# Select Model & Method
model = models.__dict__[args.arch](num_classes=num_classes)
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
# Optimizer
optimizer = torch.optim.SGD(
[{
'params': get_parameters(model, bias=False, final=False),
'lr': args.lr,
'weight_decay': args.wd
}, {
'params': get_parameters(model, bias=True, final=False),
'lr': args.lr * 2,
'weight_decay': 0
}, {
'params': get_parameters(model, bias=False, final=True),
'lr': args.lr * 10,
'weight_decay': args.wd
}, {
'params': get_parameters(model, bias=True, final=True),
'lr': args.lr * 20,
'weight_decay': 0
}],
momentum=args.momentum)
if args.resume:
model = load_model(model, args.resume)
train_loader = data_loader(args)
data_iter = iter(train_loader)
train_t = tqdm(range(args.max_iter))
model.train()
for global_iter in train_t:
try:
images, target, gt_map = next(data_iter)
except:
data_iter = iter(data_loader(args))
images, target, gt_map = next(data_iter)
if args.gpu is not None:
images = images.cuda(args.gpu)
gt_map = gt_map.cuda(args.gpu)
target = target.cuda(args.gpu)
output = model(images)
fc8_SEC_softmax = softmax_layer(output)
loss_s = seed_loss_layer(fc8_SEC_softmax, gt_map)
loss_e = expand_loss_layer(fc8_SEC_softmax, target, num_classes - 1)
fc8_SEC_CRF_log = crf_layer(output, images, iternum=10)
loss_c = constrain_loss_layer(fc8_SEC_softmax, fc8_SEC_CRF_log)
loss = loss_s + loss_e + loss_c
optimizer.zero_grad()
loss.backward()
optimizer.step()
# writer add_scalars
writer.add_scalar('loss', loss, global_iter)
writer.add_scalars('losses', {
'loss_s': loss_s,
'loss_e': loss_e,
'loss_c': loss_c
}, global_iter)
with torch.no_grad():
if global_iter % 10 == 0:
# writer add_images (origin, output, gt)
origin = images.clone().detach() + torch.tensor(
[123., 117., 107.]).reshape(1, 3, 1, 1).cuda(args.gpu)
size = (100, 100)
origin = F.interpolate(origin, size=size)
origins = vutils.make_grid(origin,
nrow=15,
padding=2,
normalize=True,
scale_each=True)
outputs = F.interpolate(output, size=size)
_, outputs = torch.max(outputs, dim=1)
outputs = outputs.unsqueeze(1)
outputs = vutils.make_grid(outputs,
nrow=15,
padding=2,
normalize=True,
scale_each=True).float()
gt_maps = F.interpolate(gt_map, size=size)
_, gt_maps = torch.max(gt_maps, dim=1)
gt_maps = gt_maps.unsqueeze(1)
gt_maps = vutils.make_grid(gt_maps,
nrow=15,
padding=2,
normalize=True,
scale_each=True).float()
# gt_maps = F.interpolate(gt_map.unsqueeze(1).float(), size=size)
# gt_maps = vutils.make_grid(gt_maps, nrow=15, padding=2, normalize=True, scale_each=True).float()
grid_image = torch.cat((origins, outputs, gt_maps), dim=1)
writer.add_image(args.name, grid_image, global_iter)
description = '[{0:4d}/{1:4d}] loss: {2} s: {3} e: {4} c: {5}'.\
format(global_iter+1, args.max_iter, loss, loss_s, loss_e, loss_c)
train_t.set_description(desc=description)
# save snapshot
if global_iter % args.snapshot == 0:
save_checkpoint(model.state_dict(), log_folder,
'checkpoint_%d.pth.tar' % global_iter)
# lr decay
if global_iter % args.lr_decay == 0:
args.lr = args.lr * 0.1
optimizer = adjust_learning_rate(optimizer, args.lr)
print("Training is over...")
save_checkpoint(model.state_dict(), log_folder, 'last_checkpoint.pth.tar')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--img_size', type=int, default=64)
parser.add_argument('--ckpt', type=str, required=True)
parser.add_argument('--dataset', type=str)
parser.add_argument('--img_type', type=str, default='rgb')
parser.add_argument('--device', type=str, default='cuda:1')
args = parser.parse_args()
device = args.device
torch.cuda.set_device(device)
# Initialise model
model = util.load_model(args.img_type, device, args.ckpt, args.img_size)
model.eval()
if args.dataset == None: dataset = {'train', 'val'}
else: dataset = {args.dataset}
for ds in dataset:
dataset_path = f'/shared/users/patriri/carla_data/{args.img_type}/rnn/{ds}/'
dataset = datasets.DatasetFolder(
root=dataset_path,
loader=npy_loader,
extensions='.npy',
)
loader = DataLoader(dataset,
batch_size=1,
shuffle=False,
# 部首有663个
model = HDENet(663, 256, "resnet34")
device = None
if torch.cuda.is_available():
cudnn.benchmark = True
device = 'cuda'
else:
device = "cpu"
model.to(device)
# resume
if is_resume:
util.load_model(model, resume_path)
start_epoch = int(re.sub("\D", "", resume_path)) + 1
optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9)
scheduler = lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.9)
for epoch in range(start_epoch, start_epoch + epochs):
train_loss = []
test_loss = []
train_acc = []
test_acc = []
scheduler.step()
model.train()
if __name__ == '__main__':
args = parse_args()
config = get_config()
logger.info(config)
CQIL_helper = CQILHelper(config)
logger.info('Constructing Model...')
model = CQIL(config)
logger.info(model)
if config['reload'] > 0:
logger.info('load model')
load_model(model, config['model_filepath'])
model = model.to(torch.device(f"cuda:{config['gpu_id']}" if torch.cuda.is_available() else "cpu"))
total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
logger.info('total parameters: ' + str(total_params))
if args.mode == 'train':
CQIL_helper.train(config, model)
elif args.mode == 'valid':
valid_dataset = TestDataset(config, dataset_type='valid')
CQIL_helper.test(config, model, valid_dataset)
elif args.mode == 'eval':
eval_dataset = TestDataset(config, dataset_type='eval')
dataset_val = datasets.DatasetFolder(
root=path_val,
loader=npy_loader,
extensions='.npy',
)
loader_train = DataLoader(dataset_train,
batch_size=args.batch,
shuffle=True,
num_workers=4)
loader_val = DataLoader(dataset_val,
batch_size=args.batch,
shuffle=True,
num_workers=4)
if args.pred is True:
model_vqvae = util.load_model(args.img_type, args.device, args.vqvae,
args.img_size)
model_vqvae.eval()
path_test = f'/shared/users/patriri/carla_data/{args.img_type}/rnn/val'
dataset_test = datasets.DatasetFolder(
root=path_test,
loader=npy_loader,
extensions='.npy',
)
loader_test = DataLoader(dataset_test,
batch_size=1,
shuffle=False,
num_workers=4)
predict(loader_test, model_rnn, model_vqvae, args)
else:
