def test_solver(model, data_loader, output_dir):
# load checkpoint
load_checkpoint(model, output_dir[0])
New2Old = cvb.load('/mnt/lustre/liushu1/mask_rcnn/coco-master/PythonAPI/Newlabel.pkl')
result_path = os.path.join(output_dir[1], 'result.json')
log_dir = output_dir[1]
count = 0
logger = solver_log(os.path.join(log_dir, 'test_'+ time.strftime('%Y%m%d_%H%M%S', time.localtime()) +'.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
for box_feature, rank_score, box_box, box_label, box_score_origin, box_box_origin, image_id, box_keep_np in data_loader:
# print(image_id)
image_id = int(image_id.numpy())
bboxes = []
start = time.time()
box_feature_variable = Variable(box_feature).cuda()
box_score_variable = Variable(rank_score).cuda()
box_label_variable = Variable(box_label).cuda()
box_box_variable = Variable(box_box).cuda()
output = test(box_feature_variable, box_score_variable, box_box_variable, model)
# keep = list(np.where(output==1)[0])
box_score_origin = box_score_origin.cpu().numpy().astype(np.float)
box_keep_np = box_keep_np.cpu().numpy().astype(np.int)
# final_score = box_score_origin * output
final_score = box_score_origin * output
# for index in keep:
for index in range(final_score.shape[0]):
# cls_index = np.argmax(box_score_origin[index, :])
cls_all_index = np.where(box_keep_np[index, :]==1)[0]
for cls_index in cls_all_index:
# cls_index = np.argsort(final_score[index, :])[::-1][0]
x1, y1, x2, y2 = box_box_origin[index, cls_index*4:cls_index*4+4]
score = final_score[index, cls_index]
# score = box_score_origin[index, cls_index]
category_id = New2Old[str(cls_index+1)][1]
bboxes.append({'bbox': [int(x1), int(y1), int(x2)-int(x1)+1, int(y2)-int(y1)+1], 'score': float(score), 'category_id':category_id, 'image_id':int(image_id)})
count += 1
end = time.time()
print_time = float(end-start)
results.extend(bboxes)
logger.info('index:{}, image_id:{}, cost:{}'.format(count, image_id,print_time))
cvb.dump(results, result_path)
def test_solver(model, dataset, output_dir, thread_index, thread_num):
# load checkpoint
New2Old = cvb.load('/mnt/lustre/liushu1/mask_rcnn/coco-master/PythonAPI/Newlabel.pkl')
# result_path = os.path.join(output_dir[1], 'result.json')
np.set_printoptions(formatter={'float': '{: 0.4f}'.format})
log_dir = output_dir[1]
# count = 0
logger = solver_log(os.path.join(log_dir, 'test_'+ time.strftime('%Y%m%d_%H%M%S', time.localtime()) +'.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
data_num = len(dataset)
for count in range(data_num):
if count % thread_num != thread_index:
continue
data_np = dataset[count]
# input
all_class_box_feature, all_class_box_box, all_class_box_score = torch.FloatTensor(data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(data_np[2])
all_class_box_label = data_np[3]
all_class_box_weight = data_np[4]
all_class_box_origin_score, all_class_box_origin_box = torch.FloatTensor(data_np[5]), torch.FloatTensor(data_np[6])
gts_box = torch.FloatTensor(data_np[7])
unique_class, unique_class_len = torch.FloatTensor(data_np[8]), torch.FloatTensor(data_np[9])
pre_unique_class, pre_unique_class_len = data_np[8], data_np[9]
image_id = int(data_np[10])
# if data_np[1].shape[0]==0:
# results.extend(image_id)
bboxes = []
start = time.time()
# all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_feature_variable = Variable(all_class_box_feature).cuda()
all_class_box_origin_score_variable = Variable(all_class_box_origin_score).cuda()
all_class_box_origin_box_variable = Variable(all_class_box_origin_box).cuda()
gts_box_tensor = gts_box.cuda()
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
pre_stage_output, post_stage_output, post_stage_label, post_stage_weight, post_stage_box_origin_score_variable, post_stage_box_origin_box_tensor, post_unique_class, post_unique_class_len = model(all_class_box_feature_variable, all_class_box_box_variable, all_class_box_score_variable, all_class_box_origin_score_variable, all_class_box_origin_box_variable, gts_box_tensor, unique_class_cuda, unique_class_len_cuda)
# output_record = model(box_feature_variable, box_score_variable, box_box_variable, all_class_box_feature_variable, all_class_box_score_variable, all_class_box_box_variable, unique_class, unique_class_len)
pre_output = pre_stage_output.data.cpu().numpy().reshape(-1, 1).astype(np.float)
# output = test(all_class_box_feature_variable, all_class_box_box_variable, all_class_box_score_variable, all_class_box_origin_score_variable, all_class_box_origin_box_variable, gts_box_tensor, unique_class_cuda, unique_class_len_cuda, model)
pre_score = all_class_box_origin_score_variable.data.cpu().numpy().astype(np.float)[:,0:1].reshape(-1, 1)
pre_box = all_class_box_origin_box_variable.data.cpu().numpy()
pre_label = all_class_box_label
# post
post_score = post_stage_box_origin_score_variable.data.cpu().numpy().astype(np.float)[:,0:1].reshape(-1,1)
post_box = post_stage_box_origin_box_tensor.cpu().numpy()
post_output = post_stage_output.data.cpu().numpy().reshape(-1, 1).astype(np.float)
post_unique_class_np = post_unique_class.cpu().numpy()
post_unique_class_len_np = post_unique_class_len.cpu().numpy()
post_label = post_stage_label.data.cpu().numpy()
torch.cuda.empty_cache()
# final_score = box_score_origin
# final_score = (box_score_origin + output) / 2
pre_flag=False
if pre_flag:
final_score = pre_score * pre_output
unique_class_np = pre_unique_class
unique_class_len_np = pre_unique_class_len
final_box = pre_box
final_label = pre_label
else:
final_score = post_score * post_output
unique_class_np = post_unique_class_np
unique_class_len_np = post_unique_class_len_np
final_box = post_box
final_label = post_label
# final_score = output
for cls_index in range(80):
if unique_class_np[cls_index] == 0:
continue
start_ = int(unique_class_len_np[cls_index])
end_ = int(unique_class_len_np[cls_index+1])
for index in range(start_, end_):
x1, y1, x2, y2 = final_box[index, 0:4]
score = final_score[index, 0]
# if final_label[index, 0]==0:
# continue
# if(score<0.01):
# continue
category_id = New2Old[str(cls_index+1)][1]
bboxes.append({'bbox': [int(x1), int(y1), int(x2-x1+1), int(y2-y1+1)], 'score': float(score), 'category_id':category_id, 'image_id':int(image_id)})
end = time.time()
print_time = float(end-start)
results.extend(bboxes)
logger.info('thread_index:{}, index:{}, image_id:{}, cost:{}'.format(thread_index, count, image_id, print_time))
return results
# cvb.dump(results, result_path)
def test_solver(model, dataset, output_dir, thread_index, thread_num):
# load checkpoint
load_checkpoint(model, output_dir[0])
New2Old = cvb.load(
'/mnt/lustre/liushu1/mask_rcnn/coco-master/PythonAPI/Newlabel.pkl')
# result_path = os.path.join(output_dir[1], 'result.json')
log_dir = output_dir[1]
# count = 0
logger = solver_log(
os.path.join(
log_dir, 'test_' +
time.strftime('%Y%m%d_%H%M%S', time.localtime()) + '.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
data_num = len(dataset)
for count in range(data_num):
if count % thread_num != thread_index:
# count += 1
continue
data_np = dataset[count]
# print(type(data_np))
# print(len(data_np))
# input()
box_feature, rank_score, box_box, box_label, box_score_origin, box_box_origin, image_id, box_keep_np = torch.FloatTensor(
data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(
data_np[2]), torch.FloatTensor(data_np[3]), torch.FloatTensor(
data_np[4]), torch.FloatTensor(
data_np[5]), torch.IntTensor(
[data_np[6]]), torch.FloatTensor(data_np[7])
# print(image_id)
# input()
image_id = int(image_id.numpy())
bboxes = []
start = time.time()
box_feature_variable = Variable(box_feature).cuda()
box_score_variable = Variable(rank_score).cuda()
# box_label_variable = Variable(box_label).cuda()
box_box_variable = Variable(box_box).cuda()
output = test(box_feature_variable, box_score_variable,
box_box_variable, model)
# keep = list(np.where(output==1)[0])
box_score_origin = box_score_origin.cpu().numpy().astype(np.float)
box_keep_np = box_keep_np.cpu().numpy().astype(np.int)
# final_score = box_score_origin * output
final_score = box_score_origin * output
# for index in keep:
for index in range(final_score.shape[0]):
# cls_index = np.argmax(box_score_origin[index, :])
# if output[index, 0]==0:
# continue
cls_all_index = np.where(box_keep_np[index, :] == 1)[0]
for cls_index in cls_all_index:
# cls_index = np.argsort(final_score[index, :])[::-1][0]
x1, y1, x2, y2 = box_box_origin[index, cls_index *
4:cls_index * 4 + 4]
# if abs(box_score_origin[index, cls_index]-output[index, 0]) >= 0.8:
# continue
score = final_score[index, cls_index]
# score = 1
# score = box_score_origin[index, cls_index]
category_id = New2Old[str(cls_index + 1)][1]
bboxes.append({
'bbox': [
int(x1),
int(y1),
int(x2) - int(x1) + 1,
int(y2) - int(y1) + 1
],
'score':
float(score),
'category_id':
category_id,
'image_id':
int(image_id)
})
# count += 1
end = time.time()
print_time = float(end - start)
results.extend(bboxes)
logger.info('thread_index:{}, index:{}, image_id:{}, cost:{}'.format(
thread_index, count, image_id, print_time))
return results
def solver(model,
data_loader,
n_epochs,
output_dir,
print_every=1,
save_every=1,
learning_rate=0.01,
step=10,
pos_neg_weight=100,
load_file=None,
continue_epochs=None,
continue_iters=None):
# plot_losses = []
if continue_epochs is None:
continue_epochs = -1
continue_iters = -1
first_count = None
else:
first_count = continue_iters
print_losses = []
print_loss_total = 0 # Reset every print_every
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
model_optimizer = optim.SGD(model.parameters(),
lr=learning_rate,
momentum=0.9)
model_dir = output_dir[0]
log_dir = output_dir[1]
# log
logger = solver_log(
os.path.join(
log_dir, 'train_' +
time.strftime('%Y%m%d_%H%M%S', time.localtime()) + '.log'))
for epoch_index in range(n_epochs):
# print len(data_loader)
if (epoch_index < continue_epochs):
continue
if first_count is None:
count = 0
else:
count = first_count
for box_feature, rank_score, box_box, box_label, box_weight, box_class_label, box_class_weight in data_loader:
# for box_feature, rank_score, box_box, box_label in data_loader:
start = time.time()
# print('begin')
box_feature_variable = Variable(box_feature).cuda()
box_score_variable = Variable(rank_score).cuda()
box_label_variable = Variable(box_label).cuda()
box_class_label_variable = Variable(box_class_label).cuda()
# box_class_weight_variable = Variable(box_class_weight).cuda()
box_box_variable = Variable(box_box).cuda()
criterion_box = nn.BCELoss(weight=box_weight.cuda())
criterion_box_class = nn.BCELoss(weight=box_class_weight.cuda())
# criterion = nn.BCELoss(weight=box_weight.cuda())
# criterion = nn.BCELoss(weight=box_weight.cuda())
# print box_score_fusion_variable.size()
loss, pos_accuracy, neg_accuracy = train(
box_feature_variable, box_score_variable, box_box_variable,
box_label_variable, box_class_label_variable, model,
model_optimizer, criterion_box, criterion_box_class)
count += 1
print_loss_total += loss
print_pos_acc_total += pos_accuracy
print_neg_acc_total += neg_accuracy
end = time.time()
print_time_total += float(end - start)
if count % print_every == 0:
print_loss_avg = print_loss_total / print_every
print_pos_acc_avg = print_pos_acc_total / print_every
print_neg_acc_avg = print_neg_acc_total / print_every
print_time_avg = print_time_total / print_every
print_loss_total = 0
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
# print('aa')
logger.info(
'epoch:{}, iter:{}, lr:{}, avg_time:{:.3f}, avg_loss:{:.10f}, accuracy:{:.3f}, recall:{:.3f}'
.format(epoch_index, count, learning_rate, print_time_avg,
print_loss_avg, print_pos_acc_avg,
print_neg_acc_avg))
if count % save_every == 0:
save_checkpoint(model, epoch_index, count, model_dir)
print_loss_total = 0
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
if epoch_index % step == 0 and epoch_index > 0:
learning_rate = learning_rate * 0.1
for param_group in model_optimizer.param_groups:
param_group['lr'] = learning_rate
def test_solver(model, dataset, output_dir, thread_index, thread_num):
# load checkpoint
load_checkpoint(model, output_dir[0])
New2Old = cvb.load('/data/luqi/coco-master/PythonAPI/Newlabel.pkl')
# result_path = os.path.join(output_dir[1], 'result.json')
log_dir = output_dir[1]
# count = 0
logger = solver_log(os.path.join(log_dir, 'test_'+ time.strftime('%Y%m%d_%H%M%S', time.localtime()) +'.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
data_num = len(dataset)
for count in range(data_num):
if count % thread_num != thread_index:
continue
data_np = dataset[count]
# input
all_class_box_feature, all_class_box_box, all_class_box_score, all_class_box_label, all_class_box_weight, all_class_box_origin_score, unique_class, unique_class_len, img_id, phase_np
# box_feature, rank_score, box_box = torch.FloatTensor(data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(data_np[2])
all_class_box_feature, all_class_box_box, all_class_box_score = torch.FloatTensor(data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(data_np[2])
all_class_box_label = data_np[3]
all_class_box_class, all_class_box_origin_score, all_class_box_origin_box = data_np[7], torch.FloatTensor(data_np[8]), data_np[9]
unique_class, unique_class_len = torch.FloatTensor(data_np[10]), torch.FloatTensor(data_np[11])
image_id = int(data_np[12])
# all_class_box_single = all_class_box_origin_score[:, 0:1].numpy().copy()
# print(all_class_box_single.shape)
# input()
bboxes = []
start = time.time()
box_feature_variable = Variable(box_feature).cuda()
box_score_variable = Variable(rank_score).cuda()
# box_label_variable = Variable(box_label).cuda()
box_box_variable = Variable(box_box).cuda()
# all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_feature_variable = Variable(all_class_box_feature).cuda()
all_class_box_origin_score_variable = Variable(all_class_box_origin_score).cuda()
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
# output = test(box_feature_variable, box_score_variable, box_box_variable, all_class_box_feature_variable, all_class_box_score_variable, all_class_box_box_variable, all_class_box_origin_score_variable, unique_class_cuda, unique_class_len_cuda, model)
box_score_origin = all_class_box_origin_score_variable.data.cpu().numpy().astype(np.float)[:,0:1].reshape(-1, 1)
final_score = box_score_origin
# final_score = box_score_origin * output
# np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
# print(np.concatenate((all_class_box_class, all_class_box_label, box_score_origin, output, final_score), axis=1))
# if count==20:
# break
for index in range(final_score.shape[0]):
cls_index = int(all_class_box_class[index, 0])
x1, y1, x2, y2 = all_class_box_origin_box[index, 0:4]
score = final_score[index, 0]
category_id = New2Old[str(cls_index+1)][1]
bboxes.append({'bbox': [int(x1), int(y1), int(x2)-int(x1)+1, int(y2)-int(y1)+1], 'score': float(score), 'category_id':category_id, 'image_id':int(image_id)})
# count += 1
end = time.time()
print_time = float(end-start)
results.extend(bboxes)
logger.info('thread_index:{}, index:{}, image_id:{}, cost:{}'.format(thread_index, count, image_id, print_time))
return results
# cvb.dump(results, result_path)
def solver(model,
data_loader,
n_epochs,
output_dir,
print_every=1,
save_every=1,
learning_rate=0.01,
step=10,
pos_neg_weight=100,
load_file=None,
continue_epochs=None,
continue_iters=None):
# plot_losses = []
if continue_epochs is None:
continue_epochs = -1
continue_iters = -1
first_count = None
else:
first_count = continue_iters
print_losses = []
print_loss_total = 0 # Reset every print_every
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
model_optimizer = optim.SGD(model.parameters(),
lr=learning_rate,
momentum=0.9)
model_dir = output_dir[0]
log_dir = output_dir[1]
# log
logger = solver_log(
os.path.join(
log_dir, 'train_' +
time.strftime('%Y%m%d_%H%M%S', time.localtime()) + '.log'))
for epoch_index in range(n_epochs):
# print len(data_loader)
if (epoch_index < continue_epochs):
continue
if first_count is None:
count = 0
else:
count = first_count
for box_feature, rank_score, box_box, box_label, box_weight, unique_class, unique_class_len, all_class_box_feature, all_class_box_box, all_class_box_score, all_class_box_label, all_class_box_weight, all_class_box_origin_score in data_loader:
# for box_feature, rank_score, box_box, box_label in data_loader:
start = time.time()
# print('begin')
box_feature_variable = Variable(box_feature).cuda()
box_score_variable = Variable(rank_score).cuda()
box_label_variable = Variable(box_label).cuda()
box_box_variable = Variable(box_box).cuda()
all_class_box_rank_score = all_class_box_origin_score[:,
0:1].clone()
all_class_box_label_np = all_class_box_label.numpy()
rank_index = np.where(all_class_box_label_np == 0)[0]
if rank_index.shape[0] == 0:
count += 1
continue
all_class_box_rank_label = torch.ones(all_class_box_label.size())
all_class_box_rank_label[rank_index, :] = -1
all_class_box_rank_label_variable = Variable(
torch.FloatTensor(all_class_box_rank_label)).cuda()
all_class_box_rank_score_variable = Variable(
all_class_box_rank_score).cuda()
all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_feature_variable = Variable(
all_class_box_feature).cuda()
all_class_box_origin_score_variable = Variable(
all_class_box_origin_score).cuda()
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
criterion = nn.BCELoss(weight=all_class_box_weight.cuda())
criterion_rank = nn.MarginRankingLoss()
loss, pos_accuracy, neg_accuracy = train(
box_feature_variable, box_score_variable, box_box_variable,
box_label_variable, all_class_box_feature_variable,
all_class_box_score_variable, all_class_box_box_variable,
all_class_box_label_variable,
all_class_box_origin_score_variable,
all_class_box_rank_score_variable,
all_class_box_rank_label_variable, model, model_optimizer,
criterion, criterion_rank, unique_class_cuda,
unique_class_len_cuda)
count += 1
print_loss_total += loss
print_pos_acc_total += pos_accuracy
print_neg_acc_total += neg_accuracy
end = time.time()
print_time_total += float(end - start)
if count % print_every == 0:
print_loss_avg = print_loss_total / print_every
print_pos_acc_avg = print_pos_acc_total / print_every
print_neg_acc_avg = print_neg_acc_total / print_every
print_time_avg = print_time_total / print_every
print_loss_total = 0
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
# print('aa')
logger.info(
'epoch:{}, iter:{}, lr:{}, avg_time:{:.3f}, avg_loss:{:.10f}, accuracy:{:.3f}, recall:{:.3f}'
.format(epoch_index, count, learning_rate, print_time_avg,
print_loss_avg, print_pos_acc_avg,
print_neg_acc_avg))
if count % save_every == 0:
save_checkpoint(model, epoch_index, count, model_dir)
print_loss_total = 0
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
if epoch_index % step == 0 and epoch_index > 0:
learning_rate = learning_rate * 0.1
for param_group in model_optimizer.param_groups:
param_group['lr'] = learning_rate
def test_solver(model, dataset, output_dir, thread_index, thread_num):
# load checkpoint
load_checkpoint(model, output_dir[0])
New2Old = cvb.load(
'/mnt/lustre/liushu1/mask_rcnn/coco-master/PythonAPI/Newlabel.pkl')
# result_path = os.path.join(output_dir[1], 'result.json')
np.set_printoptions(formatter={'float': '{: 0.4f}'.format})
log_dir = output_dir[1]
# count = 0
logger = solver_log(
os.path.join(
log_dir, 'test_' +
time.strftime('%Y%m%d_%H%M%S', time.localtime()) + '.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
data_num = len(dataset)
for count in range(data_num):
if count % thread_num != thread_index:
continue
data_np = dataset[count]
# input
all_class_box_feature, all_class_box_box, all_class_box_score = torch.FloatTensor(
data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(
data_np[2])
all_class_box_label = data_np[3]
all_class_box_weight = data_np[4]
if all_class_box_weight.shape[0] == 0:
continue
all_class_box_origin_score, all_class_box_origin_box = torch.FloatTensor(
data_np[5]), data_np[6]
unique_class, unique_class_len = torch.FloatTensor(
data_np[7]), torch.FloatTensor(data_np[8])
unique_class_np, unique_class_len_np = data_np[7], data_np[8]
image_id = int(data_np[9])
# if data_np[1].shape[0]==0:
# results.extend(image_id)
bboxes = []
start = time.time()
# all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_feature_variable = Variable(all_class_box_feature).cuda()
all_class_box_origin_score_variable = Variable(
all_class_box_origin_score).cuda()
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
output = test(all_class_box_feature_variable,
all_class_box_box_variable, all_class_box_score_variable,
all_class_box_origin_score_variable, unique_class_cuda,
unique_class_len_cuda, model)
box_score_origin = all_class_box_origin_score_variable.data.cpu(
).numpy().astype(np.float)[:, 0:1].reshape(-1, 1)
# final_score = box_score_origin
# final_score = (box_score_origin + output) / 2
final_score = box_score_origin * output
# final_score = output
for cls_index in range(80):
if unique_class_np[cls_index] == 0:
continue
start_ = int(unique_class_len_np[cls_index])
end_ = int(unique_class_len_np[cls_index + 1])
# info_info = np.concatenate((box_score_origin[start_:end_, 0:1], output[start_:end_, 0:1], final_score[start_:end_,0:1], all_class_box_origin_box[start_:end_, 0:4].astype(np.int), all_class_box_label[start_:end_, 0:1]), axis=1)
# qwe = DataFrame(info_info, columns=['score_origin', 'network', 'final', 'x1', 'y1', 'x2', 'y2', 'label'])
# print(qwe)
# qwe.style.apply(highlight_greaterthan,threshold=0.5,column=['label'], axis=1)
# qwe
# print(qwe.to_string())
# print(qwe.sort_values(by='final'))
# print(qwe.sort_values(by='label'))
# input()
for index in range(start_, end_):
x1, y1, x2, y2 = all_class_box_origin_box[index, 0:4]
score = final_score[index, 0]
# if(score<0.01):
# continue
category_id = New2Old[str(cls_index + 1)][1]
bboxes.append({
'bbox':
[int(x1),
int(y1),
int(x2 - x1 + 1),
int(y2 - y1 + 1)],
'score':
float(score),
'category_id':
category_id,
'image_id':
int(image_id)
})
end = time.time()
print_time = float(end - start)
results.extend(bboxes)
# if count==20:
# break
logger.info('thread_index:{}, index:{}, image_id:{}, cost:{}'.format(
thread_index, count, image_id, print_time))
return results
def solver(model,
data_loader,
n_epochs,
output_dir,
print_every=1,
save_every=1,
learning_rate=0.01,
step=10,
pre_post_weight=1,
load_file=None,
continue_epochs=None,
continue_iters=None):
# plot_losses = []
if continue_epochs is None:
continue_epochs = -1
continue_iters = -1
first_count = None
else:
first_count = continue_iters
print_pre_loss_total = 0 #
print_post_loss_total = 0 #
print_precision_total = [0, 0]
print_recall_total = [0, 0]
print_time_total = 0
model_optimizer = optim.SGD(model.parameters(),
lr=learning_rate,
momentum=0.9)
model_dir = output_dir[0]
log_dir = output_dir[1]
# log
logger = solver_log(
os.path.join(
log_dir, 'train_' +
time.strftime('%Y%m%d_%H%M%S', time.localtime()) + '.log'))
for epoch_index in range(n_epochs):
# print len(data_loader)
if (epoch_index < continue_epochs):
continue
if first_count is None:
count = 0
else:
count = first_count
for all_class_box_feature, all_class_box_box, all_class_box_score, all_class_box_label, all_class_box_weight, all_class_box_origin_score, all_class_box_origin_box, gts_box, unique_class, unique_class_len, img_id in data_loader:
start = time.time()
# print('begin')
all_class_box_feature_variable = Variable(
all_class_box_feature).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_origin_score_variable = Variable(
all_class_box_origin_score).cuda()
all_class_box_origin_box_variable = Variable(
all_class_box_origin_box).cuda()
all_class_box_weight_tensor = all_class_box_weight.cuda()
gts_box_tensor = gts_box.cuda()
# all_class_box_origin_box_variable = Variable(all_class_box_origin_box).cuda()
# ranks = ranks.cuda()
# logger.info(int(img_id.numpy()))
image_id = int(img_id.numpy())
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
loss, precision, recall = train(
all_class_box_feature_variable, all_class_box_box_variable,
all_class_box_score_variable, all_class_box_label_variable,
all_class_box_origin_score_variable,
all_class_box_origin_box_variable, all_class_box_weight_tensor,
gts_box_tensor, unique_class_cuda, unique_class_len_cuda,
model, model_optimizer, pre_post_weight)
count += 1
print_pre_loss_total += loss[0]
print_post_loss_total += loss[1]
print_precision_total[0] += precision[0]
print_precision_total[1] += precision[1]
print_recall_total[0] += recall[0]
print_recall_total[1] += recall[1]
end = time.time()
print_time_total += float(end - start)
if count % print_every == 0:
print_pre_loss_avg = print_pre_loss_total / print_every
print_post_loss_avg = print_post_loss_total / print_every
print_pre_pre_avg = print_precision_total[0] / print_every
print_post_pre_avg = print_precision_total[1] / print_every
print_pre_rec_avg = print_recall_total[0] / print_every
print_post_rec_avg = print_recall_total[1] / print_every
print_time_avg = print_time_total / print_every
print_pre_loss_total = 0
print_post_loss_total = 0
print_precision_total = [0, 0]
print_recall_total = [0, 0]
print_time_total = 0
# print('aa')
logger.info(
'epoch:{}, iter:{}, lr:{}, avg_time:{:.3f}, pre_loss:{:.10f}, post_loss:{:.10f}, pre_pre:{:.3f}, post_pre:{:.3f}, pre_rec:{:.3f}, post_rec:{:.3f}'
.format(epoch_index, count, learning_rate, print_time_avg,
print_pre_loss_avg, print_post_loss_avg,
print_pre_pre_avg, print_post_pre_avg,
print_pre_rec_avg, print_post_rec_avg))
# if count % save_every == 0:
# save_checkpoint(model, epoch_index, count, model_dir)
save_checkpoint(model, epoch_index, count, model_dir)
print_loss_total = 0
print_pos_acc_total = 0
print_neg_acc_total = 0
print_time_total = 0
if epoch_index % step == 0 and epoch_index > 0:
learning_rate = learning_rate * 0.1
for param_group in model_optimizer.param_groups:
param_group['lr'] = learning_rate
def test_solver(model, dataset, output_dir, thread_index, thread_num):
# load checkpoint
load_checkpoint(model, output_dir[0])
New2Old = cvb.load('/mnt/lustre/liushu1/mask_rcnn/coco-master/PythonAPI/Newlabel.pkl')
# result_path = os.path.join(output_dir[1], 'result.json')
np.set_printoptions(formatter={'float': '{: 0.4f}'.format})
log_dir = output_dir[1]
color_map = _get_voc_color_map()
# count = 0
logger = solver_log(os.path.join(log_dir, 'test_'+ time.strftime('%Y%m%d_%H%M%S', time.localtime()) +'.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
data_num = len(dataset)
for count in range(data_num):
if count % thread_num != thread_index:
continue
if count>=100:
break
data_np = dataset[count]
# input
# all_class_box_origin_score, all_class_box_origin_box, unique_class, unique_class_len, img_id
# box_feature, rank_score, box_box = torch.FloatTensor(data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(data_np[2])
all_class_box_feature, all_class_box_box, all_class_box_score = torch.FloatTensor(data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(data_np[2])
all_class_box_label = data_np[3]
all_class_box_weight = data_np[4]
all_class_box_origin_score, all_class_box_origin_box = torch.FloatTensor(data_np[5]), data_np[6]
unique_class, unique_class_len = torch.FloatTensor(data_np[7]), torch.FloatTensor(data_np[8])
unique_class_np, unique_class_len_np = data_np[7], data_np[8]
image_id = int(data_np[9])
img_name = str(image_id).zfill(12)
im_file = '/mnt/lustre/liushu1/qilu_ex/dataset/coco/fpn_bn_base/img/' + img_name + '.jpg'
im = cv2.imread(im_file)
bboxes = []
start = time.time()
# all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_feature_variable = Variable(all_class_box_feature).cuda()
all_class_box_origin_score_variable = Variable(all_class_box_origin_score).cuda()
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
output = test(all_class_box_feature_variable, all_class_box_box_variable, all_class_box_score_variable, all_class_box_origin_score_variable, unique_class_cuda, unique_class_len_cuda, model)
box_score_origin = all_class_box_origin_score_variable.data.cpu().numpy().astype(np.float)[:,0:1].reshape(-1, 1)
# final_score = box_score_origin
# final_score = (box_score_origin + output) / 2
final_score = box_score_origin * output
for cls_index in range(80):
if unique_class_np[cls_index] == 0:
continue
start_ = int(unique_class_len_np[cls_index])
end_ = int(unique_class_len_np[cls_index+1])
# info_info = np.concatenate((box_score_origin[start_:end_, 0:1], output[start_:end_, 0:1], final_score[start_:end_,0:1], all_class_box_origin_box[start_:end_, 0:4].astype(np.int), all_class_box_label[start_:end_, 0:1]), axis=1)
# qwe = DataFrame(info_info, columns=['score_origin', 'network', 'final', 'x1', 'y1', 'x2', 'y2', 'label'])
# print(qwe)
# qwe.style.apply(highlight_greaterthan,threshold=0.5,column=['label'], axis=1)
# qwe
# print(qwe.to_string())
# print(qwe.sort_values(by='final'))
# print(qwe.sort_values(by='label'))
# input()
for index in range(start_, end_):
x1, y1, x2, y2 = all_class_box_origin_box[index, 0:4]
score = final_score[index, 0]
# if(score<0.05):
# continue
category_id = cls_index+1
bboxes.append({'bbox': [int(x1), int(y1), int(x2-x1+1), int(y2-y1+1)], 'score': float(score), 'category_id':category_id, 'image_id':int(image_id)})
for bbox_single in bboxes:
cls_indx = int(bbox_single['category_id'])
x1, y1, w, h = bbox_single['bbox']
score = bbox_single['score']
if score<0.01:
continue
cv2.rectangle(im, (int(x1), int(y1)), (int(x1+w-1), int(y1+h-1)), tuple(color_map[cls_indx, :]), 2)
# count += 1
save_path = os.path.join('/mnt/lustre/liushu1/qilu_ex/Post_vis/', img_name+'.jpg')
# save_gt_path = os.path.join(args.output_dir, img_name+'.jpg')
# cv2.imwrite('/data/luqi/000000156500_proposal.png', im_proposal)
cv2.imwrite(save_path, im)
end = time.time()
print_time = float(end-start)
# results.extend(bboxes)
# if count==20:
# break
logger.info('thread_index:{}, index:{}, image_id:{}, cost:{}'.format(thread_index, count, image_id, print_time))
return results
# cvb.dump(results, result_path)
def test_solver(model, dataset, output_dir, thread_index, thread_num):
# load checkpoint
load_checkpoint(model, output_dir[0])
New2Old = cvb.load(
'/mnt/lustre/liushu1/mask_rcnn/coco-master/PythonAPI/Newlabel.pkl')
# result_path = os.path.join(output_dir[1], 'result.json')
np.set_printoptions(formatter={'float': '{: 0.4f}'.format})
log_dir = output_dir[1]
# count = 0
logger = solver_log(
os.path.join(
log_dir, 'test_' +
time.strftime('%Y%m%d_%H%M%S', time.localtime()) + '.log'))
# logger = solver_log(os.path.join(log_dir, 'test1.log'))
results = []
data_num = len(dataset)
for count in range(data_num):
if count % thread_num != thread_index:
continue
data_np = dataset[count]
# input
# all_class_box_origin_score, all_class_box_origin_box, unique_class, unique_class_len, img_id
# box_feature, rank_score, box_box = torch.FloatTensor(data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(data_np[2])
all_class_box_feature, all_class_box_box, all_class_box_score = torch.FloatTensor(
data_np[0]), torch.FloatTensor(data_np[1]), torch.FloatTensor(
data_np[2])
all_class_box_label = data_np[3]
if all_class_box_label.shape[0] == 0:
continue
all_class_box_weight = data_np[4]
all_class_box_origin_score, all_class_box_origin_box = torch.FloatTensor(
data_np[5]), data_np[6]
unique_class, unique_class_len = torch.FloatTensor(
data_np[7]), torch.FloatTensor(data_np[8])
unique_class_np, unique_class_len_np = data_np[7], data_np[8]
image_id = int(data_np[9])
bboxes = []
start = time.time()
# all_class_box_label_variable = Variable(all_class_box_label).cuda()
all_class_box_score_variable = Variable(all_class_box_score).cuda()
all_class_box_box_variable = Variable(all_class_box_box).cuda()
all_class_box_feature_variable = Variable(all_class_box_feature).cuda()
all_class_box_origin_score_variable = Variable(
all_class_box_origin_score).cuda()
unique_class_cuda = unique_class.cuda()
unique_class_len_cuda = unique_class_len.cuda()
output = test(all_class_box_feature_variable,
all_class_box_box_variable, all_class_box_score_variable,
all_class_box_origin_score_variable, unique_class_cuda,
unique_class_len_cuda, model)
box_score_origin = all_class_box_origin_score_variable.data.cpu(
).numpy().astype(np.float)[:, 0:1].reshape(-1, 1)
# final_score = box_score_origin
save_score = np.concatenate((output, box_score_origin), 1)
save_path = '/mnt/lustre/liushu1/qilu_ex/dataset/test_dev/panet/score/' + str(
image_id).zfill(12) + '.pkl'
cvb.dump(save_score, save_path)
# iii = cvb.load(save_path)
# output = iii[:,0:1]
# box_score_origin = iii[:,1:2]
# final_score = box_score_origin * output
# for cls_index in range(80):
# if unique_class_np[cls_index] == 0:
# continue
# start_ = int(unique_class_len_np[cls_index])
# end_ = int(unique_class_len_np[cls_index+1])
# # info_info = np.concatenate((box_score_origin[start_:end_, 0:1], output[start_:end_, 0:1], final_score[start_:end_,0:1], all_class_box_origin_box[start_:end_, 0:4].astype(np.int), all_class_box_label[start_:end_, 0:1]), axis=1)
# # qwe = DataFrame(info_info, columns=['score_origin', 'network', 'final', 'x1', 'y1', 'x2', 'y2', 'label'])
# # print(qwe)
# # print(qwe.sort_values(by='score_origin'))
# # input()
# for index in range(start_, end_):
# x1, y1, x2, y2 = all_class_box_origin_box[index, 0:4]
# score = final_score[index, 0]
# category_id = New2Old[str(cls_index+1)][1]
# bboxes.append({'bbox': [int(x1), int(y1), int(x2)-int(x1)+1, int(y2)-int(y1)+1], 'score': float(score), 'category_id':category_id, 'image_id':int(image_id)})
# # count += 1
end = time.time()
print_time = float(end - start)
# results.extend(bboxes)
# # if count==20:
# # break
logger.info('thread_index:{}, index:{}, image_id:{}, cost:{}'.format(
thread_index, count, image_id, print_time))
return results
