def __init__(self, config_path, dataset, metaset):
self.config = open_json(config_path)
self.logger = Logger()
self.eda = EDA(self.config["analyzer"])
self.dataset = dataset
self.metaset = metaset
def __init__(self, config_path):
self.config = open_json(config_path)
self.filepath = self.config["dataset"]["filepath"]
self.basepath = self.config["dataset"]["dirpath"]
self.format = self.config["dataset"]["format"].lower()
self.logger = Logger()
self.dataset = self.load_dataset() # 1.1
self.metaset = self.load_metaset() # 1.2
def __init__(self, config_path):
self.config = open_json(config_path)
self.logger = Logger()
self.models = self.build_model()
class ModelGenerator(object):
def __init__(self, config_path):
self.config = open_json(config_path)
self.logger = Logger()
self.models = self.build_model()
def build_model(self):
self.logger.log(
f" - Building a model [ {self.config['model']['MODEL']} ]")
model_Lasso = make_pipeline(RobustScaler(),
Lasso(alpha=0.000327, random_state=18))
model_ENet = make_pipeline(
RobustScaler(),
ElasticNet(alpha=0.00052, l1_ratio=0.70654, random_state=18))
model_GBoost = GradientBoostingRegressor(
n_estimators=3000,
learning_rate=0.05,
max_depth=4,
max_features="sqrt",
min_samples_leaf=15,
min_samples_split=10,
loss="huber",
random_state=18,
)
model_XGB = XGBRegressor(
colsample_bylevel=0.9229733609038979,
colsample_bynode=0.21481791874780318,
colsample_bytree=0.607964318297635,
gamma=0.8989889254961725,
learning_rate=0.009192310189734834,
max_depth=3,
n_estimators=3602,
reg_alpha=3.185674564163364e-12,
reg_lambda=4.95553539265423e-13,
seed=18,
subsample=0.8381904293270576,
verbosity=0,
)
model_logistic = LogisticRegression()
models = {
"Lasso": model_Lasso,
"ENet": model_ENet,
"GBoost": model_GBoost,
"XGBoost": model_XGB,
"LogReg": model_logistic,
}
return models
def fit_model(self, dataset, metaset):
dataset["valid"] = dataset["train"][:45569]
dataset["train"] = dataset["train"][45569:]
train_label = dataset["train"][metaset["__target__"]]
train_value = dataset["train"].drop(columns=metaset["__target__"])
valid_label = dataset["valid"][metaset["__target__"]]
valid_value = dataset["valid"].drop(columns=metaset["__target__"])
predicts = dict()
models = self.models
def fitting(model, x_train, x_test, y_train, y_test):
model.fit(x_train, y_train)
y_pred = model.predict(x_test)
self.metrics(y_test, y_pred)
return y_pred
print("FIT - LogReg")
predicts["LogReg"] = fitting(
model=models["LogReg"],
x_train=train_value,
x_test=valid_value,
y_train=train_label,
y_test=valid_label,
)
# log_train_predict = (
# predicts["Lasso"]
# + predicts["ENet"]
# + predicts["GBoost"]
# + predicts["XGBoost"]
# ) / 4
# train_score = mean_squared_error(train_label, log_train_predict)
# print(f"Scoring with train data : {train_score}")
def metrics(self, y_test, y_pred):
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
roc_score = roc_auc_score(y_test, y_pred, average="macro")
print(
f"accr : {accuracy:.2f}, prec : {precision:.2f}, recall : {recall:.2f}"
)
print(f"f1 : {f1:.2f}, auc : {roc_score:.2f}")
return iter(self.rand_num_view)
def __len__(self):
return self.num_data
if __name__ == '__main__':
args = parse_args()
print('Called with args:')
print(args)
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger(os.path.join('./logs', \
args.net + '_' + args.dataset + '_' + args.optimizer + '_' + str(args.session)))
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
print('Using config:')
pprint.pprint(cfg)
np.random.seed(cfg.RNG_SEED)
#torch.backends.cudnn.benchmark = True
if torch.cuda.is_available() and not args.cuda:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
# train set
print('Called with args:')
print(args)
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logdir = './logs/Session_{}'.format(args.session)
if not os.path.exists(logdir):
try:
os.makedirs(logdir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
logger = Logger(logdir)
if args.dataset == "pascal_voc":
args.imdb_name = "voc_2007_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
elif args.dataset == "pascal_voc_0712":
args.imdb_name = "voc_2007_trainval+voc_2012_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
def train():
# check cuda devices
if not torch.cuda.is_available():
assert RuntimeError(
"Training can only be done by GPU. Please use --cuda to enable training."
)
if torch.cuda.is_available() and not args.cuda:
assert RuntimeError(
"You have a CUDA device, so you should probably run with --cuda")
# init random seed
np.random.seed(cfg.RNG_SEED)
# init logger
# TODO: RESUME LOGGER
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
current_t = time.strftime("%Y_%m_%d") + "_" + time.strftime("%H:%M:%S")
logger = Logger(
os.path.join(
'.', 'logs', current_t + "_" + args.frame + "_" +
args.dataset + "_" + args.net))
# init dataset
imdb, roidb, ratio_list, ratio_index, cls_list = combined_roidb(
args.imdb_name)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
sampler_batch = sampler(train_size, args.batch_size)
iters_per_epoch = int(train_size / args.batch_size)
if args.frame in {"fpn", "faster_rcnn", "efc_det"}:
dataset = fasterrcnnbatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
elif args.frame in {"ssd"}:
dataset = ssdbatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
elif args.frame in {"ssd_vmrn", "vam"}:
dataset = svmrnbatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
elif args.frame in {"faster_rcnn_vmrn"}:
dataset = fvmrnbatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
elif args.frame in {"fcgn"}:
dataset = fcgnbatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
elif args.frame in {"all_in_one"}:
dataset = fallinonebatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
elif args.frame in {"mgn"}:
dataset = roignbatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
len(cls_list), training=True, cls_list=cls_list,
augmentation=cfg.TRAIN.COMMON.AUGMENTATION)
else:
raise RuntimeError
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers)
args.iter_per_epoch = int(len(roidb) / args.batch_size)
# init output directory for model saving
output_dir = args.save_dir + "/" + args.dataset + "/" + args.net
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if args.vis:
visualizer = dataViewer(cls_list)
data_vis_dir = os.path.join(args.save_dir, args.dataset, 'data_vis',
'train')
if not os.path.exists(data_vis_dir):
os.makedirs(data_vis_dir)
id_number_to_name = {}
for r in roidb:
id_number_to_name[r["img_id"]] = r["image"]
# init network
Network, optimizer = init_network(args, len(cls_list))
# init variables
current_result, best_result, loss_temp, loss_rpn_cls, loss_rpn_box, loss_rcnn_cls, loss_rcnn_box, loss_rel_pred, \
loss_grasp_box, loss_grasp_cls, fg_cnt, bg_cnt, fg_grasp_cnt, bg_grasp_cnt = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
save_flag, rois, rpn_loss_cls, rpn_loss_box, rel_loss_cls, cls_prob, bbox_pred, rel_cls_prob, loss_bbox, loss_cls, \
rois_label, grasp_cls_loss, grasp_bbox_loss, grasp_conf_label = \
False, None, None, None, None, None, None, None, None, None, None, None, None, None
# initialize step counter
if args.resume:
step = args.checkpoint
else:
step = 0
for epoch in range(args.checkepoch, args.max_epochs + 1):
# setting to train mode
Network.train()
start_epoch_time = time.time()
start = time.time()
data_iter = iter(dataloader)
while (True):
if step >= iters_per_epoch:
break
# get data batch
data_batch = next(data_iter)
if args.vis:
for i in range(data_batch[0].size(0)):
data_list = [
data_batch[d][i] for d in range(len(data_batch))
]
im_vis = vis_gt(data_list,
visualizer,
args.frame,
train_mode=True)
# img_name = id_number_to_name[data_batch[1][i][4].item()].split("/")[-1]
img_name = str(int(data_batch[1][i][4].item())) + ".jpg"
# When using cv2.imwrite, channel order should be BGR
cv2.imwrite(os.path.join(data_vis_dir, img_name),
im_vis[:, :, ::-1])
# ship to cuda
if args.cuda:
data_batch = makeCudaData(data_batch)
# setting gradients to zeros
Network.zero_grad()
optimizer.zero_grad()
# forward process
if args.frame == 'faster_rcnn_vmrn':
rois, cls_prob, bbox_pred, rel_cls_prob, rpn_loss_cls, rpn_loss_box, loss_cls, \
loss_bbox, rel_loss_cls, reg_loss, rois_label = Network(data_batch)
loss = (rpn_loss_cls + rpn_loss_box + loss_cls + loss_bbox +
reg_loss + rel_loss_cls).mean()
elif args.frame == 'faster_rcnn' or args.frame == 'fpn':
rois, cls_prob, bbox_pred, rpn_loss_cls, rpn_loss_box, loss_cls, loss_bbox, \
rois_label = Network(data_batch)
loss = (rpn_loss_cls + rpn_loss_box + loss_cls +
loss_bbox).mean()
elif args.frame == 'fcgn':
bbox_pred, cls_prob, loss_bbox, loss_cls, rois_label, rois = Network(
data_batch)
loss = (loss_bbox + loss_cls).mean()
elif args.frame == 'mgn':
rois, cls_prob, bbox_pred, rpn_loss_cls, rpn_loss_box, loss_cls, loss_bbox, rois_label, grasp_loc, \
grasp_prob, grasp_bbox_loss, grasp_cls_loss, grasp_conf_label, grasp_all_anchors = Network(data_batch)
loss = rpn_loss_box.mean() + rpn_loss_cls.mean() + loss_cls.mean() + loss_bbox.mean() + \
cfg.MGN.OBJECT_GRASP_BALANCE * (grasp_bbox_loss.mean() + grasp_cls_loss.mean())
elif args.frame == 'all_in_one':
rois, cls_prob, bbox_pred, rel_cls_prob, rpn_loss_cls, rpn_loss_box, loss_cls, loss_bbox, rel_loss_cls, reg_loss, rois_label, \
grasp_loc, grasp_prob, grasp_bbox_loss, grasp_cls_loss, grasp_conf_label, grasp_all_anchors = Network(
data_batch)
loss = (rpn_loss_box + rpn_loss_cls + loss_cls + loss_bbox + rel_loss_cls + reg_loss \
+ cfg.MGN.OBJECT_GRASP_BALANCE * grasp_bbox_loss + grasp_cls_loss).mean()
elif args.frame in {'ssd', 'efc_det'}:
bbox_pred, cls_prob, loss_bbox, loss_cls = Network(data_batch)
loss = loss_bbox.mean() + loss_cls.mean()
elif args.frame == 'ssd_vmrn' or args.frame == 'vam':
bbox_pred, cls_prob, rel_result, loss_bbox, loss_cls, rel_loss_cls, reg_loss = Network(
data_batch)
loss = (loss_cls + loss_bbox + rel_loss_cls + reg_loss).mean()
loss_temp += loss.data.item()
# backward process
loss.backward()
g_norm = gradient_norm(Network)
if args.net == "vgg16":
clip_gradient(Network, 10.)
# print("Gradient norm:{:.3f}".format(g_norm))
optimizer.step()
step += 1
# record training information
if len(args.mGPUs) > 0:
if rpn_loss_cls is not None and isinstance(
rpn_loss_cls, torch.Tensor):
loss_rpn_cls += rpn_loss_cls.mean().data[0].item()
if rpn_loss_box is not None and isinstance(
rpn_loss_box, torch.Tensor):
loss_rpn_box += rpn_loss_box.mean().data[0].item()
if loss_cls is not None and isinstance(loss_cls, torch.Tensor):
loss_rcnn_cls += loss_cls.mean().data[0].item()
if loss_bbox is not None and isinstance(
loss_bbox, torch.Tensor):
loss_rcnn_box += loss_bbox.mean().data[0].item()
if rel_loss_cls is not None and isinstance(
rel_loss_cls, torch.Tensor):
loss_rel_pred += rel_loss_cls.mean().data[0].item()
if grasp_cls_loss is not None and isinstance(
grasp_cls_loss, torch.Tensor):
loss_grasp_cls += grasp_cls_loss.mean().data[0].item()
if grasp_bbox_loss is not None and isinstance(
grasp_bbox_loss, torch.Tensor):
loss_grasp_box += grasp_bbox_loss.mean().data[0].item()
if rois_label is not None and isinstance(
rois_label, torch.Tensor):
tempfg = torch.sum(rois_label.data.ne(0))
fg_cnt += tempfg
bg_cnt += (rois_label.data.numel() - tempfg)
if grasp_conf_label is not None and isinstance(
grasp_conf_label, torch.Tensor):
tempfg = torch.sum(grasp_conf_label.data.ne(0))
fg_grasp_cnt += tempfg
bg_grasp_cnt += (grasp_conf_label.data.numel() - tempfg)
else:
if rpn_loss_cls is not None and isinstance(
rpn_loss_cls, torch.Tensor):
loss_rpn_cls += rpn_loss_cls.item()
if rpn_loss_cls is not None and isinstance(
rpn_loss_cls, torch.Tensor):
loss_rpn_box += rpn_loss_box.item()
if loss_cls is not None and isinstance(loss_cls, torch.Tensor):
loss_rcnn_cls += loss_cls.item()
if loss_bbox is not None and isinstance(
loss_bbox, torch.Tensor):
loss_rcnn_box += loss_bbox.item()
if rel_loss_cls is not None and isinstance(
rel_loss_cls, torch.Tensor):
loss_rel_pred += rel_loss_cls.item()
if grasp_cls_loss is not None and isinstance(
grasp_cls_loss, torch.Tensor):
loss_grasp_cls += grasp_cls_loss.item()
if grasp_bbox_loss is not None and isinstance(
grasp_bbox_loss, torch.Tensor):
loss_grasp_box += grasp_bbox_loss.item()
if rois_label is not None and isinstance(
rois_label, torch.Tensor):
tempfg = torch.sum(rois_label.data.ne(0))
fg_cnt += tempfg
bg_cnt += (rois_label.data.numel() - tempfg)
if grasp_conf_label is not None and isinstance(
grasp_conf_label, torch.Tensor):
tempfg = torch.sum(grasp_conf_label.data.ne(0))
fg_grasp_cnt += tempfg
bg_grasp_cnt += (grasp_conf_label.data.numel() - tempfg)
if Network.iter_counter % args.disp_interval == 0:
end = time.time()
loss_temp /= args.disp_interval
loss_rpn_cls /= args.disp_interval
loss_rpn_box /= args.disp_interval
loss_rcnn_cls /= args.disp_interval
loss_rcnn_box /= args.disp_interval
loss_rel_pred /= args.disp_interval
loss_grasp_cls /= args.disp_interval
loss_grasp_box /= args.disp_interval
print("[session %d][epoch %2d][iter %4d/%4d] \n\t\t\tloss: %.4f, lr: %.2e" \
% (args.session, epoch, step, iters_per_epoch, loss_temp, optimizer.param_groups[0]['lr']))
print('\t\t\ttime cost: %f' % (end - start, ))
if rois_label is not None:
print("\t\t\tfg/bg=(%d/%d)" % (fg_cnt, bg_cnt))
if grasp_conf_label is not None:
print("\t\t\tgrasp_fg/grasp_bg=(%d/%d)" %
(fg_grasp_cnt, bg_grasp_cnt))
if rpn_loss_box is not None and rpn_loss_cls is not None:
print("\t\t\trpn_cls: %.4f\n\t\t\trpn_box: %.4f\n\t\t\trcnn_cls: %.4f\n\t\t\trcnn_box %.4f" \
% (loss_rpn_cls, loss_rpn_box, loss_rcnn_cls, loss_rcnn_box))
else:
print("\t\t\trcnn_cls: %.4f\n\t\t\trcnn_box %.4f" \
% (loss_rcnn_cls, loss_rcnn_box))
if rel_loss_cls is not None:
print("\t\t\trel_loss %.4f" \
% (loss_rel_pred,))
if grasp_cls_loss is not None and grasp_bbox_loss is not None:
print("\t\t\tgrasp_cls: %.4f\n\t\t\tgrasp_box %.4f" \
% (loss_grasp_cls, loss_grasp_box))
if args.use_tfboard:
info = {
'loss': loss_temp,
'loss_rcnn_cls': loss_rcnn_cls,
'loss_rcnn_box': loss_rcnn_box,
}
if rpn_loss_cls:
info['loss_rpn_cls'] = loss_rpn_cls
if rpn_loss_box:
info['loss_rpn_box'] = loss_rpn_box
if rel_loss_cls:
info['loss_rel_pred'] = loss_rel_pred
for tag, value in info.items():
logger.scalar_summary(tag, value, Network.iter_counter)
loss_temp = 0.
loss_rpn_cls = 0.
loss_rpn_box = 0.
loss_rcnn_cls = 0.
loss_rcnn_box = 0.
loss_rel_pred = 0.
loss_grasp_box = 0.
loss_grasp_cls = 0.
fg_cnt = 0.
bg_cnt = 0.
fg_grasp_cnt = 0.
bg_grasp_cnt = 0.
start = time.time()
# adjust learning rate
if args.lr_decay_step == 0:
# clr = lr / (1 + decay * n) -> lr_n / lr_n+1 = (1 + decay * (n+1)) / (1 + decay * n)
decay = (1 + args.lr_decay_gamma * Network.iter_counter) / (
1 + args.lr_decay_gamma * (Network.iter_counter + 1))
adjust_learning_rate(optimizer, decay)
elif Network.iter_counter % (args.lr_decay_step) == 0:
adjust_learning_rate(optimizer, args.lr_decay_gamma)
# test and save
if (Network.iter_counter -
1) % cfg.TRAIN.COMMON.SNAPSHOT_ITERS == 0:
# test network and record results
if cfg.TRAIN.COMMON.SNAPSHOT_AFTER_TEST:
Network.eval()
with torch.no_grad():
current_result = evalute_model(Network,
args.imdbval_name, args)
torch.cuda.empty_cache()
if args.use_tfboard:
for key in current_result.keys():
logger.scalar_summary(key, current_result[key],
Network.iter_counter)
Network.train()
if current_result["Main_Metric"] > best_result:
best_result = current_result["Main_Metric"]
save_flag = True
else:
save_flag = True
if save_flag:
save_name = os.path.join(
output_dir, args.frame +
'_{}_{}_{}.pth'.format(args.session, epoch, step))
save_checkpoint(
{
'session': args.session,
'model': Network.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.RCNN_COMMON.POOLING_MODE,
'class_agnostic': args.class_agnostic,
}, save_name)
print('save model: {}'.format(save_name))
save_flag = False
end_epoch_time = time.time()
print("Epoch finished. Time costing: ",
end_epoch_time - start_epoch_time, "s")
step = 0 # reset step counter
import numpy as np
import pandas as pd
from model.utils.logger import Logger
logger = Logger()
def check_data(config, dataset):
logger.log(f" - 1.1.+ : Check Data Collection")
logger.log(f" - 1.1.1 : Check Columns ")
train_cols = dataset["train"].columns
test_cols = dataset["train"].columns
# union_cols = train_cols.union(test_cols)
# logger.log(f" - Total columns ({len(union_cols)}) : \n List \n {union_cols.values} ")
col_info = []
pd.set_option("display.max_rows", None)
dtype_dict = {
"int64": "Num_desc",
"float64": "Num_cont",
"object": "Cat "
}
# pd.set_option('display.max_seq_items', None)
for col in train_cols:
dtype = dataset["train"][col].dtype.name
na_count = dataset["train"][col].isna().sum()
na_percent = (np.round(
import torch.nn.functional as F
from torch.autograd import Variable
import torchvision.models as models
from torch.autograd import Variable
import numpy as np
from model.utils.config import cfg
from model.rpn.rpn import _RPN
from model.roi_pooling.modules.roi_pool import _RoIPooling
from model.roi_crop.modules.roi_crop import _RoICrop
from model.roi_align.modules.roi_align import RoIAlignAvg
from model.rpn.proposal_target_layer_cascade import _ProposalTargetLayer
import time
import pdb
from model.utils.net_utils import _smooth_l1_loss, _crop_pool_layer, _affine_grid_gen, _affine_theta
from model.utils.logger import Logger
logger_total = Logger('./logs_total')
class _fasterRCNN(nn.Module):
""" faster RCNN """
def __init__(self, classes, class_agnostic):
super(_fasterRCNN, self).__init__()
self.classes = classes
self.n_classes = len(classes)
self.class_agnostic = class_agnostic
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# define rpn
self.RCNN_rpn = _RPN(self.dout_base_model)
def _main_(args):
init_logger()
logger = Logger()
logger.log("Step 0 >> Setting ")
logger.log("Step 1 >> Data Preparation")
logger.log("- 1 : Data Collection ", level=1)
loader = DataLoader(config_path="./config.json")
logger.log("- 2 : Data Analization ", level=1)
analyzer = DataAnalyzer(
config_path="./config.json",
dataset=loader.dataset,
metaset=loader.metaset,
)
analyzer.analize()
logger.log("Step 3 >> Model Generation")
model_generator = ModelGenerator(config_path="./config.json")
models = model_generator.models
logger.log("Step 4 >> Data Preprocess")
preprocessor = PreProcessor(
config_path="./config.json",
dataset=analyzer.dataset,
metaset=analyzer.metaset,
)
# (x_value, x_label), (y_value, y_label) = preprocessor.label_split()
logger.log("Step 5 >> Model Evaluation")
models = model_generator.fit_model(
dataset=analyzer.dataset,
metaset=analyzer.metaset,
)
class DataAnalyzer(object):
def __init__(self, config_path, dataset, metaset):
self.config = open_json(config_path)
self.logger = Logger()
self.eda = EDA(self.config["analyzer"])
self.dataset = dataset
self.metaset = metaset
def analize(self):
dataset = self.dataset
metaset = self.metaset
pd.set_option("display.max_columns", metaset["__ncolumns__"])
pd.set_option("display.width", 1000)
self.logger.log(
f"DATASET Analysis \n"
f" Total Train dataset : {metaset['__nrows__']['train']} \n"
f" Total Test dataset : {metaset['__nrows__']['test']} \n"
f" Total Columns num : {metaset['__ncolumns__']} \n"
f" Target label : {metaset['__target__']} \n"
f" Target dtype : {dataset['train'][metaset['__target__']].dtype} \n"
)
self.eda.countplot(
dataframe=dataset["train"],
column=metaset["__target__"],
title="Target Label Distributions",
)
request_user_input()
self.analize_dtype() # 2.1
self.analize_feature()
def analize_dtype(self):
self.logger.log(" - 2.1 Analize Dtype", level=2)
# SHOW INFO
print(get_meta_info(self.metaset, self.dataset))
# USER COMMAND
answer = ask_boolean("Are there any issues that need to be corrected?")
while answer:
target_index = request_user_input(
f"Please enter the index of the target to be modified.",
valid_inputs=range(self.metaset["__ncolumns__"]),
skipable=True,
default=None,
)
if target_index is None:
break
target_col = self.metaset["__columns__"][int(target_index)]
self.convert_dtype(target_col)
print(get_meta_info(self.metaset, self.dataset))
answer = ask_boolean(
"Are there any issues that need to be corrected?")
def analize_dataset(self):
metaset = self.metaset
dataset = self.dataset
self.logger.log(
f"DATASET Analysis \n"
f" Total Train dataset : {metaset['__nrows__']['train']} \n"
f" Total Test dataset : {metaset['__nrows__']['test']} \n"
f" Total Columns num : {metaset['__ncolumns__']} \n"
f" Target label : {metaset['__target__']} \n"
f" [train distribute(percent.)]\n{metaset['__distribution__']['train']} \n"
f" [test distribute(percent.)]\n{metaset['__distribution__']['test']} \n"
)
request_user_input()
for i, col in enumerate(metaset["__columns__"]):
col_meta = metaset[col]
self.logger.log(f"{col_meta['index']:3d} "
f"{col_meta['name']:20} "
f"{col_meta['dtype']:10} "
f"{col_meta['descript']}")
answer = ask_boolean("Are there any issues that need to be corrected?")
self.config["options"]["FIX_COLUMN_INFO"] = answer
if self.config["options"]["FIX_COLUMN_INFO"] is True:
self.analize_feature()
def analize_feature(self):
self.logger.log("- 2.2 : Check Data Features", level=2)
for i, col in enumerate(self.metaset["__columns__"]):
col_meta = self.metaset[col]
col_data = self.dataset["train"][col]
show_col_info(col_meta, col_data)
answer = ask_boolean(
"Are there any issues that need to be corrected?", default="N")
while answer:
target = request_user_input(
f"Please enter issue [none, dtype]",
valid_inputs=["dtype"],
skipable=True,
default=None,
)
if target == "Dtype":
self.convert_dtype(col)
show_col_info(col_meta, col_data)
answer = ask_boolean(
"Are there any issues that need to be corrected?",
default="N")
print(get_meta_info(self.metaset, self.dataset))
return self.dataset
def convert_dtype(self, col):
right_dtype = request_user_input(
f"Please enter right dtype [num-int, num-float, bool, category, datetime]",
valid_inputs=[
"num-int", "num-float", "bool", "category", "datetime"
],
skipable=True,
default=None,
)
print(f"you select dtype {right_dtype}")
if right_dtype == "Datetime":
self.convert_datetime(col)
elif right_dtype == "Category":
self.convert_category(col)
elif right_dtype == "Bool":
self.convert_boolean(col)
def convert_datetime(self, col):
self.dataset["train"][col] = pd.to_datetime(self.dataset["train"][col])
self.metaset[col]["log"].append(
f"dtype changed : {self.metaset[col]['dtype']} to Datetime")
self.metaset[col]["dtype"] = "Datetime"
answer = ask_boolean("Do you want to split datetime?")
if answer:
metaset, trainset = self.metaset, self.dataset["train"]
metaset, trainset[f"{col}_year"] = add_col_info(
metaset, trainset[col].dt.year, f"{col}_year")
metaset, trainset[f"{col}_month"] = add_col_info(
metaset, trainset[col].dt.month, f"{col}_month")
metaset, trainset[f"{col}_day"] = add_col_info(
metaset, trainset[col].dt.day, f"{col}_day")
metaset, trainset[f"{col}_hour"] = add_col_info(
metaset, trainset[col].dt.hour, f"{col}_hour")
metaset, trainset[f"{col}_dow"] = add_col_info(
metaset, trainset[col].dt.day_name(), f"{col}_dow")
self.metaset = metaset
self.dataset["train"] = trainset
def convert_category(self, col):
col_meta = self.metaset[col]
col_data = self.dataset["train"][col]
col_data = col_data.apply(str)
col_meta["log"].append(
f"dtype changed : {col_meta['dtype']} to Category")
col_meta["dtype"] = "Category"
col_meta["unique"] = col_data.unique()
col_meta["rate"] = (col_data.value_counts(), )
self.metaset[col] = col_meta
self.dataset["train"][col] = col_data
def convert_boolean(self, col):
col_meta = self.metaset[col]
col_data = self.dataset["train"][col]
col_data = col_data.apply(str)
col_meta["log"].append(
f"dtype changed : {col_meta['dtype']} to Boolean")
col_meta["dtype"] = "Boolean"
col_meta["rate"] = col_data.value_counts()
self.metaset[col] = col_meta
self.dataset["train"][col] = col_data
def get_meta_info(self, columns):
info = list()
for col in columns:
col_meta = self.metaset[col]
col_info = {
"name": col,
"dtype": col_meta["dtype"],
"desc": col_meta["descript"],
}
for i in range(1, 6):
col_info[f"sample{i}"] = self.dataset["train"][col][i]
info.append(col_info)
info_df = pd.DataFrame(info)
self.logger.log(f" - Dtype \n {info_df}\n\n", level=3)
return info_df
def train(dataset="kaggle_pna",
train_ds="train",
arch="couplenet",
net="res152",
start_epoch=1,
max_epochs=20,
disp_interval=100,
save_dir="save",
num_workers=4,
cuda=True,
large_scale=False,
mGPUs=True,
batch_size=4,
class_agnostic=False,
anchor_scales=4,
optimizer="sgd",
lr_decay_step=10,
lr_decay_gamma=.1,
session=1,
resume=False,
checksession=1,
checkepoch=1,
checkpoint=0,
use_tfboard=False,
flip_prob=0.0,
scale=0.0,
scale_prob=0.0,
translate=0.0,
translate_prob=0.0,
angle=0.0,
dist="cont",
rotate_prob=0.0,
shear_factor=0.0,
shear_prob=0.0,
rpn_loss_cls_wt=1,
rpn_loss_box_wt=1,
RCNN_loss_cls_wt=1,
RCNN_loss_bbox_wt=1,
**kwargs):
print("Train Arguments: {}".format(locals()))
# Import network definition
if arch == 'rcnn':
from model.faster_rcnn.resnet import resnet
elif arch == 'rfcn':
from model.rfcn.resnet_atrous import resnet
elif arch == 'couplenet':
from model.couplenet.resnet_atrous import resnet
from roi_data_layer.pnaRoiBatchLoader import roibatchLoader
from roi_data_layer.pna_roidb import combined_roidb
print('Called with kwargs:')
print(kwargs)
# Set up logger
if use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger('./logs')
# Anchor settings: ANCHOR_SCALES: [8, 16, 32] or [4, 8, 16, 32]
if anchor_scales == 3:
scales = [8, 16, 32]
elif anchor_scales == 4:
scales = [4, 8, 16, 32]
# Dataset related settings: MAX_NUM_GT_BOXES: 20, 30, 50
if train_ds == "train":
imdb_name = "pna_2018_train"
elif train_ds == "trainval":
imdb_name = "pna_2018_trainval"
set_cfgs = [
'ANCHOR_SCALES',
str(scales), 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '30'
]
import model
model_repo_path = os.path.dirname(
os.path.dirname(os.path.dirname(model.__file__)))
cfg_file = "cfgs/{}_ls.yml".format(
net) if large_scale else "cfgs/{}.yml".format(net)
if cfg_file is not None:
cfg_from_file(os.path.join(model_repo_path, cfg_file))
if set_cfgs is not None:
cfg_from_list(set_cfgs)
train_kwargs = kwargs.pop("TRAIN", None)
resnet_kwargs = kwargs.pop("RESNET", None)
mobilenet_kwargs = kwargs.pop("MOBILENET", None)
if train_kwargs is not None:
for key, value in train_kwargs.items():
cfg["TRAIN"][key] = value
if resnet_kwargs is not None:
for key, value in resnet_kwargs.items():
cfg["RESNET"][key] = value
if mobilenet_kwargs is not None:
for key, value in mobilenet_kwargs.items():
cfg["MOBILENET"][key] = value
if kwargs is not None:
for key, value in kwargs.items():
cfg[key] = value
print('Using config:')
cfg.MODEL_DIR = os.path.abspath(cfg.MODEL_DIR)
cfg.TRAIN_DATA_CLEAN_PATH = os.path.abspath(cfg.TRAIN_DATA_CLEAN_PATH)
pprint.pprint(cfg)
np.random.seed(cfg.RNG_SEED)
print("LEARNING RATE: {}".format(cfg.TRAIN.LEARNING_RATE))
# Warning to use cuda if available
if torch.cuda.is_available() and not cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
# Train set
# Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = cuda
imdb, roidb, ratio_list, ratio_index = combined_roidb(imdb_name)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
# output_dir = os.path.join(save_dir, arch, net, dataset)
output_dir = cfg.MODEL_DIR
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch = sampler(train_size, batch_size)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
batch_size,
imdb.num_classes,
training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
sampler=sampler_batch,
num_workers=num_workers)
# Initilize the tensor holder
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# Copy tensors in CUDA memory
if cuda:
im_data = im_data.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
# Make variable
im_data = Variable(im_data)
im_info = Variable(im_info)
num_boxes = Variable(num_boxes)
gt_boxes = Variable(gt_boxes)
if cuda:
cfg.CUDA = True
# Initilize the network:
if net == 'vgg16':
# model = vgg16(imdb.classes, pretrained=True, class_agnostic=args.class_agnostic)
print("Pretrained model is not downloaded and network is not used")
elif net == 'res18':
model = resnet(imdb.classes,
18,
pretrained=False,
class_agnostic=class_agnostic) # TODO: Check dim error
elif net == 'res34':
model = resnet(imdb.classes,
34,
pretrained=False,
class_agnostic=class_agnostic) # TODO: Check dim error
elif net == 'res50':
model = resnet(imdb.classes,
50,
pretrained=False,
class_agnostic=class_agnostic) # TODO: Check dim error
elif net == 'res101':
model = resnet(imdb.classes,
101,
pretrained=True,
class_agnostic=class_agnostic)
elif net == 'res152':
model = resnet(imdb.classes,
152,
pretrained=True,
class_agnostic=class_agnostic)
else:
print("network is not defined")
pdb.set_trace()
# Create network architecture
model.create_architecture()
# Update model parameters
lr = cfg.TRAIN.LEARNING_RATE
# tr_momentum = cfg.TRAIN.MOMENTUM
# tr_momentum = args.momentum
params = []
for key, value in dict(model.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params': [value], 'lr': lr * (cfg.TRAIN.DOUBLE_BIAS + 1), \
'weight_decay': cfg.TRAIN.BIAS_DECAY and cfg.TRAIN.WEIGHT_DECAY or 0}]
else:
params += [{
'params': [value],
'lr': lr,
'weight_decay': cfg.TRAIN.WEIGHT_DECAY
}]
# Optimizer
if optimizer == "adam":
lr = lr * 0.1
optimizer = torch.optim.Adam(params)
elif optimizer == "sgd":
optimizer = torch.optim.SGD(params, momentum=cfg.TRAIN.MOMENTUM)
# Resume training
if resume:
load_name = os.path.join(
output_dir, '{}_{}_{}_{}.pth'.format(arch, checksession,
checkepoch, checkpoint))
print("loading checkpoint %s" % (load_name))
checkpoint = torch.load(load_name)
session = checkpoint['session'] + 1
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr = optimizer.param_groups[0]['lr']
if 'pooling_mode' in checkpoint.keys():
cfg.POOLING_MODE = checkpoint['pooling_mode']
print("loaded checkpoint %s" % (load_name))
# Train on Multiple GPUS
if mGPUs:
model = nn.DataParallel(model)
# Copy network to CUDA memroy
if cuda:
model.cuda()
# Training loop
iters_per_epoch = int(train_size / batch_size)
sys.stdout.flush()
for epoch in range(start_epoch, max_epochs + 1):
# remove batch re-sizing for augmentation or adjust?
dataset.resize_batch()
# Set model to train mode
model.train()
loss_temp = 0
start = time.time()
# Update learning rate as per decay step
if epoch % (lr_decay_step + 1) == 0:
adjust_learning_rate(optimizer, lr_decay_gamma)
lr *= lr_decay_gamma
# Get batch data and train
data_iter = iter(dataloader)
for step in range(iters_per_epoch):
sys.stdout.flush()
data = next(data_iter)
# Apply augmentations
aug_img_tensors, aug_bbox_tensors = apply_augmentations(
data[0],
data[2],
flip_prob=flip_prob,
scale=scale,
scale_prob=scale_prob,
translate=translate,
translate_prob=translate_prob,
angle=angle,
dist=dist,
rotate_prob=rotate_prob,
shear_factor=shear_factor,
shear_prob=shear_prob)
# im_data.data.resize_(data[0].size()).copy_(data[0])
im_data.data.resize_(aug_img_tensors.size()).copy_(aug_img_tensors)
im_info.data.resize_(data[1].size()).copy_(data[1])
# gt_boxes.data.resize_(data[2].size()).copy_(data[2])
gt_boxes.data.resize_(
aug_bbox_tensors.size()).copy_(aug_bbox_tensors)
num_boxes.data.resize_(data[3].size()).copy_(data[3])
# Compute multi-task loss
model.zero_grad()
rois, cls_prob, bbox_pred, \
rpn_loss_cls, rpn_loss_box, \
RCNN_loss_cls, RCNN_loss_bbox, \
rois_label = model(im_data, im_info, gt_boxes, num_boxes)
loss = rpn_loss_cls_wt * rpn_loss_cls.mean() + rpn_loss_box_wt * rpn_loss_box.mean() + \
RCNN_loss_cls_wt * RCNN_loss_cls.mean() + RCNN_loss_bbox_wt * RCNN_loss_bbox.mean()
loss_temp += loss.data[0]
# Backward pass to compute gradients and update weights
optimizer.zero_grad()
loss.backward()
if net == "vgg16":
clip_gradient(model, 10.)
optimizer.step()
# Display training stats on terminal
if step % disp_interval == 0:
end = time.time()
if step > 0:
loss_temp /= disp_interval
if mGPUs:
batch_loss = loss.data[0]
loss_rpn_cls = rpn_loss_cls.mean().data[0]
loss_rpn_box = rpn_loss_box.mean().data[0]
loss_rcnn_cls = RCNN_loss_cls.mean().data[0]
loss_rcnn_box = RCNN_loss_bbox.mean().data[0]
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
else:
batch_loss = loss.data[0]
loss_rpn_cls = rpn_loss_cls.data[0]
loss_rpn_box = rpn_loss_box.data[0]
loss_rcnn_cls = RCNN_loss_cls.data[0]
loss_rcnn_box = RCNN_loss_bbox.data[0]
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
print("[session %d][epoch %2d][iter %4d/%4d] loss: %.4f, lr: %.2e" \
% (session, epoch, step, iters_per_epoch, loss_temp, lr))
print("\t\t\tfg/bg=(%d/%d), time cost: %f" %
(fg_cnt, bg_cnt, end - start))
print("\t\t\t batch_loss: %.4f, rpn_cls: %.4f, rpn_box: %.4f, rcnn_cls: %.4f, rcnn_box %.4f" \
% (batch_loss, loss_rpn_cls, loss_rpn_box, loss_rcnn_cls, loss_rcnn_box))
if use_tfboard:
info = {
'loss': loss_temp,
'loss_rpn_cls': loss_rpn_cls,
'loss_rpn_box': loss_rpn_box,
'loss_rcnn_cls': loss_rcnn_cls,
'loss_rcnn_box': loss_rcnn_box
}
for tag, value in info.items():
logger.scalar_summary(tag, value, step)
loss_temp = 0
start = time.time()
# Save model at checkpoints
if mGPUs:
save_name = os.path.join(
output_dir, '{}_{}_{}_{}.pth'.format(arch, session, epoch,
step))
save_checkpoint(
{
'session': session,
'epoch': epoch + 1,
'model': model.module.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.POOLING_MODE,
'class_agnostic': class_agnostic,
}, save_name)
else:
save_name = os.path.join(
output_dir, '{}_{}_{}_{}.pth'.format(arch, session, epoch,
step))
save_checkpoint(
{
'session': session,
'epoch': epoch + 1,
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.POOLING_MODE,
'class_agnostic': class_agnostic,
}, save_name)
print('save model: {}'.format(save_name))
end = time.time()
delete_older_checkpoints(
os.path.join(cfg.MODEL_DIR, "couplenet_{}_*.pth".format(i)))
print("Run Time: ", end - start)
class DataLoader(object):
"""
Data Loader
"""
def __init__(self, config_path):
self.config = open_json(config_path)
self.filepath = self.config["dataset"]["filepath"]
self.basepath = self.config["dataset"]["dirpath"]
self.format = self.config["dataset"]["format"].lower()
self.logger = Logger()
self.dataset = self.load_dataset() # 1.1
self.metaset = self.load_metaset() # 1.2
def load_dataset(self):
"""
1.1 Data Loading
"""
self.logger.log(
f"- 1.1 {self.config['dataset']['category']} type dataset loading .. ",
level=2,
)
self.filepath = os.path.join(self.basepath, self.filepath)
self.logger.log(f"- '{self.filepath}' is now loading...", level=2)
dataset = {
"train": self.read_csv("train"),
"valid": self.read_csv("valid"),
"test": self.read_csv("test"),
}
if dataset["test"] is None:
dataset = self.split_dataset(dataset, "train", "test")
return dataset
def read_csv(self, name):
filepath = os.path.join(self.basepath, self.filepath, name + "." + self.format)
index_col = self.config["dataset"].get("index", None)
index_col = index_col if index_col != "None" else None
try:
csv_file = open_csv(filepath=filepath, index_col=index_col)
self.logger.log(f"- {name:5} data{csv_file.shape} is now loaded", level=3)
except FileNotFoundError:
csv_file = None
return csv_file
def split_dataset(self, dataset, origin, target):
split_ratio = self.config["dataset"]["split_ratio"]
dataset[origin], dataset[target] = train_test_split(
dataset[origin], train_size=split_ratio, random_state=42
)
self.logger.log(
f"- {origin:5} data{dataset[origin].shape}"
f", {target:5} data{dataset[target].shape}"
f" (split ratio: {split_ratio})",
level=3,
)
return dataset
def load_metaset(self):
"""
1.2
"""
self.logger.log(f"- 1.2 Prepare metadata", level=2)
def convert_dict(dtype):
return {
"Int64": "Num_int",
"Float64": "Num_float",
"object": "Cat",
}[dtype.name]
metaset = init_set_info(self.config, self.dataset)
metaset = self.read_description(metaset)
for i, col in enumerate(metaset["__columns__"]):
col_data = self.dataset["train"][col].convert_dtypes()
metaset[col] = init_col_info(metaset, col_data, col)
return metaset
def read_description(self, metaset):
descfile = self.config["metaset"].get("descpath", None)
if descfile is None:
return metaset
descpath = os.path.join(
self.config["dataset"]["dirpath"],
self.config["dataset"]["filepath"],
descfile,
)
try:
with open(descpath, "r", newline="\r\n") as desc_file:
self.logger.log(f"- '{descpath}' is now loaded", level=3)
desc_list = desc_file.read().splitlines()
for desc_line in desc_list:
col, desc = desc_line.split(":")
metaset[col]["descript"] = desc.strip()
return metaset
except FileNotFoundError as e:
self.logger.warn(f"Description File Not Found Error, '{descpath}'")
return metaset
def __len__(self):
return self.num_data
if __name__ == "__main__":
args = parse_args()
print("Called with args:")
print(args)
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger("./logs/" + args.tfboard_path)
if args.dataset == "charades":
args.imdb_name = "charades_train"
args.imdbval_name = "charades_test"
args.set_cfgs = [
"ANCHOR_SCALES",
"[1]",
"ANCHOR_RATIOS",
"[1]",
"MAX_NUM_GT_BOXES",
"5",
]
args.cfg_file = ("cfgs/{}_ls.yml".format(args.net)
if args.large_scale else "cfgs/{}.yml".format(args.net))
'loss_rcnn_twin': loss_rcnn_twin
}
for tag, value in info.items():
logger.scalar_summary(tag, value, step)
loss_temp = 0
if __name__ == '__main__':
args = parse_args()
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger('./logs')
if args.dataset == "thumos14":
args.imdb_name = "train_data_25fps_flipped.pkl"
args.imdbval_name = "val_data_25fps.pkl"
args.num_classes = 21
args.set_cfgs = [
'ANCHOR_SCALES', '[2,4,5,6,8,9,10,12,14,16]', 'NUM_CLASSES',
args.num_classes
]
# args.set_cfgs = ['ANCHOR_SCALES', '[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56]', 'NUM_CLASSES', args.num_classes]
elif args.dataset == "activitynet":
args.imdb_name = "train_data_25fps_flipped.pkl" # _192.pkl"
args.imdbval_name = "val_data_25fps.pkl"
args.num_classes = 201
# args.set_cfgs = ['ANCHOR_SCALES', '[1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64]', 'NUM_CLASSES', args.num_classes] / stride
class sampler(Sampler):
def __init__(self, train_size, batch_size):
self.num_data = train_size
self.num_per_batch = int(train_size / batch_size)
self.batch_size = batch_size
self.range = torch.arange(0, batch_size).view(1, batch_size).long()
self.leftover_flag = False
if train_size % batch_size:
self.leftover = torch.arange(self.num_per_batch * batch_size,
train_size).long()
self.leftover_flag = True
def __iter__(self):
rand_num = torch.randperm(self.num_per_batch).view(-1,
1) * self.batch_size
self.rand_num = rand_num.expand(self.num_per_batch,
self.batch_size) + self.range
self.rand_num_view = self.rand_num.view(-1)
if self.leftover_flag:
self.rand_num_view = torch.cat((self.rand_num_view, self.leftover),
0)
return iter(self.rand_num_view)
def __len__(self):
return self.num_data
args = parse_args()
print('Called with args:')
print(args)
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger(args.log_dir)
if args.dataset == "pascal_voc":
args.imdb_name = "voc_2007_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
elif args.dataset == "pascal_voc_0712":
args.imdb_name = "voc_2007_trainval+voc_2012_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
elif args.dataset == "coco":
args.imdb_name = "coco_2014_train+coco_2014_valminusminival"
args.imdbval_name = "coco_2014_minival"
args.set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '50'
]
elif args.dataset == "imagenet":
args.imdb_name = "imagenet_train"
args.imdbval_name = "imagenet_val"
args.set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '30'
]
elif args.dataset == "vg":
# train sizes: train, smalltrain, minitrain
# train scale: ['150-50-20', '150-50-50', '500-150-80', '750-250-150', '1750-700-450', '1600-400-20']
args.imdb_name = "vg_train"
args.imdbval_name = "vg_val"
args.set_cfgs = [
'ANCHOR_SCALES', '[2, 4, 8, 16, 32]', 'MAX_NUM_GT_BOXES', '50'
]
# args.set_cfgs = ['ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '50']
# args.cfg_file = "cfgs/{}_ls.yml".format(args.net) if args.large_scale else "cfgs/{}.yml".format(args.net)
args.cfg_file = "cfgs/res101_ms.yml" #.format(args.net + "_ms" if args.multi_scale else "")
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
print('Using config:')
pprint.pprint(cfg)
np.random.seed(cfg.RNG_SEED)
#torch.backends.cudnn.benchmark = True
if torch.cuda.is_available() and not args.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
# train set
# -- Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = args.cuda
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
sys.stdout.flush()
output_dir = args.save_dir[0] + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# log_f = open(os.path.join(args.log_dir, time.strftime("%Y-%m-%d-%H:%M.txt", time.localtime())), "w")
# old_stdout = sys.stdout
# sys.stdout = log_f
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
args.batch_size,
imdb.num_classes,
training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers,
pin_memory=False)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# attr_prob = torch.FloatTensor(imdb._clscls_attr)
# attr_prob = torch.FloatTensor(cout_a(imdb._class_to_attr, 200))
# pair_prob = torch.FloatTensor(cout_w(imdb.pair))
# pair_prob = pair_prob.unsqueeze(0).repeat(args.batch_size, 1, 1)
# ship to cuda
if args.cuda:
im_data = im_data.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
# make variable
im_data = Variable(im_data)
im_info = Variable(im_info)
num_boxes = Variable(num_boxes)
gt_boxes = Variable(gt_boxes)
# pair_prob = Variable(pair_prob)
# attr_prob = Variable(attr_prob)
if args.cuda:
cfg.CUDA = True
# initilize the network here.
if args.net == 'baseline':
fasterRCNN = resnet(imdb.classes,
101,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'relationloss':
fasterRCNN = resnet(imdb.classes,
101,
pretrained=False,
class_agnostic=args.class_agnostic,
pair_prob=pair_prob)
elif args.net == 'attributeloss':
fasterRCNN = resnet(imdb.classes,
101,
pretrained=True,
class_agnostic=args.class_agnostic,
attr_prob=attr_prob)
fasterRCNN.create_architecture()
lr = cfg.TRAIN.LEARNING_RATE
lr = args.lr
#tr_momentum = cfg.TRAIN.MOMENTUM
#tr_momentum = args.momentum
params = []
for key, value in dict(fasterRCNN.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params':[value],'lr':lr*(cfg.TRAIN.DOUBLE_BIAS + 1), \
'weight_decay': cfg.TRAIN.BIAS_DECAY and cfg.TRAIN.WEIGHT_DECAY or 0}]
else:
params += [{
'params': [value],
'lr': lr,
'weight_decay': cfg.TRAIN.WEIGHT_DECAY
}]
if args.optimizer == "adam":
lr = lr * 0.1
optimizer = torch.optim.Adam(params)
elif args.optimizer == "sgd":
optimizer = torch.optim.SGD(params, momentum=cfg.TRAIN.MOMENTUM)
if args.resume:
load_name = os.path.join(
output_dir,
'faster_rcnn_{}_{}_{}.pth'.format(args.checksession,
args.checkepoch,
args.checkpoint))
print("loading checkpoint %s" % (load_name))
checkpoint = torch.load(load_name)
args.session = checkpoint['session']
args.start_epoch = checkpoint['epoch']
fasterRCNN.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr = optimizer.param_groups[0]['lr']
if 'pooling_mode' in checkpoint.keys():
cfg.POOLING_MODE = checkpoint['pooling_mode']
print("loaded checkpoint %s" % (load_name))
if args.mGPUs:
fasterRCNN = nn.DataParallel(fasterRCNN)
if args.cuda:
fasterRCNN.cuda()
iters_per_epoch = int(train_size / args.batch_size)
if args.arch == 'rcnn':
from model.faster_rcnn.vgg16 import vgg16
from model.faster_rcnn.resnet import resnet
elif args.arch == 'rfcn':
from model.rfcn.resnet_atrous import resnet
elif args.arch == 'couplenet':
from model.couplenet.resnet_atrous import resnet
print('Called with args:')
print(args)
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger('./logs')
if args.dataset == "pascal_voc":
args.imdb_name = "voc_2007_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '20']
elif args.dataset == "pascal_voc_0712":
args.imdb_name = "voc_2007_trainval+voc_2012_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '20']
elif args.dataset == "coco":
args.imdb_name = "coco_2014_train+coco_2014_valminusminival"
args.imdbval_name = "coco_2014_minival"
args.set_cfgs = ['ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '50']
elif args.dataset == "imagenet":
args.imdb_name = "imagenet_train"
def bld_train(args, ann_path=None, step=0):
# print('Train from annotaion {}'.format(ann_path))
# print('Called with args:')
# print(args)
if args.use_tfboard:
from model.utils.logger import Logger
# Set the logger
logger = Logger(
os.path.join('./.logs', args.active_method,
"/activestep" + str(step)))
if args.dataset == "pascal_voc":
args.imdb_name = "voc_2007_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
elif args.dataset == "pascal_voc_0712":
args.imdb_name = "voc_2007_trainval+voc_2012_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
elif args.dataset == "coco":
args.imdb_name = "coco_2014_train"
args.imdbval_name = "coco_2014_minival"
args.set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '50'
]
elif args.dataset == "imagenet":
args.imdb_name = "imagenet_train"
args.imdbval_name = "imagenet_val"
args.set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '30'
]
elif args.dataset == "vg":
# train sizes: train, smalltrain, minitrain
# train scale: ['150-50-20', '150-50-50', '500-150-80', '750-250-150', '1750-700-450', '1600-400-20']
args.imdb_name = "vg_150-50-50_minitrain"
args.imdbval_name = "vg_150-50-50_minival"
args.set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '50'
]
elif args.dataset == "voc_coco":
args.imdb_name = "voc_coco_2007_train+voc_coco_2007_val"
args.imdbval_name = "voc_coco_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]',
'MAX_NUM_GT_BOXES', '20'
]
else:
raise NotImplementedError
args.cfg_file = "cfgs/{}_ls.yml".format(
args.net) if args.large_scale else "cfgs/{}.yml".format(args.net)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
# print('Using config:')
# pprint.pprint(cfg)
# np.random.seed(cfg.RNG_SEED)
# torch.backends.cudnn.benchmark = True
if torch.cuda.is_available() and not args.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
# train set = source set + target set
# -- Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = args.cuda
# source train set, fully labeled
#ann_path_source = os.path.join(ann_path, 'voc_coco_2007_train_f.json')
#ann_path_target = os.path.join(ann_path, 'voc_coco_2007_train_l.json')
imdb, roidb, ratio_list, ratio_index = combined_roidb(
args.imdb_name, ann_path=os.path.join(ann_path, 'source'))
imdb_tg, roidb_tg, ratio_list_tg, ratio_index_tg = combined_roidb(
args.imdb_name, ann_path=os.path.join(ann_path, 'target'))
print('{:d} roidb entries for source set'.format(len(roidb)))
print('{:d} roidb entries for target set'.format(len(roidb_tg)))
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset + "/" + args.active_method + "/activestep" + str(
step)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch_tg = None # do not sample target set
bs_tg = 4
dataset_tg = roibatchLoader(roidb_tg, ratio_list_tg, ratio_index_tg, bs_tg, \
imdb_tg.num_classes, training=True)
assert imdb.num_classes == imdb_tg.num_classes
dataloader_tg = torch.utils.data.DataLoader(dataset_tg,
batch_size=bs_tg,
sampler=sampler_batch_tg,
num_workers=args.num_workers,
worker_init_fn=_rand_fn())
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
image_label = torch.FloatTensor(1)
confidence = torch.FloatTensor(1)
# ship to cuda
if args.cuda:
im_data = im_data.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
image_label = image_label.cuda()
confidence = confidence.cuda()
# make variable
im_data = Variable(im_data)
im_info = Variable(im_info)
num_boxes = Variable(num_boxes)
gt_boxes = Variable(gt_boxes)
image_label = Variable(image_label)
confidence = Variable(confidence)
if args.cuda:
cfg.CUDA = True
# initialize the network here.
if args.net == 'vgg16':
fasterRCNN = vgg16(imdb.classes,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'res101':
fasterRCNN = resnet(imdb.classes,
101,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'res50':
fasterRCNN = resnet(imdb.classes,
50,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'res152':
fasterRCNN = resnet(imdb.classes,
152,
pretrained=True,
class_agnostic=args.class_agnostic)
else:
print("network is not defined")
raise NotImplementedError
# initialize the expectation network.
if args.net == 'vgg16':
fasterRCNN_val = vgg16(imdb.classes,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'res101':
fasterRCNN_val = resnet(imdb.classes,
101,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'res50':
fasterRCNN_val = resnet(imdb.classes,
50,
pretrained=True,
class_agnostic=args.class_agnostic)
elif args.net == 'res152':
fasterRCNN_val = resnet(imdb.classes,
152,
pretrained=True,
class_agnostic=args.class_agnostic)
else:
print("network is not defined")
raise NotImplementedError
fasterRCNN.create_architecture()
fasterRCNN_val.create_architecture()
# lr = cfg.TRAIN.LEARNING_RATE
lr = args.lr
# tr_momentum = cfg.TRAIN.MOMENTUM
# tr_momentum = args.momentum
params = []
for key, value in dict(fasterRCNN.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params': [value], 'lr': lr * (cfg.TRAIN.DOUBLE_BIAS + 1), \
'weight_decay': cfg.TRAIN.BIAS_DECAY and cfg.TRAIN.WEIGHT_DECAY or 0}]
else:
params += [{
'params': [value],
'lr': lr,
'weight_decay': cfg.TRAIN.WEIGHT_DECAY
}]
if args.optimizer == "adam":
lr = lr * 0.1
optimizer = torch.optim.Adam(params)
elif args.optimizer == "sgd":
optimizer = torch.optim.SGD(params, momentum=cfg.TRAIN.MOMENTUM)
else:
raise NotImplementedError
if args.resume:
load_name = os.path.join(
output_dir,
'faster_rcnn_{}_{}_{}.pth'.format(args.checksession,
args.checkepoch,
args.checkpoint))
print("loading checkpoint %s" % (load_name))
checkpoint = torch.load(load_name)
args.session = checkpoint['session']
args.start_epoch = checkpoint['epoch']
fasterRCNN.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr = optimizer.param_groups[0]['lr']
if 'pooling_mode' in checkpoint.keys():
cfg.POOLING_MODE = checkpoint['pooling_mode']
print("loaded checkpoint %s" % (load_name))
# expectation model
print("load checkpoint for expectation model: %s" % args.model_path)
checkpoint = torch.load(args.model_path)
fasterRCNN_val.load_state_dict(checkpoint['model'])
if 'pooling_mode' in checkpoint.keys():
cfg.POOLING_MODE = checkpoint['pooling_mode']
fasterRCNN_val = fasterRCNN_val
fasterRCNN_val.eval()
if args.mGPUs:
fasterRCNN = nn.DataParallel(fasterRCNN)
#fasterRCNN_val = nn.DataParallel(fasterRCNN_val)
if args.cuda:
fasterRCNN.cuda()
fasterRCNN_val.cuda()
# Evaluation
# data_iter = iter(dataloader_tg)
# for target_k in range( int(train_size_tg / args.batch_size)):
fname = "noisy_annotations.pkl"
if not os.path.isfile(fname):
for batch_k, data in enumerate(dataloader_tg):
im_data.data.resize_(data[0].size()).copy_(data[0])
im_info.data.resize_(data[1].size()).copy_(data[1])
gt_boxes.data.resize_(data[2].size()).copy_(data[2])
num_boxes.data.resize_(data[3].size()).copy_(data[3])
image_label.data.resize_(data[4].size()).copy_(data[4])
b_size = len(im_data)
# expactation pass
rois, cls_prob, bbox_pred, \
_, _, _, _, _ = fasterRCNN_val(im_data, im_info, gt_boxes, num_boxes)
scores = cls_prob.data
boxes = rois.data[:, :, 1:5]
if cfg.TRAIN.BBOX_REG:
# Apply bounding-box regression deltas
box_deltas = bbox_pred.data
if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:
# Optionally normalize targets by a precomputed mean and stdev
if args.class_agnostic:
box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
+ torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
box_deltas = box_deltas.view(b_size, -1, 4)
else:
box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
+ torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
# print('DEBUG: Size of box_deltas is {}'.format(box_deltas.size()) )
box_deltas = box_deltas.view(b_size, -1,
4 * len(imdb.classes))
pred_boxes = bbox_transform_inv(boxes, box_deltas, 1)
pred_boxes = clip_boxes(pred_boxes, im_info.data, 1)
else:
# Simply repeat the boxes, once for each class
pred_boxes = np.tile(boxes, (1, scores.shape[1]))
# TODO: data distalliation
# Choose the confident samples
for b_idx in range(b_size):
# fill one confidence
# confidence.data[b_idx, :] = 1 - (gt_boxes.data[b_idx, :, 4] == 0)
# resize prediction
pred_boxes[b_idx] /= data[1][b_idx][2]
for j in xrange(1, imdb.num_classes):
if image_label.data[b_idx, j] != 1:
continue # next if no image label
# filtering box outside of the image
not_keep = (pred_boxes[b_idx][:, j * 4] == pred_boxes[b_idx][:, j * 4 + 2]) | \
(pred_boxes[b_idx][:, j * 4 + 1] == pred_boxes[b_idx][:, j * 4 + 3])
keep = torch.nonzero(not_keep == 0).view(-1)
# decease the number of pgts
thresh = 0.5
while torch.nonzero(
scores[b_idx, :,
j][keep] > thresh).view(-1).numel() <= 0:
thresh = thresh * 0.5
inds = torch.nonzero(
scores[b_idx, :, j][keep] > thresh).view(-1)
# if there is no det, error
if inds.numel() <= 0:
print('Warning!!!!!!! It should not appear!!')
continue
# find missing ID
missing_list = np.where(gt_boxes.data[b_idx, :, 4] == 0)[0]
if (len(missing_list) == 0): continue
missing_id = missing_list[0]
cls_scores = scores[b_idx, :, j][keep][inds]
cls_boxes = pred_boxes[b_idx][keep][inds][:, j *
4:(j + 1) * 4]
cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)),
1)
keep = nms(cls_dets, 0.2) # Magic number ????
keep = keep.view(-1).tolist()
sys.stdout.write(
'from {} predictions choose-> min({},4) as pseudo label \r'
.format(len(cls_scores), len(keep)))
sys.stdout.flush()
_, order = torch.sort(cls_scores[keep], 0, True)
if len(keep) == 0: continue
max_keep = 4
for pgt_k in range(max_keep):
if len(order) <= pgt_k: break
if missing_id + pgt_k >= 20: break
gt_boxes.data[b_idx, missing_id +
pgt_k, :4] = cls_boxes[keep][order[
len(order) - 1 - pgt_k]]
gt_boxes.data[b_idx, missing_id + pgt_k,
4] = j # class
#confidence[b_idx, missing_id + pgt_k] = cls_scores[keep][order[len(order) - 1 - pgt_k]]
num_boxes[b_idx] = num_boxes[b_idx] + 1
sample = roidb_tg[dataset_tg.ratio_index[batch_k * bs_tg +
b_idx]]
pgt_boxes = np.array([
gt_boxes[b_idx, x, :4].cpu().data.numpy()
for x in range(int(num_boxes[b_idx]))
])
pgt_classes = np.array([
gt_boxes[b_idx, x, 4].cpu().data[0]
for x in range(int(num_boxes[b_idx]))
])
sample["boxes"] = pgt_boxes
sample["gt_classes"] = pgt_classes
# DEBUG
assert np.array_equal(sample["label"],image_label[b_idx].cpu().data.numpy()), \
"Image labels are not equal! {} vs {}".format(sample["label"],image_label[b_idx].cpu().data.numpy())
#with open(fname, 'w') as f:
# pickle.dump(roidb_tg, f)
else:
pass
# with open(fname) as f: # Python 3: open(..., 'rb')
# roidb_tg = pickle.load(f)
print("-- Optimization Stage --")
# Optimization
print("######################################################l")
roidb.extend(roidb_tg) # merge two datasets
print('before filtering, there are %d images...' % (len(roidb)))
i = 0
while i < len(roidb):
if True:
if len(roidb[i]['boxes']) == 0:
del roidb[i]
i -= 1
else:
if len(roidb[i]['boxes']) == 0:
del roidb[i]
i -= 1
i += 1
print('after filtering, there are %d images...' % (len(roidb)))
from roi_data_layer.roidb import rank_roidb_ratio
ratio_list, ratio_index = rank_roidb_ratio(roidb)
train_size = len(roidb)
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers,
worker_init_fn=_rand_fn())
iters_per_epoch = int(train_size / args.batch_size)
print("Training set size is {}".format(train_size))
for epoch in range(args.start_epoch, args.max_epochs + 1):
fasterRCNN.train()
loss_temp = 0
start = time.time()
epoch_start = start
# adjust learning rate
if epoch % (args.lr_decay_step + 1) == 0:
adjust_learning_rate(optimizer, args.lr_decay_gamma)
lr *= args.lr_decay_gamma
# one step
data_iter = iter(dataloader)
for step in range(iters_per_epoch):
data = next(data_iter)
im_data.data.resize_(data[0].size()).copy_(data[0])
im_info.data.resize_(data[1].size()).copy_(data[1])
gt_boxes.data.resize_(data[2].size()).copy_(data[2])
num_boxes.data.resize_(data[3].size()).copy_(data[3])
image_label.data.resize_(data[4].size()).copy_(data[4])
#gt_boxes.data = \
# torch.cat((gt_boxes.data, torch.zeros(gt_boxes.size(0), gt_boxes.size(1), 1).cuda()), dim=2)
conf_data = torch.zeros(gt_boxes.size(0), gt_boxes.size(1)).cuda()
confidence.data.resize_(conf_data.size()).copy_(conf_data)
fasterRCNN.zero_grad()
# rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes, confidence)
rois, cls_prob, bbox_pred, \
rpn_loss_cls, rpn_loss_box, \
RCNN_loss_cls, RCNN_loss_bbox, \
rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes)
# rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes, confidence)
loss = rpn_loss_cls.mean() + rpn_loss_box.mean() \
+ RCNN_loss_cls.mean() + RCNN_loss_bbox.mean()
loss_temp += loss.data[0]
# backward
optimizer.zero_grad()
loss.backward()
if args.net == "vgg16":
clip_gradient(fasterRCNN, 10.)
optimizer.step()
if step % args.disp_interval == 0:
end = time.time()
if step > 0:
loss_temp /= args.disp_interval
if args.mGPUs:
loss_rpn_cls = rpn_loss_cls.mean().data[0]
loss_rpn_box = rpn_loss_box.mean().data[0]
loss_rcnn_cls = RCNN_loss_cls.mean().data[0]
loss_rcnn_box = RCNN_loss_bbox.mean().data[0]
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
else:
loss_rpn_cls = rpn_loss_cls.data[0]
loss_rpn_box = rpn_loss_box.data[0]
loss_rcnn_cls = RCNN_loss_cls.data[0]
loss_rcnn_box = RCNN_loss_bbox.data[0]
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
print("[session %d][epoch %2d][iter %4d/%4d] loss: %.4f, lr: %.2e" \
% (args.session, epoch, step, iters_per_epoch, loss_temp, lr))
print("\t\t\tfg/bg=(%d/%d), time cost: %f" %
(fg_cnt, bg_cnt, end - start))
print("\t\t\trpn_cls: %.4f, rpn_box: %.4f, rcnn_cls: %.4f, rcnn_box %.4f" \
% (loss_rpn_cls, loss_rpn_box, loss_rcnn_cls, loss_rcnn_box))
if args.use_tfboard:
info = {
'loss': loss_temp,
'loss_rpn_cls': loss_rpn_cls,
'loss_rpn_box': loss_rpn_box,
'loss_rcnn_cls': loss_rcnn_cls,
'loss_rcnn_box': loss_rcnn_box
}
for tag, value in info.items():
logger.scalar_summary(tag, value, step)
images = []
for k in range(args.batch_size):
image = draw_bounding_boxes(
im_data[k].data.cpu().numpy(),
gt_boxes[k].data.cpu().numpy(),
im_info[k].data.cpu().numpy(),
num_boxes[k].data.cpu().numpy())
images.append(image)
logger.image_summary("Train epoch %2d, iter %4d/%4d" % (epoch, step, iters_per_epoch), \
images, step)
loss_temp = 0
start = time.time()
if False:
break
if args.mGPUs:
save_name = os.path.join(
output_dir,
'faster_rcnn_{}_{}_{}.pth'.format(args.session, epoch, step))
save_checkpoint(
{
'session': args.session,
'epoch': epoch + 1,
'model': fasterRCNN.module.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.POOLING_MODE,
'class_agnostic': args.class_agnostic,
}, save_name)
else:
save_name = os.path.join(
output_dir,
'faster_rcnn_{}_{}_{}.pth'.format(args.session, epoch, step))
save_checkpoint(
{
'session': args.session,
'epoch': epoch + 1,
'model': fasterRCNN.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.POOLING_MODE,
'class_agnostic': args.class_agnostic,
}, save_name)
print('save model: {}'.format(save_name))
epoch_end = time.time()
print('Epoch time cost: {}'.format(epoch_end - epoch_start))
print('finished!')
