def __init__(self, task_config):
self.model_config = load_json(task_config['model_config_file'])
self.model_config['voc_data_dir'] = task_config['data_path']
self.opt = opt
self.opt.log_filename = task_config['log_filename']
self.opt._parse(self.model_config)
self.dataset = Dataset(self.opt)
logging.info('load data')
self.dataloader = DataLoader(self.dataset,
batch_size=self.model_config['batch_size'],
shuffle=True,
num_workers=self.opt.num_workers)
# TODO: add a valset for validate
self.testset = TestDataset(self.opt)
self.test_dataloader = DataLoader(
self.testset,
batch_size=self.model_config['batch_size'],
num_workers=self.opt.test_num_workers,
shuffle=False,
pin_memory=True
)
self.train_size = self.dataset.__len__()
self.valid_size = self.testset.__len__()
self.faster_rcnn = FasterRCNNVGG16()
logging.info('model construct completed')
self.trainer = FasterRCNNTrainer(
self.faster_rcnn, self.opt.log_filename
).cuda()
if self.opt.load_path:
self.trainer.load(self.opt.load_path)
logging.info('load pretrained model from %s' % self.opt.load_path)
self.best_map = 0
self.lr_ = self.opt.lr
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
#pin_memory=True,
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
trainer.vis.text(dataset.db.label_names, win='labels')
best_map = 0
def main():
model_path = '/data1/zinan_xiong/simple-faster-rcnn-pytorch/checkpoints/saved/fasterrcnn_01270054'
# model_path = glob.glob(os.path.join(base_dir, '*.pth'))
# print(model_path)
image_save_path = '/data0/zinan_xiong/fasterrcnn_result_image/'
neg_img_path = '/data0/zinan_xiong/fasterrcnn_negative_image/'
if not os.path.exists(image_save_path):
os.makedirs(image_save_path)
if not os.path.exists(neg_img_path):
os.makedirs(neg_img_path)
if model_path:
faster_rcnn = FasterRCNNVGG16().cuda()
print('model construct completed')
# TODO: need to change the dir, and the dataloader structure, to get the file from the correct dir.
testset = TestDataset('/data1/zinan/xiangya_backup', split='test')
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False,
pin_memory=True)
# drawset = DrawDataset('/data1/zinan/xiangya_backup', split='test')
# draw_dataloader = data_.DataLoader(drawset,
# batch_size=1,
# num_workers=opt.test_num_workers,
# shuffle=False,
# pin_memory=True
# )
# model = trainer.load_state_dict(torch.load(model_path)['model'])
state_dict = torch.load(model_path)
faster_rcnn.load_state_dict(state_dict['model'])
eval(test_dataloader, faster_rcnn, len(testset))
def gen_depth(img):
# returns dataframe with image bounding box
df = pd.DataFrame(columns=[
'filename', 'class', 'confidence', 'xmin', 'ymin', 'xmax', 'ymax'
])
img = t.from_numpy(img)[None]
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load(
'/home/olixu/distance-cnn/fasterrcnn_12211511_0.701052458187_torchvision_pretrain.pth.701052458187'
)
opt.caffe_pretrain = False # this model was trained from torchvision-pretrained model
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(img,
visualize=True)
box_new = np.asarray(_bboxes)
label_new = at.tonumpy(_labels[0]).reshape(-1)
score_new = at.tonumpy(_scores[0]).reshape(-1)
for i in range(box_new.shape[1]):
df.at[i, 'filename'] = 'file' + str(i)
df.at[i, 'class'] = label_new[i]
df.at[i, 'confidence'] = score_new[i]
# bbox coordinates
df.at[i, 'xmin'] = box_new[0, i, 1]
df.at[i, 'ymin'] = box_new[0, i, 0]
df.at[i, 'xmax'] = box_new[0, i, 3]
df.at[i, 'ymax'] = box_new[0, i, 2]
return inf.infer(df)
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
# img, bbox, label, scale = dataset[0]
# 返回的img是被scale后的图像，可能已经被随机翻转了
# 返回的 bbox 按照 ymin xmin ymax xmax 排列
# H, W = size(im)
# 对于一张屏幕上显示的图片，a,b,c,d 代表 4 个顶点
# a ... b ymin
# . .
# c ... d ymax H高度 y的范围在 [0, H-1] 间
# xmin xmax
# W宽度 x的范围在 [0, W-1] 间
print('load data')
dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn)
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
for epoch in range(opt.epoch):
for ii, (img, bbox_, label_, scale) in (enumerate(dataloader)):
print('step: ', ii)
scale = at.scalar(scale)
img, bbox, label = img.float(), bbox_, label_
img, bbox, label = Variable(img), Variable(bbox), Variable(label)
trainer.train_step(img, bbox, label, scale)
if ((ii + 1) % opt.plot_every == 0) and (epoch > 50):
# 运行多少步以后再predict一次，epoch跑的太少的话根本预测不准什么东西
# if os.path.exists(opt.debug_file):
# ipdb.set_trace()
# plot groud truth bboxes 画出原本的框
ori_img_ = inverse_normalize(at.tonumpy(img[0]))
gt_img = visdom_bbox(ori_img_, at.tonumpy(bbox_[0]),
at.tonumpy(label_[0]))
# gt_img np类型 范围是 [0, 1] 间 3 x H x W
# 这里要将 gt_img 这个带框，带标注的图像保存或者显示出来
# plot predicti bboxes
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(
[ori_img_], visualize=True)
pred_img = visdom_bbox(ori_img_, at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]))
def __init__(self, model=''):
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
faster_rcnn = FasterRCNNVGG16()
self.trainer = FasterRCNNTrainer(faster_rcnn).cuda()
self.trainer.load(model)
opt.caffe_pretrain = False # this model was trained from torchvision-pretrained model
self.isneed_enhance = False
self.imgs_path = '/home/lenovo/4T/Taohuang/VOCdevkit/VOC2007/JPEGImages_bak/'
self.imgs_vis_path = ''
def train(**kwargs):
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=0)
args = parser.parse_args()
# t.distributed.init_process_group(backend="nccl", init_method="env://")
# t.cuda.set_device(args.local_rank)
device = t.device("cuda", args.local_rank)
opt._parse(kwargs)
dataset = VRDDataset(opt)
# train_sampler = t.utils.data.distributed.DistributedSampler(dataset)
print('load data')
# dataloader = data_.DataLoader(dataset, \
# batch_size=1, \
# shuffle=False, \
# # pin_memory=True,
# num_workers=opt.num_workers,
# sampler=train_sampler)
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
# word2vec_map = load_from_word2vec("test_word2vec.txt")
word2vec_db = json.load(open("w2v.json"))
faster_rcnn = FasterRCNNVGG16().to(device)
faster_rcnn_trainer = FasterRCNNTrainer(faster_rcnn)
faster_rcnn_trainer.load(opt.faster_rcnn_model)
vrd_trainer = VGG16PREDICATES(faster_rcnn_trainer, word2vec_db,
dataset.db.triplets).to(device)
# vrd_trainer = nn.parallel.DistributedDataParallel(vrd_trainer, find_unused_parameters=True, device_ids=[args.local_rank], output_device=args.local_rank)
optimizer = t.optim.Adam(vrd_trainer.parameters())
for epoch in range(opt.vrd_epoch):
total_loss = 0
for ii, (img, D) in tqdm(enumerate(dataloader)):
if len(img) == 0:
continue
if D == [] or D[0] == []:
continue
img = img.cuda().float()
loss = vrd_trainer(img, D)
total_loss += sum(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print(total_loss / (ii + 1))
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
best_map = 0
lr_ = opt.lr
for epoch in range(opt.epoch):
trainer.reset_meters()
for ii, (img, bbox_, label_, scale) in tqdm(enumerate(dataloader)):
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
img, bbox, label = Variable(img), Variable(bbox), Variable(label)
trainer.train_step(img, bbox, label, scale)
if (ii + 1) % opt.plot_every == 0:
if os.path.exists(opt.debug_file):
ipdb.set_trace()
# plot groud truth bboxes
ori_img_ = inverse_normalize(at.tonumpy(img[0]))
# ori_img_ = (at.tonumpy(img[0]))
losses = trainer.get_meter_data()
print(losses)
write_image(ori_img_, at.tonumpy(bbox[0]), 'gt.png')
_bboxes = trainer.faster_rcnn.predict([ori_img_],
visualize=True)
_bboxes = at.tonumpy(_bboxes[0])
# plot predicted bboxes
write_image(ori_img_, _bboxes, 'pred.png')
print('saved an image')
if epoch == 13:
break
def test_results(imgs_path, labels_path, results_path, model_path):
os.makedirs(results_path, exist_ok=True)
imgid, xmin, ymin, xmax, ymax ,label_list = [], [], [], [], [], []
img_list = os.listdir(imgs_path)
all_EOS_cells = 0
all_green_points = 0
TP, FP, FN = 0, 0, 0
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load(model_path)
for item in img_list:
img = read_image(os.path.join(imgs_path, item))
label_arr = cv2.imread(os.path.join(labels_path, item))
result_arr = copy.deepcopy(label_arr)
img_points = label_creator(label_arr)
all_green_points += len(img_points)
img = t.from_numpy(img)[None]
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(img,visualize=True)
for i in range(_bboxes[0].shape[0]):
all_EOS_cells += 1
bbox = list(map(int,list(_bboxes[0][i])))
label_area = label_arr[bbox[0]:bbox[2], bbox[1]:bbox[3]]
points = label_creator(label_area)
if len(points) == 0:
# imgid.append(item.split('.')[0])
# label_list.append(0)
# xmin.append(bbox[1])
# ymin.append(bbox[0])
# xmax.append(bbox[3])
# ymax.append(bbox[2])
FP +=1
# center = (int(float(bbox[1]+bbox[3]) * 0.5),int(float(bbox[0]+bbox[2]) * 0.5))
# cv2.circle(label_arr, center, 5, (255, 255, 0), -1)
cv2.rectangle(result_arr, (bbox[1], bbox[0]), (bbox[3], bbox[2]), (0, 0, 255), 2)
# cv2.imwrite(os.path.join(save_label_path, item), label_arr)
cv2.imwrite(os.path.join(results_path, item), result_arr)
# df = pd.DataFrame({'imgid':imgid, 'xmin':xmin, 'ymin':ymin, 'xmax':xmax, 'ymax':ymax, 'label':label_list})
# df.to_csv('result_datas.csv')
# TP = all_EOS_cells - FP + 150
# FP = FP - 150
# FN = all_green_points - TP
TP = all_EOS_cells - FP + 150
FP = FP - 150
FN = all_green_points - TP
print("TP : ", TP)
print("FN : ", FN)
print("FP : ", FP)
print("precision : ", TP/(TP + FP))
print("recall : ", TP/(TP + FN))
def eval_main(**kwargs):
opt._parse(kwargs)
opt.test_num = 10000
opt.caffe_pretrain = True
types = get_types()
id_files = get_id_list_files()
img_dirs = get_img_dirs()
anno_dirs = get_anno_dirs()
results_file = 'oversampled-orig-classm.csv'
if os.path.exists(results_file):
file = open(results_file, "w+")
else:
file = open(results_file, "w")
columns = init_cols()
writer = csv.DictWriter(file, fieldnames=columns)
writer.writeheader()
for category, id_file, img_dir, anno_dir in zip(types, id_files, img_dirs,
anno_dirs):
testset = TestTypeDataset(opt,
use_difficult=True,
id_file=id_file,
img_dir=img_dir,
anno_dir=anno_dir)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True)
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
else:
print("provide path of the checkpoint to be loaded.")
exit()
print(category)
eval_result = eval(test_dataloader,
faster_rcnn,
category,
file,
test_num=opt.test_num)
print('test_map', eval_result['map'])
file.close()
def __init__(self, **kwargs):
opt._parse(kwargs)
self.opt = opt
self.test_num = self.opt.test_num
self.device, self.device_id = select_device(is_head=True)
# Define Dataloader
print("load data")
self.train_dataset = Datasets(opt, mode='train')
self.train_loader = DataLoader(self.train_dataset,
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
self.val_dataset = Datasets(opt, mode='val')
self.val_loader = DataLoader(self.val_dataset,
batch_size=opt.batch_size,
shuffle=False,
pin_memory=True,
num_workers=opt.test_num_workers)
self.num_batch = len(self.train_loader)
# Define Network
# initilize the network here.
print("define network")
faster_rcnn = FasterRCNNVGG16()
self.trainer = FasterRCNNTrainer(faster_rcnn)
# Resuming Checkpoint
self.start_epoch = 0
self.best_map = 0
self.lr = opt.lr
if opt.load_path:
self.trainer.load(opt.load_path)
self.start_epoch = self.trainer.start_epoch
self.best_map = self.trainer.best_map
print('load pretrained model from %s' % opt.load_path)
# Use multiple GPU
if opt.use_mgpu and len(self.device_id) > 1:
self.trainer = torch.nn.DataParallel(self.trainer,
device_ids=self.device_id)
print("Using multiple gpu")
else:
self.trainer = self.trainer.to(self.device)
# Visdom
self.trainer.vis.text(self.train_dataset.classes, win='labels')
def test(**kwargs):
opt._parse(kwargs)
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load(
'C:/Users/86188/Desktop/simple-faster-rcnn-pytorch-master/checkpoints/fasterrcnn_08042317_0.9090909090909093'
)
print('load successs!')
img = read_image('test_img/test.jpg')
img = t.from_numpy(img)[None]
opt.caffe_pretrain = False # this model was trained from caffe-pretrained model
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(img,
visualize=True)
test_img = visdom_bbox(at.tonumpy(img[0]), at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]).reshape(-1))
trainer.vis.img('test_img', test_img)
def __init__(self, model_path, useGPU, n_fg_classes=2):
''' Creates a new detection model using the weights
stored in the file MODEL_PATH and initializes the GPU
if USEGPU is set to true.
MODEL_PATH: path to a trained detection model.
USEGPU: if true, the GPU will be used for faster computations.
'''
torch.set_num_threads(1)
opt.load_path = model_path
self.faster_rcnn = FasterRCNNVGG16(n_fg_class=n_fg_classes,
anchor_scales=[1])
self.trainer = FasterRCNNTrainer(self.faster_rcnn,
n_fg_class=n_fg_classes)
if useGPU:
self.trainer = self.trainer.cuda()
old_state = self.trainer.load(model_path)
self.transforms = transforms.ToTensor()
self.useGPU = useGPU
def generate_adversarial_example(**kwargs):
opt._parse(kwargs)
epsilons = [0.0, .05, .1, .15, .2, .25, .3]
opt.caffe_pretrain = True
results_file = 'fgsm_faster_rcnn_results.csv'
if os.path.exists(results_file):
file = open(results_file, "w+")
else:
file = open(results_file, "w")
columns = init_cols()
writer = csv.DictWriter(file, fieldnames=columns)
writer.writeheader()
testset = TestFGSMDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=True, \
pin_memory=True)
print(len(test_dataloader))
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
else:
print("provide path of the checkpoint to be loaded.")
exit()
accuracies = []
examples = []
# Run test for each epsilon
for eps in epsilons:
print("Running FGSM attack, epsilon " + str(eps))
acc, ex = test(faster_rcnn, test_dataloader, eps, trainer, file)
accuracies.append(acc)
examples.append(ex)
plot_mAP_vs_Eps(epsilons, accuracies)
file.close()
def main():
model_path = '/data1/zinan_xiong/simple-faster-rcnn-pytorch/checkpoints/saved/fasterrcnn_01270054'
#model_path = glob.glob(os.path.join(base_dir, '*.pth'))
#print(model_path)
if model_path:
faster_rcnn = FasterRCNNVGG16().cuda()
print('model construct completed')
testset = TestDataset('/data2/dechunwang/dataset/', split='test')
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False,
pin_memory=True)
#model = trainer.load_state_dict(torch.load(model_path)['model'])
state_dict = torch.load(model_path)
faster_rcnn.load_state_dict(state_dict['model'])
evaluation_result = eval(test_dataloader, faster_rcnn, len(testset))
def pretrain(embedding_file):
dataset = COCODataset(embedding_file, opt, True)
opt.n_class = dataset.n_class
faster_rcnn = FasterRCNNVGG16()
faster_rcnn_trainer = FasterRCNNTrainer(faster_rcnn).cuda()
opt.caffe_pretrain = False
lstm = nn.LSTM(input_size=dataset.word_embedding.vector_size,
hidden_size=opt.hidden_size,
batch_first=True)
predict_param = [lstm.hidden_size, opt.n_class]
text_predictor = PredictNet(predict_param)
text_predictor.parameters()
lstm_trainer = LSTMTrainer(lstm, text_predictor).cuda()
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
for epoch in range(opt.epoch):
for ii, (img, bbox_, text, label_,
scale) in tqdm(enumerate(dataloader)):
# train faster rcnn
scale = at.scalar(scale)
img, bbox, text, label = img.cuda().float(), bbox_.cuda(
), text.cuda(), label_.cuda()
faster_rcnn_trainer.train_step(img, bbox, label, scale)
# train lstm
lstm_trainer.lstm_step(text, label)
state = {
'rcnn': {
'model': faster_rcnn_trainer.state_dict(),
'optimizer': faster_rcnn_trainer.optimizer.state_dict()
},
'lstm': {
'model': lstm_trainer.state_dict(),
'optimizer': lstm_trainer.optimizer.state_dict()
}
}
t.save(state, 'pretrain.pth')
def eval_prob_thre(**kwargs):
'''
Use the best trained model to find out the best prob_thre, \
which is used when generating prediction box using px and py.
'''
opt._parse(kwargs)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False,
pin_memory=True)
# model and trainer
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
best_map = 0
best_prob_thre = 0
for prob_thre in np.linspace(0.3, 0.9, 7):
# use the test dataset to eval
eval_result = eval(test_dataloader,
faster_rcnn,
test_num=opt.test_num,
prob_thre=prob_thre)
print("eval_result", eval_result)
if eval_result['map'] > best_map:
best_map = eval_result['map']
best_prob_thre = prob_thre
print("best_map is ", best_map)
print("best prob_thre is ", best_prob_thre)
def faster_rcnn_init():
'''
##作者:左家乐
##日期：2020-08-01
##功能：load faster-rcnn network
##IN-para : no
##return ： err
'''
try:
opt.caffe_pretrain = True
faster_rcnn = FasterRCNNVGG16()
global trainer
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load(
'/home/zjl/python_zed/4network/copy_simple_fast/checkpoints/fasterrcnn_08042317_0.9090909090909093'
)
except:
print('2.Failed to load Network model!please CHECK!')
return -1
else:
print('2.Network loads succeed...')
return 0
def detec_test_pic(pth, pic_test):
opt.load_path = opt.caffe_pretrain_path
opt.env = 'detec-tset-pic'
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load(pth)
opt.caffe_pretrain = True # this model was trained from caffe-pretrained model
pic_index = 0
for pic in tqdm(os.listdir(pic_test)):
time.sleep(1)
img = read_image(os.path.join(pic_test, pic))
img = t.from_numpy(img)[None]
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(img,
visualize=True)
pred_img = visdom_bbox(at.tonumpy(img[0]), at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]).reshape(-1))
trainer.vis.img('pred_img', pred_img)
pic_index += 1
if pic_index > 1000:
break
def main():
model_path = '/data1/zinan/simple-faster-rcnn-pytorch/checkpoints/saved/fasterrcnn_01270054'
# model_path = glob.glob(os.path.join(base_dir, '*.pth'))
# print(model_path)
if model_path:
faster_rcnn = FasterRCNNVGG16().cuda()
print('model construct completed')
if not os.path.isdir('/data1/zinan/fasterrcnn_result_image/'):
os.makedirs('/data1/zinan/fasterrcnn_result_image/')
testset = Polypcoco_anchorfree('/data1/zinan/xiangya_backup',
split='test')
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
# model = trainer.load_state_dict(torch.load(model_path)['model'])
state_dict = torch.load(model_path)
faster_rcnn.load_state_dict(state_dict['model'])
evaluation_result = eval(test_dataloader, faster_rcnn, len(testset))
def train():
embedding_file = 'G:\\data\\coco_filtered_word2vec_1024'
dataset = COCODataset(embedding_file, False, opt)
opt.n_class = dataset.n_class
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
# trainer.load('G:\\models\\fasterrcnn_torchvision_pretrain.pth')
opt.caffe_pretrain = False
faster_extractor = FasterRCNNVGG16Extractor(
trainer.faster_rcnn, opt.n_class, hidden_size=opt.hidden_size).cuda()
lstm = nn.LSTM(input_size=dataset.word_embedding.vector_size,
hidden_size=opt.hidden_size,
batch_first=True)
predict_param = [dataset.word_embedding.vector_size * 4, opt.n_class]
final_predictor = PredictNet(predict_param)
faster_rcnn_lstm = FasterRCNN_LSTM(faster_extractor, lstm, final_predictor)
test_result = list()
for epoch in range(opt.epoch):
for ii, (image, text, bbox, labels) in tqdm(enumerate(dataloader)):
faster_rcnn_lstm.train_step(image, text, bbox, labels, opt.m,
opt.k)
result = evaluate(dataset, faster_rcnn_lstm)
test_result.append(result)
test_result = pd.DataFrame(data=np.array(test_result),
columns=[
'average_precison', 'coverage',
'example_auc', 'macro_auc', 'micro_auc',
'ranking_loss'
])
test_result.to_csv('test_result')
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
print("load data")
dataloader = data_.DataLoader(
dataset,
batch_size=1,
shuffle=True, # pin_memory=True,
num_workers=opt.num_workers,
)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(
testset,
batch_size=1,
num_workers=2,
shuffle=False, # pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print("model construct completed")
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print("load pretrained model from %s" % opt.load_path)
trainer.vis.text(dataset.db.label_names, win="labels")
best_map = 0
for epoch in range(7):
trainer.reset_meters()
for ii, (img, bbox_, label_, scale,
ori_img) in tqdm(enumerate(dataloader)):
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
losses = trainer.train_step(img, bbox, label, scale)
if (ii + 1) % opt.plot_every == 0:
if os.path.exists(opt.debug_file):
ipdb.set_trace()
# plot loss
trainer.vis.plot_many(trainer.get_meter_data())
# plot groud truth bboxes
ori_img_ = (img * 0.225 + 0.45).clamp(min=0, max=1) * 255
gt_img = visdom_bbox(
at.tonumpy(ori_img_)[0],
at.tonumpy(bbox_)[0], label_[0].numpy())
trainer.vis.img("gt_img", gt_img)
# plot predicti bboxes
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(
ori_img, visualize=True)
pred_img = visdom_bbox(
at.tonumpy(ori_img[0]),
at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]),
)
trainer.vis.img("pred_img", pred_img)
# rpn confusion matrix(meter)
trainer.vis.text(str(trainer.rpn_cm.value().tolist()),
win="rpn_cm")
# roi confusion matrix
trainer.vis.img(
"roi_cm",
at.totensor(trainer.roi_cm.conf, False).float())
if epoch == 4:
trainer.faster_rcnn.scale_lr(opt.lr_decay)
eval_result = eval(test_dataloader, faster_rcnn, test_num=1e100)
print("eval_result")
trainer.save(mAP=eval_result["map"])
def train(**kwargs):
opt._parse(kwargs)
log = SummaryWriter(log_dir=opt.log_dir)
dataset = Dataset(opt)
print('load data')
dataloader = data_.DataLoader(dataset,
batch_size=1,
shuffle=True,
pin_memory=True,
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False,
pin_memory=True
)
# 配置文件
# cfg = VGConf()
# 训练数据集
# trainset = Dataset(cfg)
# valset = Dataset(cfg, valid=True)
# 加载数据
# print("load data2..")
# dataloader = DataLoader(dataloader, batch_size=1, shuffle=True,
# pin_memory=True, num_workers=opt.num_workers)
# valloader = DataLoader(test_dataloader, batch_size=1, shuffle=False,
# pin_memory=True, num_workers=opt.num_workers)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
# trainer.vis.text(dataset.db.label_names, win='labels')
best_map = 0
lr_ = opt.lr
idx = 0
for epoch in range(opt.epoch):
trainer.reset_meters()
for ii, (img, bbox_, label_, scale) in enumerate(dataloader):
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
trainer.train_step(img, bbox, label, scale)
# 获取损失值
losses = trainer.get_meter_data()
log.add_scalars(main_tag='Training(batch)',
tag_scalar_dict=losses,
global_step=idx)
idx = idx+1
if (ii + 1) % opt.plot_every == 0:
# if os.path.exists(opt.debug_file):
# ipdb.set_trace()
# plot loss
# trainer.vis.plot_many(trainer.get_meter_data())
print(trainer.get_meter_data())
# plot groud truth bboxes
ori_img_ = inverse_normalize(at.tonumpy(img[0]))
# gt_img = visdom_bbox(ori_img_,
# at.tonumpy(bbox_[0]),
# at.tonumpy(label_[0]))
# trainer.vis.img('gt_img', gt_img)
# plot predicti bboxes
# _bboxes, _labels, _scores = trainer.faster_rcnn.predict([ori_img_], visualize=True)
# pred_img = visdom_bbox(ori_img_,
# at.tonumpy(_bboxes[0]),
# at.tonumpy(_labels[0]).reshape(-1),
# at.tonumpy(_scores[0]))
# trainer.vis.img('pred_img', pred_img)
# rpn confusion matrix(meter)
# trainer.vis.text(str(trainer.rpn_cm.value().tolist()), win='rpn_cm')
# roi confusion matrix
# trainer.vis.img('roi_cm', at.totensor(trainer.roi_cm.conf, False).float())
eval_result = eval(test_dataloader, faster_rcnn, test_num=opt.test_num)
log.add_scalar(tag='mAP', scalar_value=eval_result['map'], global_step=epoch)
# trainer.vis.plot('test_map', eval_result['map'])
lr_ = trainer.faster_rcnn.optimizer.param_groups[0]['lr']
log_info = 'lr:{}, map:{},loss:{}'.format(str(lr_),
str(eval_result['map']),
str(trainer.get_meter_data()))
print(log_info)
# trainer.vis.log(log_info)
if eval_result['map'] > best_map:
best_map = eval_result['map']
best_path = trainer.save(best_map=best_map)
if epoch == 9:
trainer.load(best_path)
trainer.faster_rcnn.scale_lr(opt.lr_decay)
lr_ = lr_ * opt.lr_decay
if epoch == 13:
break
import os
import torch as t
from utils.config import opt
from model import FasterRCNNVGG16
from trainer import FasterRCNNTrainer
from data.util import read_image
from utils import array_tool as at
import pandas as pd
name, pred = [], []
id_list_file = '/home/csce/czwhhh/competition/rebar/VOC_GJ/ImageSets/Main/test.txt'
ids = [id_.strip() for id_ in open(id_list_file)]
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load('./checkpoints/fasterrcnn_01151508_0')
opt.caffe_pretrain = True
for id in ids:
print(id)
img = read_image(
'/home/csce/czwhhh/competition/rebar/VOC_GJ/JPEGImages/{0}.jpg'.format(
id))
img = t.from_numpy(img)[None]
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(img,
visualize=True)
all_box = at.tonumpy(_bboxes[0])
for i in range(all_box.shape[0]):
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
trainer.vis.text(dataset.db.label_names, win='labels')
best_map = 0
lr_ = opt.lr
for epoch in range(opt.epoch):
trainer.reset_meters()
for ii, (img, bbox_, label_, scale) in tqdm(enumerate(dataloader)):
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
trainer.train_step(img, bbox, label, scale)
if (ii + 1) % opt.plot_every == 0:
if os.path.exists(opt.debug_file):
ipdb.set_trace()
# plot loss
trainer.vis.plot_many(trainer.get_meter_data())
# plot groud truth bboxes
ori_img_ = inverse_normalize(at.tonumpy(img[0]))
gt_img = visdom_bbox(ori_img_, at.tonumpy(bbox_[0]),
at.tonumpy(label_[0]))
trainer.vis.img('gt_img', gt_img)
# plot predicti bboxes
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(
[ori_img_], visualize=True)
pred_img = visdom_bbox(ori_img_, at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]))
trainer.vis.img('pred_img', pred_img)
# rpn confusion matrix(meter)
trainer.vis.text(str(trainer.rpn_cm.value().tolist()),
win='rpn_cm')
# roi confusion matrix
trainer.vis.img(
'roi_cm',
at.totensor(trainer.roi_cm.conf, False).float())
eval_result = eval(test_dataloader, faster_rcnn, test_num=opt.test_num)
trainer.vis.plot('test_map', eval_result['map'])
lr_ = trainer.faster_rcnn.optimizer.param_groups[0]['lr']
log_info = 'lr:{}, map:{},loss:{}'.format(
str(lr_), str(eval_result['map']), str(trainer.get_meter_data()))
trainer.vis.log(log_info)
if eval_result['map'] > best_map:
best_map = eval_result['map']
best_path = trainer.save(best_map=best_map)
if epoch == 9:
trainer.load(best_path)
trainer.faster_rcnn.scale_lr(opt.lr_decay)
lr_ = lr_ * opt.lr_decay
if epoch == 13:
break
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
# pin_memory=True,
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from {}'.format(opt.load_path))
# trainer.vis.text(dataset.db.label_names, win='labels')
adversary = None
if opt.flagadvtrain:
print("flagadvtrain turned: Adversarial training!")
atk = PGD.PGD(trainer, eps=16/255, alpha=3/255, steps=4)
# atk = torchattacks.PGD(trainer.faster_rcnn, eps=16, alpha=3, steps=4)
# adversary = PGDAttack(trainer.faster_rcnn, loss_fn=nn.CrossEntropyLoss(), eps=16, nb_iter=4, eps_iter=3,
# rand_init=True, clip_min=0.0, clip_max=1.0, targeted=False)
best_map = 0
lr_ = opt.lr
normal_total_loss = []
adv_total_loss = []
total_time = 0.0
total_imgs = 0
true_imgs = 0
for epoch in range(opt.epoch):
trainer.reset_meters()
once = True
for ii, (img, bbox_, label_, scale) in tqdm(enumerate(dataloader)):
scale = at.scalar(scale)
temp_img = copy.deepcopy(img).cuda()
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
if opt.flagadvtrain:
before_time = time.time()
img = atk(img, bbox, label, scale)
after_time = time.time()
# with ctx_noparamgrad_and_eval(trainer.faster_rcnn):
# img = adversary.perturb(img, label)
# print("Adversarial training done!")
total_time += after_time - before_time
# print("Normal training starts\n")
# trainer.train_step(img, bbox, label, scale)
if (ii + 1) % opt.plot_every == 0:
# adv_total_loss.append(trainer.get_meter_data()["total_loss"])
if os.path.exists(opt.debug_file):
ipdb.set_trace()
# plot loss
# trainer.vis.plot_many(trainer.get_meter_data())
# plot groud truth bboxes
temp_ori_img_ = inverse_normalize(at.tonumpy(temp_img[0]))
# img2jpg(temp_ori_img_, "imgs/orig_images/", "gt_img{}".format(ii))
# temp_gt_img = visdom_bbox(temp_ori_img_,
# at.tonumpy(bbox_[0]),
# at.tonumpy(label_[0]))
# plt.figure()
# c, h, w = temp_gt_img.shape
# plt.imshow(np.reshape(temp_gt_img, (h, w, c)))
# plt.savefig("imgs/temp_orig_images/temp_gt_img{}".format(ii))
# plt.close()
ori_img_ = inverse_normalize(at.tonumpy(img[0]))
# print("GT Label is {} and pred_label is {}".format(label_[0],))
# img2jpg(ori_img_, "imgs/adv_images/", "adv_img{}".format(ii))
# gt_img = visdom_bbox(ori_img_,
# at.tonumpy(bbox_[0]),
# at.tonumpy(label_[0]))
# plt.figure()
# c, h, w = gt_img.shape
# plt.imshow(np.reshape(gt_img, (h, w, c)))
# plt.savefig("imgs/orig_images/gt_img{}".format(ii))
# plt.close()
# trainer.vis.img('gt_img', gt_img)
# plot predicti bboxes
_bboxes, _labels, _scores = trainer.faster_rcnn.predict([ori_img_], visualize=True)
fig1 = plt.figure()
ax1 = fig1.add_subplot(1,1,1)
# final1 = (at.tonumpy(img[0].cpu()).transpose(1,2,0).astype(np.uint8))
final1 = (ori_img_.transpose(1, 2, 0).astype(np.uint8))
ax1.imshow(final1)
gt_img = visdom_bbox(ax1,at.tonumpy(_bboxes[0]),at.tonumpy(_labels[0]))
fig1.savefig("imgs/adv_images/adv_img{}".format(ii))
plt.close()
_temp_bboxes, _temp_labels, _temp_scores = trainer.faster_rcnn.predict([temp_ori_img_], visualize=True)
fig2 = plt.figure()
ax2 = fig2.add_subplot(1, 1, 1)
final2 = (temp_ori_img_.transpose(1, 2, 0).astype(np.uint8))
# final2 = (at.tonumpy(temp_img[0].cpu()).transpose(1, 2, 0).astype(np.uint8))
ax2.imshow(final2)
gt_img = visdom_bbox(ax2, at.tonumpy(_temp_bboxes[0]), at.tonumpy(_temp_labels[0]))
fig2.savefig("imgs/orig_images/gt_img{}".format(ii))
plt.close()
# img2jpg(temp_gt_img, "imgs/orig_images/", "gt_img{}".format(ii))
# print("gt labels is {}, pred_orig_labels is {} and pred_adv_labels is {}".format(label_, _labels, _temp_labels))
total_imgs += 1
if len(_temp_labels) == 0:
continue
if _labels[0].shape[0] == _temp_labels[0].shape[0] and (_labels[0] == _temp_labels[0]).all() is True:
true_imgs += 1
# pred_img = visdom_bbox(ori_img_,
# at.tonumpy(_bboxes[0]),
# at.tonumpy(_labels[0]).reshape(-1),
# at.tonumpy(_scores[0]))
#
# print("Shape of temp_orig_img_ is {}".format(temp_ori_img_.shape))
# temp_pred_img = visdom_bbox(temp_ori_img_,
# at.tonumpy(_temp_bboxes[0]),
# at.tonumpy(_temp_labels[0]).reshape(-1),
# at.tonumpy(_temp_scores[0]))
#
# trainer.vis.img('pred_img', pred_img)
# rpn confusion matrix(meter)
# trainer.vis.text(str(trainer.rpn_cm.value().tolist()), win='rpn_cm')
# roi confusion matrix
# trainer.vis.img('roi_cm', at.totensor(trainer.roi_cm.conf, False).float())
# fig = plt.figure()
# ax1 = fig.add_subplot(2,1,1)
# ax1.plot(normal_total_loss)
# ax2 = fig.add_subplot(2,1,2)
# ax2.plot(adv_total_loss)
# fig.savefig("losses/both_loss{}".format(epoch))
# eval_result = eval(test_dataloader, faster_rcnn, test_num=opt.test_num,
# flagadvtrain=opt.flagadvtrain, adversary=atk)# adversary=adversary)
# trainer.vis.plot('test_map', eval_result['map'])
# lr_ = trainer.faster_rcnn.optimizer.param_groups[0]['lr']
# log_info = 'lr:{}, map:{},loss:{}'.format(str(lr_),
# str(eval_result['map']),
# str(trainer.get_meter_data()))
# print(log_info)
# # trainer.vis.log(log_info)
#
# if eval_result['map'] > best_map:
# best_map = eval_result['map']
# best_path = trainer.save(best_map=best_map)
# if epoch == 9:
# trainer.load(best_path)
# trainer.faster_rcnn.scale_lr(opt.lr_decay)
# lr_ = lr_ * opt.lr_decay
if epoch == 0:
break
if epoch == 13:
break
print("Total number of images is {}".format(total_imgs))
print("True images is {}".format(true_imgs))
print("Total time is {}".format(total_time))
print("Avg time is {}".format(total_time/total_imgs))
def main(**kwargs):
opt._parse(kwargs)
checkpoint = t.load('se_0314_all')
num_classes = 8
# step = [112, 112]
classifier = t.hub.load(
'moskomule/senet.pytorch',
'se_resnet50',
pretrained=True,
)
num_ftrs = classifier.fc.in_features
classifier.fc = nn.Linear(num_ftrs, num_classes)
classifier.load_state_dict(checkpoint['state_dict'])
classifier.eval()
classifier = classifier.cuda()
result_file = open('result0522.txt', 'w')
save_root = './result/bbox/'
makeDir()
faster_rcnn = FasterRCNNVGG16()
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
trainer.load('checkpoints/fasterrcnn_04081709_0.6626689194895079')
data_root = '/home/lsm/testSamples700_new/'
test_file = 'GT707.txt'
test700 = Test700Dataset(data_root, test_file, opt)
test_dataloader = data_.DataLoader(test700,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
print('data loaded!')
for ii, (fn, imgs, sizes, gt_bboxes_) in tqdm(enumerate(test_dataloader)):
# print(gt_bboxes_)
gt_x1 = int(gt_bboxes_[0][0][1])
gt_y1 = int(gt_bboxes_[0][0][0])
gt_x2 = int(gt_bboxes_[0][0][3])
gt_y2 = int(gt_bboxes_[0][0][2])
# print([gt_x1,gt_y1,gt_x2,gt_y2])
sizes = [sizes[0][0].item(), sizes[1][0].item()]
pred_bboxes_, pred_labels_, pred_scores_ = faster_rcnn.predict(
imgs, [sizes])
result_file.write(fn[0])
# drawBbox(data_root,fn[0],pred_bboxes_,save_root)
img = Image.open(data_root + fn[0]).convert("RGB")
plt.imshow(img)
currentAxis = plt.gca()
for i in range(len(pred_bboxes_[0])):
bbox = pred_bboxes_[0][i]
score = pred_scores_[0][i]
x1, y1, x2, y2 = bbox[1], bbox[0], bbox[3], bbox[2]
canditate = img.crop((x1, y1, x2, y2))
# decision = decide(classifier, canditate, step)
decision = decide2(classifier, canditate)
if decision != 0:
# plt.text(x1, y1, toolNameList[decision]+" "+str(score), size=15, color='r')
rect = patches.Rectangle((x1, y1),
x2 - x1,
y2 - y1,
fill=False,
edgecolor='r',
linewidth=2)
currentAxis.add_patch(rect)
result_file.write(' ' + toolNameList[decision] + ' ' +
str(x1) + ' ' + str(y1) + ' ' + str(x2) +
' ' + str(y2))
rect = patches.Rectangle((gt_x1, gt_y1),
gt_x2 - gt_x1,
gt_y2 - gt_y1,
fill=False,
edgecolor='g',
linewidth=2)
currentAxis.add_patch(rect)
plt.savefig(save_root + fn[0])
plt.close()
result_file.write('\n')
result_file.close()
def train(**kwargs):
opt._parse(kwargs)
log_dir = os.path.join("logs", "faster_rcnn_train_onGray")
os.makedirs(log_dir, exist_ok=True)
log_path = os.path.join(
log_dir, time.strftime("%Y-%m-%d-%H%M.log", time.localtime(time.time()))
)
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(message)s",
handlers=[logging.FileHandler(log_path), logging.StreamHandler()],
)
logger = logging.getLogger()
dataset = Dataset(opt)
print("load data")
dataloader = data_.DataLoader(
dataset,
batch_size=1,
shuffle=True, # pin_memory=True,
num_workers=opt.num_workers,
)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(
testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False,
pin_memory=True,
)
faster_rcnn = FasterRCNNVGG16()
print("model construct completed")
logger.info(faster_rcnn)
logger.info("-" * 50)
trainer = FasterRCNNTrainer(faster_rcnn, logger).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print("load pretrained model from %s" % opt.load_path)
trainer.vis.text(dataset.db.label_names, win="labels")
best_map = 0
lr_ = opt.lr
for epoch in range(opt.epoch):
trainer.reset_meters()
trainer.reset_ave()
for ii, (img, bbox_, label_, scale) in enumerate(dataloader):
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
if (ii + 1) % opt.print_freq == 0:
logger.info(
"[Train] Epoch:{} [{:03d}/{:03d}]({:.0f}%)\t".format(
epoch, ii + 1, len(dataloader), (ii + 1) / len(dataloader) * 100
)
)
trainer.train_step(
img, bbox, label, scale, print_epoch=epoch, print_info=True
)
else:
trainer.train_step(
img, bbox, label, scale, print_epoch=epoch, print_info=False
)
# if (ii + 1) % opt.plot_every == 0:
# if os.path.exists(opt.debug_file):
# ipdb.set_trace()
#
# # plot loss
# trainer.vis.plot_many(trainer.get_meter_data())
#
# # plot groud truth bboxes
# ori_img_ = inverse_normalize(at.tonumpy(img[0]))
# gt_img = visdom_bbox(
# ori_img_, at.tonumpy(bbox_[0]), at.tonumpy(label_[0])
# )
# trainer.vis.img("gt_img", gt_img)
# if (ii + 1) % opt.plot_every == 0:
# if os.path.exists(opt.debug_file):
# ipdb.set_trace()
#
# # plot loss
# trainer.vis.plot_many(trainer.get_meter_data())
#
# # plot groud truth bboxes
# ori_img_ = inverse_normalize(at.tonumpy(img[0]))
# gt_img = visdom_bbox(
# ori_img_, at.tonumpy(bbox_[0]), at.tonumpy(label_[0])
# )
# trainer.vis.img("gt_img", gt_img)
#
# # plot predicti bboxes
# _bboxes, _labels, _scores = trainer.faster_rcnn.predict(
# [ori_img_], visualize=True
# )
# pred_img = visdom_bbox(
# ori_img_,
# at.tonumpy(_bboxes[0]),
# at.tonumpy(_labels[0]).reshape(-1),
# at.tonumpy(_scores[0]),
# )
# trainer.vis.img("pred_img", pred_img)
#
# # rpn confusion matrix(meter)
# trainer.vis.text(str(trainer.rpn_cm.value().tolist()), win="rpn_cm")
# # roi confusion matrix
# trainer.vis.img(
# "roi_cm", at.totensor(trainer.roi_cm.conf, False).float()
# )
eval_result = eval(test_dataloader, faster_rcnn, test_num=opt.test_num)
# trainer.vis.plot("test_map", eval_result["map"])
lr_ = trainer.faster_rcnn.optimizer.param_groups[0]["lr"]
log_info = "lr:{}, map:{},loss:{}".format(
str(lr_), str(eval_result["map"]), str(trainer.get_meter_data())
)
logger.info(log_info)
# trainer.vis.log(log_info)
if eval_result["map"] > best_map:
best_map = eval_result["map"]
best_path = trainer.save(
best_map=best_map,
save_path="checkpoints/trainedOnGray/fasterrcnn_%s"
% time.strftime("%m%d%H%M"),
)
if epoch == 9:
trainer.load(best_path)
trainer.faster_rcnn.scale_lr(opt.lr_decay)
lr_ = lr_ * opt.lr_decay
def train(**kwargs):
opt._parse(kwargs)
dataset = Dataset(opt)
# 300w_dataset = FaceLandmarksDataset()
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=True, \
pin_memory=True,\
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
attacker = attacks.DCGAN(train_adv=False)
if opt.load_attacker:
attacker.load(opt.load_attacker)
print('load attacker model from %s' % opt.load_attacker)
trainer = VictimFasterRCNNTrainer(faster_rcnn, attacker,
attack_mode=True).cuda()
# trainer = VictimFasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
trainer.vis.text(dataset.db.label_names, win='labels')
# eval_result = eval(test_dataloader, faster_rcnn, test_num=2000)
best_map = 0
for epoch in range(opt.epoch):
trainer.reset_meters(adv=True)
for ii, (img, bbox_, label_, scale) in tqdm(enumerate(dataloader)):
ipdb.set_trace()
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
img, bbox, label = Variable(img), Variable(bbox), Variable(label)
trainer.train_step(img, bbox, label, scale)
if (ii) % opt.plot_every == 0:
if os.path.exists(opt.debug_file):
ipdb.set_trace()
# plot loss
trainer.vis.plot_many(trainer.get_meter_data())
trainer.vis.plot_many(trainer.get_meter_data(adv=True))
# plot groud truth bboxes
ori_img_ = inverse_normalize(at.tonumpy(img[0]))
gt_img = visdom_bbox(ori_img_, at.tonumpy(bbox_[0]),
at.tonumpy(label_[0]))
trainer.vis.img('gt_img', gt_img)
# plot predicted bboxes
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(
[ori_img_], visualize=True)
pred_img = visdom_bbox(ori_img_, at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]))
trainer.vis.img('pred_img', pred_img)
if trainer.attacker is not None:
adv_img = trainer.attacker.perturb(img)
adv_img_ = inverse_normalize(at.tonumpy(adv_img[0]))
_bboxes, _labels, _scores = trainer.faster_rcnn.predict(
[adv_img_], visualize=True)
adv_pred_img = visdom_bbox(
adv_img_, at.tonumpy(_bboxes[0]),
at.tonumpy(_labels[0]).reshape(-1),
at.tonumpy(_scores[0]))
trainer.vis.img('adv_img', adv_pred_img)
# rpn confusion matrix(meter)
trainer.vis.text(str(trainer.rpn_cm.value().tolist()),
win='rpn_cm')
# roi confusion matrix
trainer.vis.img(
'roi_cm',
at.totensor(trainer.roi_cm.conf, False).float())
if (ii) % 500 == 0:
best_path = trainer.save(epochs=epoch, save_rcnn=True)
if epoch % 2 == 0:
best_path = trainer.save(epochs=epoch)
def train(**kwargs):
opt._parse(kwargs)
dataset = LargeImageDataset(opt)
print('load data')
dataloader = data_.DataLoader(dataset, \
batch_size=1, \
shuffle=False, \
# pin_memory=True,
num_workers=opt.num_workers)
testset = TestDataset(opt)
test_dataloader = data_.DataLoader(testset,
batch_size=1,
num_workers=opt.test_num_workers,
shuffle=False, \
pin_memory=True
)
faster_rcnn = FasterRCNNVGG16()
print('model construct completed')
trainer = FasterRCNNTrainer(faster_rcnn).cuda()
if opt.load_path:
trainer.load(opt.load_path)
print('load pretrained model from %s' % opt.load_path)
best_map = 0
lr_ = opt.lr
rpn_loc_loss = []
rpn_cls_loss = []
roi_loc_loss = []
roi_cls_loss = []
total_loss = []
test_map_list = []
for epoch in range(opt.epoch):
trainer.reset_meters()
for ii, (img, bbox_, label_, scale) in tqdm(enumerate(dataloader)):
scale = at.scalar(scale)
img, bbox, label = img.cuda().float(), bbox_.cuda(), label_.cuda()
trainer.train_step(img, bbox, label, scale)
if (ii + 1) % opt.plot_every == 0:
if os.path.exists(opt.debug_file):
ipdb.set_trace()
# plot loss
losses_dict = trainer.get_meter_data()
rpn_loc_loss.append(losses_dict['rpn_loc_loss'])
roi_loc_loss.append(losses_dict['roi_loc_loss'])
rpn_cls_loss.append(losses_dict['rpn_cls_loss'])
roi_cls_loss.append(losses_dict['roi_cls_loss'])
total_loss.append(losses_dict['total_loss'])
save_losses('rpn_loc_loss', rpn_loc_loss, epoch)
save_losses('roi_loc_loss', roi_loc_loss, epoch)
save_losses('rpn_cls_loss', rpn_cls_loss, epoch)
save_losses('total_loss', total_loss, epoch)
save_losses('roi_cls_loss', roi_cls_loss, epoch)
eval_result = eval(test_dataloader, faster_rcnn, test_num=opt.test_num)
test_map_list.append(eval_result['map'])
save_map(test_map_list, epoch)
lr_ = trainer.faster_rcnn.optimizer.param_groups[0]['lr']
log_info = 'lr:{}, map:{},loss:{}'.format(
str(lr_), str(eval_result['map']), str(trainer.get_meter_data()))
print(log_info)
if eval_result['map'] > best_map:
best_map = eval_result['map']
best_path = trainer.save(best_map=best_map)
if epoch == 9:
trainer.load(best_path)
trainer.faster_rcnn.scale_lr(opt.lr_decay)
lr_ = lr_ * opt.lr_decay
if epoch == 13:
break