def train(net, train_loader,optimizer, num_epochs):
log_file = open(args.SAVE_ROOT+"/"+args.Dataset+"_training.log","w",1)
log_print("Training ....", color='green', attrs=['bold'])
# training
train_loss = 0
step_cnt = 0
re_cnt = False
t = Timer()
t.tic()
for epoch in range(1,num_epochs+1):
step = -1
train_loss = 0
for blob in train_loader:
step = step + 1
im_data = blob['data']
gt_data = blob['gt_density']
density_map = net(im_data, gt_data)
loss = net.loss
train_loss += loss.data
step_cnt += 1
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step % disp_interval == 0:
duration = t.toc(average=False)
fps = step_cnt / duration
gt_count = np.sum(gt_data)
density_map = density_map.data.cpu().numpy()
et_count = np.sum(density_map)
utils.save_results(im_data,gt_data,density_map, args.SAVE_ROOT)
log_text = 'epoch: %4d, step %4d, Time: %.4fs, gt_cnt: %4.1f, et_cnt: %4.1f' % (epoch,
step, 1./fps, gt_count,et_count)
log_print(log_text, color='green', attrs=['bold'])
re_cnt = True
if re_cnt:
t.tic()
re_cnt = False
return net
density_map = net(im_data, gt_data, gt_class_label, class_wts)
loss = net.loss
train_loss += loss.data[0]
step_cnt += 1
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step % disp_interval == 0:
duration = t.toc(average=False)
fps = step_cnt / duration
gt_count = np.sum(gt_data)
density_map = density_map.data.cpu().numpy()
et_count = np.sum(density_map)
utils.save_results(im_data, gt_data, density_map, output_dir)
log_text = 'epoch: %4d, step %4d, Time: %.4fs, gt_cnt: %4.1f, et_cnt: %4.1f' % (
epoch, step, 1. / fps, gt_count, et_count)
log_print(log_text, color='green', attrs=['bold'])
re_cnt = True
if re_cnt:
t.tic()
re_cnt = False
if (epoch % 2 == 0):
save_name = os.path.join(
output_dir, '{}_{}_{}.h5'.format(method, dataset_name, epoch))
network.save_net(save_name, net)
#calculate error on the validation dataset
mae, mse = evaluate_model(save_name, data_loader_val)
def test(net,test_path,optimizer, num_epochs, Dataset=args.Dataset):
if Dataset=="fdst":
num_sessions=3
test_len=750
low_limit=451
high_limit=750
else:
num_sessions=8
test_len=2000
low_limit=1201
high_limit=2000
#print(num_sessions)
sessions_list = []
ses_size = 100
for i in range(low_limit, high_limit,ses_size):
sessions_list.append(i)
sessions_list.append(test_len)
#print("test list: ", sessions_list)
for test_inc in range(len(sessions_list)-1):
start_frame = sessions_list[test_inc]
end_frame = sessions_list[test_inc+1]
#print('start:,end:', (start_frame,end_frame))
test_loader = ImageDataLoader_Val_Test(test_path, None,'test_split',start_frame, end_frame, shuffle=False, gt_downsample=True, pre_load=True, Dataset=args.Dataset)
log_file = open(args.SAVE_ROOT+"/"+args.Dataset+"_test.log","w",1)
log_print("test/Self Training ....", color='green', attrs=['bold'])
# training
train_loss = 0
step_cnt = 0
re_cnt = False
t = Timer()
t.tic()
for epoch in range(1,num_epochs+1):
step = -1
train_loss = 0
for blob in test_loader:
step = step + 1
im_data = blob['data']
net.training = False
gt_data = net(im_data)
gt_data = gt_data.cpu().detach().numpy()
net.training = True
density_map = net(im_data, gt_data)
loss = net.loss
train_loss += loss.data
step_cnt += 1
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step % disp_interval == 0:
duration = t.toc(average=False)
fps = step_cnt / duration
gt_count = np.sum(gt_data)
density_map = density_map.data.cpu().numpy()
et_count = np.sum(density_map)
utils.save_results(im_data,gt_data,density_map, args.SAVE_ROOT)
log_text = 'epoch: %4d, step %4d, Time: %.4fs, gt_cnt: %4.1f, et_cnt: %4.1f' % (epoch,
step, 1./fps, gt_count,et_count)
log_print(log_text, color='green', attrs=['bold'])
re_cnt = True
if re_cnt:
t.tic()
re_cnt = False
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = False
session= str(sessions_list[test_inc])
network.save_net(args.SAVE_ROOT+'/'+args.Dataset+ session +'_self_trained_model_test.h5', net)
output_dir = './densitymaps/' + args.Dataset + session
net.cuda()
net.eval()
all_test_loader = ImageDataLoader(test_path, None, 'test_split', shuffle=False, gt_downsample=True, pre_load=True , Dataset=args.Dataset)
for blob in all_test_loader:
im_data = blob['data']
net.training = False
density_map = net(im_data)
density_map = density_map.data.cpu().numpy()
new_dm= density_map.reshape([ density_map.shape[2], density_map.shape[3] ])
np.savetxt(output_dir + '_output_' + blob['fname'].split('.')[0] +'.csv', new_dm, delimiter=',', fmt='%.6f')
return net
cf.batch_size),
steps_per_epoch=(len(only_parasite_generator.files_list) //
cf.batch_size),
epochs=cf.parasite_epochs,
verbose=1,
callbacks=[tensorboard])
model.fit_generator(
generator=overall_generator.generate(),
validation_data=validation_generator.generate(),
validation_steps=(len(validation_generator.files_list) //
cf.batch_size),
steps_per_epoch=(len(overall_generator.files_list) //
cf.batch_size),
epochs=cf.overall_epochs,
verbose=1,
callbacks=[tensorboard])
model.save_weights(os.path.join(cf.train_output_path, 'weights.hdf5'))
elif args.action is 'test':
weights = os.path.join(cf.train_output_path, 'weights.hdf5')
save_results(cf.test_data_path, weights, cf.train_output_path,
cf.save_predictions, cf.save_regions)
if cf.print_overall_table:
overall_table(cf.test_data_path, cf.test_labels_path, weights)
if cf.print_jaccard_table:
jaccard_table(cf.test_data_path, cf.test_labels_path, weights)
def word_translation(self):
"""
Evaluation on word translation.
"""
# mapped word embeddings
all_emb = {
l2: apply_mapping(self.mapping[l2],
self.embs[l2].weight).data.cpu()
for l2 in self.params.langs
}
results = defaultdict(dict)
# for computational efficiency, iterate over source languages and calculate all methods for each one
for src_lang in self.params.langs:
logger.info('\n\n\n\nSource Language: {}\n\n\n\n'.format(src_lang))
torch.cuda.empty_cache()
# get source queries
paths = self.get_dico_paths(src_lang)
query_ids = self.aggregate_query_ids(paths, src_lang)
if query_ids is None:
logger.info(
'Warning: No test dictionary was found for source language {}. Skipping!'
.format(src_lang))
continue
method = 'csls_knn_10'
# init translation
init_trans, top_scores = BI_translation(src_lang,
query_ids,
method,
all_emb,
cuda=self.params.cuda)
for inf_met in self.params.multilingual_inference_method:
logger.info('\n\nMultilingual inference method: {}\n\n'.format(
inf_met))
# improve source word representation, and re-translate
if inf_met != 'BI':
updated_trans, used_langs = update_translation_for_all_langs(
self.params.langs,
src_lang,
query_ids,
all_emb,
init_trans,
method,
inf_met,
top_scores,
cuda=self.params.cuda)
else:
used_langs = None
updated_trans = init_trans
# re-arrange translations for convenience
translation_by_src_id, used_langs_by_src_id = self.translation_by_src_id(
updated_trans, used_langs, src_lang)
# calcualte accuracy, and matching per source word
for tgt_lang, path in paths.items():
pair_result = self.get_pair_accuracy(
path, src_lang, self.lang_dico[src_lang].word2id,
tgt_lang, self.lang_dico[tgt_lang].word2id,
translation_by_src_id, method)
if inf_met != 'BI':
self.print_aux_statistics(src_lang, tgt_lang, path,
used_langs_by_src_id)
results[(src_lang, tgt_lang)][inf_met] = pair_result
save_results(self.params, results,
self.params.multilingual_inference_method)
model_path = './saved_models/mcnn_shtechA_1998.h5'
output_dir = './output/'
net = CrowdCounter()
"""Load trained model"""
trained_model = os.path.join(model_path)
network.load_net(trained_model, net)
net.cuda()
net.eval()
gt_data = None
"""Load image from data_path"""
im_data = read_image(data_path)
"""Calculate density map"""
density_map = net(im_data, gt_data)
"""convert to numpy array"""
density_map = density_map.data.cpu().numpy()
"""estimation count from density map"""
et_count = np.sum(density_map)
"""Save result: density map; stack input image and density map"""
utils.save_results(im_data, int(et_count), density_map, output_dir)
utils.save_density_map(density_map, output_dir)
import matplotlib.pyplot as plt
img = cv2.imread('./output/results.png')
plt.imshow(img, cmap='gray')
plt.show()
print et_count
def main():
# define output folder
output_dir = './saved_models/'
log_dir = './mae_mse/'
checkpoint_dir = './checkpoint/'
train_path = '/home/jake/Desktop/Projects/Python/dataset/SH_B/cooked/train/images'
train_gt_path = '/home/jake/Desktop/Projects/Python/dataset/SH_B/cooked/train/ground_truth'
val_path = '/home/jake/Desktop/Projects/Python/dataset/SH_B/cooked/val/images'
val_gt_path = '/home/jake/Desktop/Projects/Python/dataset/SH_B/cooked/val/ground_truth'
# last checkpoint
checkpointfile = os.path.join(checkpoint_dir, 'checkpoint.94.pth.tar')
# some description
method = 'mcnn'
dataset_name = 'SH_B'
# log file
f_train_loss = open(os.path.join(log_dir, "train_loss.csv"), "a+")
f_val_loss = open(os.path.join(log_dir, "val_loss.csv"), "a+")
# Training configuration
start_epoch = 0
end_epoch = 97
lr = 0.00001
# momentum = 0.9
disp_interval = 1000
# log_interval = 250
# Flag
CONTINUE_TRAIN = True
# Tensorboard config
# use_tensorboard = False
# save_exp_name = method + '_' + dataset_name + '_' + 'v1'
# remove_all_log = False # remove all historical experiments in TensorBoard
# exp_name = None # the previous experiment name in TensorBoard
# -----------------------------------------------------------------------------------------
rand_seed = 64678
if rand_seed is not None:
np.random.seed(rand_seed)
torch.manual_seed(rand_seed)
torch.cuda.manual_seed(rand_seed)
# Define network
net = CrowdCounter()
network.weights_normal_init(net, dev=0.01)
# net.cuda()
net.train()
# params = list(net.parameters())
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, net.parameters()), lr=lr)
if not os.path.exists(output_dir):
os.mkdir(output_dir)
# # tensorboad
# use_tensorboard = use_tensorboard and CrayonClient is not None
# if use_tensorboard:
# cc = CrayonClient(hostname='127.0.0.1')
# if remove_all_log:
# cc.remove_all_experiments()
# if exp_name is None:
# exp_name = save_exp_name
# exp = cc.create_experiment(exp_name)
# else:
# exp = cc.open_experiment(exp_name)
# training param
if CONTINUE_TRAIN:
net, optimizer, start_epoch = utils.load_checkpoint(
net, optimizer, filename=checkpointfile)
train_loss = 0
step_cnt = 0
re_cnt = False
t = Timer()
t.tic()
# Load data
data_loader = ImageDataLoader(
train_path, train_gt_path, shuffle=True, gt_downsample=True, pre_load=True)
data_loader_val = ImageDataLoader(
val_path, val_gt_path, shuffle=False, gt_downsample=True, pre_load=True)
best_mae = sys.maxsize
# Start training
for this_epoch in range(start_epoch, end_epoch-1):
step = -1
train_loss = 0
for blob in data_loader:
step += 1
img_data = blob['data']
gt_data = blob['gt_density']
et_data = net(img_data, gt_data)
loss = net.loss
train_loss += loss.data
step_cnt += 1
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step % disp_interval == 0:
duration = t.toc(average=False)
fps = step_cnt / duration
gt_count = np.sum(gt_data)
et_data = et_data.data.cpu().numpy()
et_count = np.sum(et_data)
utils.save_results(img_data, gt_data, et_data, output_dir,
fname="{}.{}.png".format(this_epoch, step))
log_text = 'epoch: %4d, step %4d, Time: %.4fs, gt_cnt: %4.1f, et_cnt: %4.1f' % (this_epoch,
step, 1./fps, gt_count, et_count)
log_print(log_text, color='green', attrs=['bold'])
re_cnt = True
if re_cnt:
t.tic()
re_cnt = False
# Save checkpoint
state = {'epoch': this_epoch, 'state_dict': net.state_dict(),
'optimizer': optimizer.state_dict()}
cp_filename = "checkpoint.{}.pth.tar".format(this_epoch)
torch.save(state, os.path.join(checkpoint_dir, cp_filename))
# ========================== END 1 EPOCH==================================================================================
train_mae, train_mse = evaluate_network(net, data_loader)
f_train_loss.write("{},{}\n".format(train_mae, train_mse))
log_text = 'TRAINING - EPOCH: %d, MAE: %.1f, MSE: %0.1f' % (
this_epoch, train_mae, train_mse)
log_print(log_text, color='green', attrs=['bold'])
# =====================================================VALIDATION=========================================================
# calculate error on the validation dataset
val_mae, val_mse = evaluate_network(net, data_loader_val)
f_val_loss.write("{},{}\n".format(val_mae, val_mse))
log_text = 'VALIDATION - EPOCH: %d, MAE: %.1f, MSE: %0.1f' % (
this_epoch, val_mae, val_mse)
log_print(log_text, color='green', attrs=['bold'])
# SAVE model
is_save = False
if val_mae <= best_mae:
if val_mae < best_mae:
is_save = True
best_mae = val_mae
best_mse = val_mse
else:
if val_mse < best_mse:
is_save = True
best_mse = val_mse
if is_save:
save_name = os.path.join(output_dir, '{}_{}_{}.h5'.format(
method, dataset_name, this_epoch))
network.save_net(save_name, net)
best_model = '{}_{}_{}.h5'.format(method, dataset_name, this_epoch)
log_text = 'BEST MAE: %0.1f, BEST MSE: %0.1f, BEST MODEL: %s' % (
best_mae, best_mse, best_model)
log_print(log_text, color='green', attrs=['bold'])
# if use_tensorboard:
# exp.add_scalar_value('MAE', mae, step=epoch)
# exp.add_scalar_value('MSE', mse, step=epoch)
# exp.add_scalar_value('train_loss', train_loss /
# data_loader.get_num_samples(), step=epoch)
f_train_loss.close()
f_val_loss.close()
#load test data
data_loader = ImageDataLoader(data_path,
gt_path,
shuffle=False,
gt_downsample=True,
pre_load=True)
for blob in data_loader:
im_data = blob['data']
gt_data = blob['gt_density']
density_map = net(im_data, gt_data)
density_map = density_map.data.cpu().numpy()
gt_count = np.sum(gt_data)
et_count = np.sum(density_map)
mae += abs(gt_count - et_count)
mse += ((gt_count - et_count) * (gt_count - et_count))
print("Ground truth: {:0.2f}, Estimate: {:0.2f}".format(
gt_count, et_count))
if vis:
utils.display_results(im_data, gt_data, density_map)
if save_output:
utils.save_results(im_data, gt_data, density_map, output_dir,
'output_' + blob['fname'].split('.')[0] + '.png')
mae = mae / data_loader.get_num_samples()
mse = np.sqrt(mse / data_loader.get_num_samples())
print('\nMAE: %0.2f, MSE: %0.2f' % (mae, mse))
# f = open(file_results, 'w')
# f.write('MAE: %0.2f, MSE: %0.2f' % (mae,mse))
# f.close()
