def do_reval(dataset_name, output_dir, args):
dataset = JsonDataset(dataset_name)
dets = load_object(os.path.join(output_dir, 'detections.pkl'))
# Override config with the one saved in the detections file
if args.cfg_file is not None:
core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg']))
else:
core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg)
# re-filter on score threshold:
dets['all_boxes'] = \
[
[
im[im[:,4] > cfg.TEST.SCORE_THRESH,:] if len(im) != 0 else []
for im in cls
]
for cls in dets['all_boxes']
]
results = task_evaluation.evaluate_all(dataset,
dets['all_boxes'],
dets['all_segms'],
dets['all_keyps'],
output_dir,
use_matlab=args.matlab_eval)
task_evaluation.log_copy_paste_friendly_results(results)
def test_immutability(self):
# Top level immutable
a = AttrDict()
a.foo = 0
a.immutable(True)
with self.assertRaises(AttributeError):
a.foo = 1
a.bar = 1
assert a.is_immutable()
assert a.foo == 0
a.immutable(False)
assert not a.is_immutable()
a.foo = 1
assert a.foo == 1
# Recursively immutable
a.level1 = AttrDict()
a.level1.foo = 0
a.level1.level2 = AttrDict()
a.level1.level2.foo = 0
a.immutable(True)
assert a.is_immutable()
with self.assertRaises(AttributeError):
a.level1.level2.foo = 1
a.level1.bar = 1
assert a.level1.level2.foo == 0
# Serialize immutability state
a.immutable(True)
a2 = core_config.load_cfg(yaml.dump(a))
assert a.is_immutable()
assert a2.is_immutable()
def test_immutability(self):
# Top level immutable
a = AttrDict()
a.foo = 0
a.immutable(True)
with self.assertRaises(AttributeError):
a.foo = 1
a.bar = 1
assert a.is_immutable()
assert a.foo == 0
a.immutable(False)
assert not a.is_immutable()
a.foo = 1
assert a.foo == 1
# Recursively immutable
a.level1 = AttrDict()
a.level1.foo = 0
a.level1.level2 = AttrDict()
a.level1.level2.foo = 0
a.immutable(True)
assert a.is_immutable()
with self.assertRaises(AttributeError):
a.level1.level2.foo = 1
a.level1.bar = 1
assert a.level1.level2.foo == 0
# Serialize immutability state
a.immutable(True)
a2 = core_config.load_cfg(envu.yaml_dump(a))
assert a.is_immutable()
assert a2.is_immutable()
def do_reval(dataset_name, output_dir, args):
dataset = JsonDataset(dataset_name)
dets = load_object(os.path.join(output_dir, 'detections.pkl'))
# Override config with the one saved in the detections file
if args.cfg_file is not None:
core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg']))
else:
core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg)
results = task_evaluation.evaluate_all(dataset,
dets['all_boxes'],
dets['all_segms'],
dets['all_keyps'],
output_dir,
use_matlab=args.matlab_eval)
task_evaluation.log_copy_paste_friendly_results(results)
def main(args):
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = load_cfg(envu.yaml_dump(cfg))
im = cv2.imread(args.im_file)
if args.rpn_pkl is not None:
proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args)
workspace.ResetWorkspace()
else:
proposal_boxes = None
cls_boxes, cls_segms, cls_keyps, cls_bodys = None, None, None, None
for i in range(0, len(args.models_to_run), 2):
pkl = args.models_to_run[i]
yml = args.models_to_run[i + 1]
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
weights_file = pkl
else:
weights_file = cfg.TEST.WEIGHTS
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ , cls_bodys_= \
model_engine.im_detect_all(model, im, proposal_boxes)
cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes
cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms
cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps
cls_bodys = cls_bodys_ if cls_bodys_ is not None else cls_bodys
workspace.ResetWorkspace()
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf'))
logger.info('Processing {} -> {}'.format(args.im_file, out_name))
with open('test_vis.pkl', 'w') as f:
pickle.dump(
{
'im': im,
'cls_boxes': np.array(cls_boxes),
'cls_bodys': np.array(cls_bodys)
}, f)
vis_utils.vis_one_image(im[:, :, ::-1],
args.im_file,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
def main(args):
logger = logging.getLogger(__name__)
dummy_nucoco_dataset = dummy_datasets.get_nucoco_dataset()
cfg_orig = load_cfg(envu.yaml_dump(cfg))
## Load image
coco = COCO_PLUS(args.ann_file, args.imgs_dir)
image_id = coco.dataset['images'][args.im_ind]['id']
img_path = os.path.join(args.imgs_dir, coco.imgs[image_id]["file_name"])
im = cv2.imread(img_path)
## Get the proposals for this image
proposals = rrpn_loader(args.rpn_pkl)
proposal_boxes = proposals[image_id]['boxes']
_proposal_scores = proposals[image_id]['scores']
workspace.ResetWorkspace()
## run models
cls_boxes, cls_segms, cls_keyps = None, None, None
for i in range(0, len(args.models_to_run), 2):
pkl = args.models_to_run[i]
yml = args.models_to_run[i + 1]
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
weights_file = pkl
else:
weights_file = cfg.TEST.WEIGHTS
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ = \
model_engine.im_detect_all(model, im, proposal_boxes)
cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes
cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms
cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps
workspace.ResetWorkspace()
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(img_path) + '.pdf')
)
logger.info('Processing {} -> {}'.format(img_path, out_name))
vis_utils.vis_one_image(
im[:, :, ::-1],
img_path,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_nucoco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
def do_reval(dataset_name, output_dir, args):
dataset = JsonDataset(dataset_name)
dets = load_object(os.path.join(output_dir, 'detections.pkl'))
# Override config with the one saved in the detections file
if args.cfg_file is not None:
core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg']))
else:
core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg)
results = task_evaluation.evaluate_all(
dataset,
dets['all_boxes'],
dets['all_segms'],
dets['all_keyps'],
output_dir,
use_matlab=args.matlab_eval
)
task_evaluation.log_copy_paste_friendly_results(results)
def get_detectron_result(im):
"""
功能: 获取传入图像的检测结果
输入参数列表:
im: BGR格式图片
返回参数列表:
img: 检测结果图片
detectron_result_info: 检测结果字典
"""
setup_logging(__name__)
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = load_cfg(yaml.dump(cfg))
if rpn_pkl is not None:
proposal_boxes, _proposal_scores = get_rpn_box_proposals(im)
workspace.ResetWorkspace()
else:
proposal_boxes = None
cls_boxes, cls_segms, cls_keyps = None, None, None
pkl = rpn_pkl
yml = rpn_cfg
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
weights_file = pkl
else:
weights_file = cfg.TEST.WEIGHTS
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ = \
model_engine.im_detect_all(model, im, proposal_boxes)
cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes
cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms
cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps
workspace.ResetWorkspace()
img, detectron_result_info = vis_utils.vis_one_image_opencv(
im,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
show_box=True,
show_class=True)
return img, detectron_result_info
def main(args):
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = load_cfg(yaml.dump(cfg))
im = cv2.imread(args.im_file)
if args.rpn_pkl is not None:
proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args)
workspace.ResetWorkspace()
else:
proposal_boxes = None
cls_boxes, cls_segms, cls_keyps = None, None, None
for i in range(0, len(args.models_to_run), 2):
pkl = args.models_to_run[i]
yml = args.models_to_run[i + 1]
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
weights_file = pkl
else:
weights_file = cfg.TEST.WEIGHTS
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ = \
model_engine.im_detect_all(model, im, proposal_boxes)
cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes
cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms
cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps
workspace.ResetWorkspace()
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf')
)
logger.info('Processing {} -> {}'.format(args.im_file, out_name))
vis_utils.vis_one_image(
im[:, :, ::-1],
args.im_file,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
def test_merge_cfg_from_cfg(self):
# Test: merge from deepcopy
s = 'dummy0'
cfg2 = copy.deepcopy(cfg)
cfg2.MODEL.TYPE = s
core_config.merge_cfg_from_cfg(cfg2)
assert cfg.MODEL.TYPE == s
# Test: merge from yaml
s = 'dummy1'
cfg2 = core_config.load_cfg(envu.yaml_dump(cfg))
cfg2.MODEL.TYPE = s
core_config.merge_cfg_from_cfg(cfg2)
assert cfg.MODEL.TYPE == s
# Test: merge with a valid key
s = 'dummy2'
cfg2 = AttrDict()
cfg2.MODEL = AttrDict()
cfg2.MODEL.TYPE = s
core_config.merge_cfg_from_cfg(cfg2)
assert cfg.MODEL.TYPE == s
# Test: merge with an invalid key
s = 'dummy3'
cfg2 = AttrDict()
cfg2.FOO = AttrDict()
cfg2.FOO.BAR = s
with self.assertRaises(KeyError):
core_config.merge_cfg_from_cfg(cfg2)
# Test: merge with converted type
cfg2 = AttrDict()
cfg2.TRAIN = AttrDict()
cfg2.TRAIN.SCALES = [1]
core_config.merge_cfg_from_cfg(cfg2)
assert type(cfg.TRAIN.SCALES) is tuple
assert cfg.TRAIN.SCALES[0] == 1
# Test: merge with invalid type
cfg2 = AttrDict()
cfg2.TRAIN = AttrDict()
cfg2.TRAIN.SCALES = 1
with self.assertRaises(ValueError):
core_config.merge_cfg_from_cfg(cfg2)
def test_merge_cfg_from_cfg(self):
# Test: merge from deepcopy
s = 'dummy0'
cfg2 = copy.deepcopy(cfg)
cfg2.MODEL.TYPE = s
core_config.merge_cfg_from_cfg(cfg2)
assert cfg.MODEL.TYPE == s
# Test: merge from yaml
s = 'dummy1'
cfg2 = core_config.load_cfg(yaml.dump(cfg))
cfg2.MODEL.TYPE = s
core_config.merge_cfg_from_cfg(cfg2)
assert cfg.MODEL.TYPE == s
# Test: merge with a valid key
s = 'dummy2'
cfg2 = AttrDict()
cfg2.MODEL = AttrDict()
cfg2.MODEL.TYPE = s
core_config.merge_cfg_from_cfg(cfg2)
assert cfg.MODEL.TYPE == s
# Test: merge with an invalid key
s = 'dummy3'
cfg2 = AttrDict()
cfg2.FOO = AttrDict()
cfg2.FOO.BAR = s
with self.assertRaises(KeyError):
core_config.merge_cfg_from_cfg(cfg2)
# Test: merge with converted type
cfg2 = AttrDict()
cfg2.TRAIN = AttrDict()
cfg2.TRAIN.SCALES = [1]
core_config.merge_cfg_from_cfg(cfg2)
assert type(cfg.TRAIN.SCALES) is tuple
assert cfg.TRAIN.SCALES[0] == 1
# Test: merge with invalid type
cfg2 = AttrDict()
cfg2.TRAIN = AttrDict()
cfg2.TRAIN.SCALES = 1
with self.assertRaises(ValueError):
core_config.merge_cfg_from_cfg(cfg2)
def do_reval(dataset_name, output_dir, args):
dataset = JsonDataset(dataset_name)
with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f:
dets = pickle.load(f)
# Override config with the one saved in the detections file
if args.cfg_file is not None:
# bug: loads only already stored cfg
# core_config.merge_cfg_from_cfg(core_config.load_cfg(dets['cfg']))
# merge config from passed config file!!
core_config.merge_cfg_from_file(args.cfg_file)
else:
core_config._merge_a_into_b(core_config.load_cfg(dets['cfg']), cfg)
results = task_evaluation.evaluate_all(dataset,
dets['all_boxes'],
dets['all_segms'],
dets['all_keyps'],
output_dir,
use_matlab=args.matlab_eval)
task_evaluation.log_copy_paste_friendly_results(results)
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
"""Initialize a network with ops on a specific GPU.
If you use CUDA_VISIBLE_DEVICES to target specific GPUs, Caffe2 will
automatically map logical GPU ids (starting from 0) to the physical GPUs
specified in CUDA_VISIBLE_DEVICES.
"""
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
with open(weights_file, 'r') as f:
src_blobs = pickle.load(f)
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
# Backwards compat--dictionary used to be only blobs, now they are
# stored under the 'blobs' key
src_blobs = src_blobs['blobs']
# Initialize weights on GPU gpu_id only
unscoped_param_names = OrderedDict() # Print these out in model order
for blob in model.params:
unscoped_param_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gpu_id):
for unscoped_param_name in unscoped_param_names.keys():
if (unscoped_param_name.find(']_') >= 0
and unscoped_param_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_param_name[unscoped_param_name.find(']_') +
2:]
else:
src_name = unscoped_param_name
if src_name not in src_blobs:
logger.info('{:s} not found'.format(src_name))
continue
dst_name = core.ScopedName(unscoped_param_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum_str = ' [+ momentum]' if has_momentum else ''
logger.debug(
'{:s}{:} loaded from weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name,
src_blobs[src_name].shape))
if dst_name in ws_blobs:
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
GPU_NAME = 'gpu_0'
ws_blob = workspace.FetchBlob(dst_name)
if (dst_name!=GPU_NAME+'/cls_score_w') and (dst_name!=GPU_NAME+'/cls_score_b') \
and (dst_name!=GPU_NAME+'/bbox_pred_w') and (dst_name!=GPU_NAME+'/bbox_pred_b') \
and (dst_name!=GPU_NAME+'/mask_fcn_logits_w') and (dst_name!=GPU_NAME+'/mask_fcn_logits_b') : #add by shan
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
#print(dst_name, ws_blob.shape, src_name, src_blobs[src_name].shape)
assert ws_blob.shape == src_blobs[src_name].shape, \
('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
else:
if dst_name == GPU_NAME + '/cls_score_w':
temp = 0.0001 * np.random.randn(*(ws_blob.shape))
temp[0:4, :] = src_blobs[src_name][0:4, :]
temp[5, :] = src_blobs[src_name][6, :]
temp[6, :] = src_blobs[src_name][8, :]
src_blobs[src_name] = temp
if (dst_name == GPU_NAME + '/cls_score_b'):
temp = -np.log((1 - 0.00001) / 0.00001) * np.ones(
*(ws_blob.shape))
temp[0:4] = src_blobs[src_name][0:4]
temp[5] = src_blobs[src_name][6]
temp[6] = src_blobs[src_name][8]
src_blobs[src_name] = temp
if (dst_name == GPU_NAME + '/bbox_pred_w'):
temp = 0.0001 * np.random.randn(*(ws_blob.shape))
temp[0:16, :] = src_blobs[src_name][0:16, :]
temp[16:20, :] = src_blobs[src_name][24:28, :]
temp[20:24, :] = src_blobs[src_name][32:36, :]
src_blobs[src_name] = temp
if (dst_name == GPU_NAME + '/bbox_pred_b'):
temp = -np.log((1 - 0.00001) / 0.00001) * np.ones(
*(ws_blob.shape))
temp[0:16] = src_blobs[src_name][0:16]
temp[16:20] = src_blobs[src_name][24:28]
temp[20:24] = src_blobs[src_name][32:36]
src_blobs[src_name] = temp
if dst_name == GPU_NAME + '/mask_fcn_logits_w':
print(src_blobs[src_name].shape)
temp = 0.0001 * np.random.randn(*(ws_blob.shape))
temp[0:4, :, :, :] = src_blobs[src_name][0:4, :, :, :]
temp[5, :, :, :] = src_blobs[src_name][6, :, :, :]
temp[6, :, :, :] = src_blobs[src_name][8, :, :, :]
src_blobs[src_name] = temp
#src_blobs[src_name + '_momentum'] = np.zeros(ws_blob.shape) #ws_blob.shape
if dst_name == GPU_NAME + '/mask_fcn_logits_b':
#print("--", src_blobs[src_name].shape)
temp = -np.log((1 - 0.00001) / 0.00001) * np.ones(
*(ws_blob.shape))
temp[0:4] = src_blobs[src_name][0:4]
temp[5] = src_blobs[src_name][6]
temp[6] = src_blobs[src_name][8]
src_blobs[src_name] = temp
src_blobs[src_name + '_momentum'] = np.zeros(ws_blob.shape)
workspace.FeedBlob(
dst_name, src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(np.float32,
copy=False))
# We preserve blobs that are in the weights file but not used by the current
# model. We load these into CPU memory under the '__preserve__/' namescope.
# These blobs will be stored when saving a model to a weights file. This
# feature allows for alternating optimization of Faster R-CNN in which blobs
# unused by one step can still be preserved forward and used to initialize
# another step.
for src_name in src_blobs.keys():
if (src_name not in unscoped_param_names
and not src_name.endswith('_momentum')
and src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob('__preserve__/{:s}'.format(src_name),
src_blobs[src_name])
logger.debug(
'{:s} preserved in workspace (unused)'.format(src_name))
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
"""Initialize a network with ops on a specific GPU.
If you use CUDA_VISIBLE_DEVICES to target specific GPUs, Caffe2 will
automatically map logical GPU ids (starting from 0) to the physical GPUs
specified in CUDA_VISIBLE_DEVICES.
"""
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
with open(weights_file, 'r') as f:
src_blobs = pickle.load(f)
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
# Backwards compat--dictionary used to be only blobs, now they are
# stored under the 'blobs' key
src_blobs = src_blobs['blobs']
# Initialize weights on GPU gpu_id only
unscoped_param_names = OrderedDict() # Print these out in model order
for blob in model.params:
unscoped_param_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gpu_id):
for unscoped_param_name in unscoped_param_names.keys():
if (unscoped_param_name.find(']_') >= 0 and
unscoped_param_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_param_name[
unscoped_param_name.find(']_') + 2:]
else:
src_name = unscoped_param_name
if src_name not in src_blobs:
logger.info('{:s} not found'.format(src_name))
continue
dst_name = core.ScopedName(unscoped_param_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum_str = ' [+ momentum]' if has_momentum else ''
logger.debug(
'{:s}{:} loaded from weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name, src_blobs[src_name]
.shape
)
)
if dst_name in ws_blobs:
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
ws_blob = workspace.FetchBlob(dst_name)
assert ws_blob.shape == src_blobs[src_name].shape, \
('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
workspace.FeedBlob(
dst_name,
src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(
np.float32, copy=False))
# We preserve blobs that are in the weights file but not used by the current
# model. We load these into CPU memory under the '__preserve__/' namescope.
# These blobs will be stored when saving a model to a weights file. This
# feature allows for alternating optimization of Faster R-CNN in which blobs
# unused by one step can still be preserved forward and used to initialize
# another step.
for src_name in src_blobs.keys():
if (src_name not in unscoped_param_names and
not src_name.endswith('_momentum') and
src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob(
'__preserve__/{:s}'.format(src_name), src_blobs[src_name])
logger.debug(
'{:s} preserved in workspace (unused)'.format(src_name))
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
"""Initialize a network with ops on a specific GPU.
If you use CUDA_VISIBLE_DEVICES to target specific GPUs, Caffe2 will
automatically map logical GPU ids (starting from 0) to the physical GPUs
specified in CUDA_VISIBLE_DEVICES.
"""
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
src_blobs = load_object(weights_file)
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
# Backwards compat--dictionary used to be only blobs, now they are
# stored under the 'blobs' key
src_blobs = src_blobs['blobs']
# Initialize weights on GPU gpu_id only
unscoped_param_names = OrderedDict() # Print these out in model order
for blob in model.params:
unscoped_param_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gpu_id):
for unscoped_param_name in unscoped_param_names.keys():
if (unscoped_param_name.find(']_') >= 0
and unscoped_param_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_param_name[unscoped_param_name.find(']_') +
2:]
else:
src_name = unscoped_param_name
if src_name not in src_blobs:
logger.info('{:s} not found'.format(src_name))
continue
dst_name = core.ScopedName(unscoped_param_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum = False
has_momentum_str = ' [+ momentum]' if has_momentum else ''
logger.info(
'{:s}{:} loaded from weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name,
src_blobs[src_name].shape))
if dst_name in ws_blobs:
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
ws_blob = workspace.FetchBlob(dst_name)
assert ws_blob.shape == src_blobs[src_name].shape, \
('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
workspace.FeedBlob(
dst_name, src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(np.float32,
copy=False))
# let roidb continue with the data that is not seen yet.
if 'roidb_state' in src_blobs and model.roi_data_loader is not None:
model.roi_data_loader.set_perm_state(src_blobs['roidb_state'])
del src_blobs['roidb_state']
else:
logger.info("roidb state not loaded")
if 'roidb_state' in src_blobs and model.roi_data_loader is None:
del src_blobs['roidb_state']
if cfg.TRAIN.PADA:
if 'weight_db' in src_blobs:
import detectron.modeling.PADA as pada
model.class_weight_db = pada.ClassWeightDB(*src_blobs['weight_db'])
del src_blobs['weight_db']
elif 'weight_db' in src_blobs:
del src_blobs['weight_db']
# We preserve blobs that are in the weights file but not used by the current
# model. We load these into CPU memory under the '__preserve__/' namescope.
# These blobs will be stored when saving a model to a weights file. This
# feature allows for alternating optimization of Faster R-CNN in which blobs
# unused by one step can still be preserved forward and used to initialize
# another step.
for src_name in src_blobs.keys():
if (src_name not in unscoped_param_names
and not src_name.endswith('_momentum')
and src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob('__preserve__/{:s}'.format(src_name),
src_blobs[src_name])
logger.info(
'{:s} preserved in workspace (unused)'.format(src_name))
from detectron.core.config import merge_cfg_from_file
from detectron.utils.logging import setup_logging
import detectron.core.test_engine as model_engine
import detectron.utils.c2 as c2_utils
c2_utils.import_detectron_ops()
# OpenCL may be enabled by default in OpenCV3; disable it because it's not
# thread safe and causes unwanted GPU memory allocations.
cv2.ocl.setUseOpenCL(False)
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
setup_logging(__name__)
logger = logging.getLogger(__name__)
cfg_orig = load_cfg(yaml.dump(cfg))
#Download model of choice from https://github.com/facebookresearch/Detectron/blob/master/MODEL_ZOO.md"
#Yaml files available at https://github.com/facebookresearch/Detectron/tree/master/configs
models_dir = os.path.join(os.path.dirname(__file__), 'model_files')
pkl = models_dir + "/kps_R-50-FPN.pkl"
yml = models_dir + "/kps_R-50-FPN.yaml"
if not os.path.isfile(pkl):
exit("MODEL FILES NOT FOUND (check kpdetection.py)")
#Config Setup
cfg.immutable(False)
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
weights_file = pkl
cfg.NUM_GPUS = 1
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
"""Initialize a network with ops on a specific GPU.
If you use CUDA_VISIBLE_DEVICES to target specific GPUs, Caffe2 will
automatically map logical GPU ids (starting from 0) to the physical GPUs
specified in CUDA_VISIBLE_DEVICES.
"""
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
with open(weights_file, 'rb') as f:
try:
src_blobs = pickle.load(
f, encoding='latin1'
) # the pickles from the Model Zoo (as of January 2018) seem to be encoded with latin1; see also https://github.com/tflearn/tflearn/issues/57
except TypeError:
src_blobs = pickle.load(
f) # Python 2 has no "encoding" argument for pickle
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
# Backwards compat--dictionary used to be only blobs, now they are
# stored under the 'blobs' key
src_blobs = src_blobs['blobs']
# Initialize weights on GPU gpu_id only
unscoped_param_names = OrderedDict() # Print these out in model order
for blob in model.params:
unscoped_param_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gpu_id):
for unscoped_param_name in list(unscoped_param_names.keys()):
if (unscoped_param_name.find(']_') >= 0
and unscoped_param_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_param_name[unscoped_param_name.find(']_') +
2:]
else:
src_name = unscoped_param_name
if src_name not in src_blobs:
logger.info('{:s} not found'.format(src_name))
continue
dst_name = core.ScopedName(unscoped_param_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum_str = ' [+ momentum]' if has_momentum else ''
logger.debug(
'{:s}{:} loaded from weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name,
src_blobs[src_name].shape))
if dst_name in ws_blobs:
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
ws_blob = workspace.FetchBlob(dst_name)
assert ws_blob.shape == src_blobs[src_name].shape, \
('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
workspace.FeedBlob(
dst_name, src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(np.float32,
copy=False))
# We preserve blobs that are in the weights file but not used by the current
# model. We load these into CPU memory under the '__preserve__/' namescope.
# These blobs will be stored when saving a model to a weights file. This
# feature allows for alternating optimization of Faster R-CNN in which blobs
# unused by one step can still be preserved forward and used to initialize
# another step.
for src_name in list(src_blobs.keys()):
if (src_name not in unscoped_param_names
and not src_name.endswith('_momentum')
and src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob('__preserve__/{:s}'.format(src_name),
src_blobs[src_name])
logger.debug(
'{:s} preserved in workspace (unused)'.format(src_name))
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
"""Initialize a network with ops on a specific GPU.
If you use CUDA_VISIBLE_DEVICES to target specific GPUs, Caffe2 will
automatically map logical GPU ids (starting from 0) to the physical GPUs
specified in CUDA_VISIBLE_DEVICES.
"""
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
with open(weights_file, 'r') as f:
src_blobs = pickle.load(f)
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
# Backwards compat--dictionary used to be only blobs, now they are
# stored under the 'blobs' key
src_blobs = src_blobs['blobs']
# Initialize weights on GPU gpu_id only
unscoped_param_names = OrderedDict() # Print these out in model order
for blob in model.params:
unscoped_param_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gpu_id):
for unscoped_param_name in unscoped_param_names.keys():
if (unscoped_param_name.find(']_') >= 0
and unscoped_param_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_param_name[unscoped_param_name.find(']_') +
2:]
else:
src_name = unscoped_param_name
if src_name not in src_blobs:
logger.info('{:s} not found'.format(src_name))
continue
dst_name = core.ScopedName(unscoped_param_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum_str = ' [+ momentum]' if has_momentum else ''
logger.debug(
'{:s}{:} loaded from weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name,
src_blobs[src_name].shape))
if dst_name in ws_blobs:
print("dst_name:" + dst_name)
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
ws_blob = workspace.FetchBlob(dst_name)
print("xhpan:ws_blob.shape:" + str(ws_blob.shape))
print("xhpan:src_blobs[src_name].shape:" +
str(src_blobs[src_name].shape))
classes_layers_list_w = [
'gpu_0/cls_score_w', 'gpu_0/bbox_pred_w',
'gpu_0/mask_fcn_logits_w'
]
classes_layers_list_b = [
'gpu_0/cls_score_b', 'gpu_0/bbox_pred_b',
'gpu_0/mask_fcn_logits_b'
]
# -----------------(11, 1024) - --------------(10, 1024)
# -----------------(11,) - --------------(10,)
# -----------------(44, 1024) - --------------(40, 1024)
# -----------------(44,) - --------------(40,)
# -----------------(11, 256, 1, 1) - --------------(10, 256, 1, 1)
# -----------------(11,) - --------------(10,)
# if ws_blob.shape != src_blobs[src_name].shape:
# if dst_name is 'gpu_0/cls_score_w':
# if ws_blob.shape[0] > src_blobs[src_name].shape[0]:#(10, 1024)
# src_blobs[src_name].extend(0.0001 * np.random.randn(*(ws_blob.shape[0] - src_blobs[src_name].shape[0], ws_blob.shape[1])))
# else:
# num = src_blobs[src_name].shape[0] - ws_blob.shape[0]
# src_blobs[src_name] = src_blobs[src_name][-num]
# elif dst_name is
cfg.MODEL.NUM_CLASSES
if ws_blob.shape != src_blobs[src_name].shape:
print("ws_blob.shape != src_blobs[src_name].shape")
print("-----------------" + str(ws_blob.shape) +
"---------------" + str(src_blobs[src_name].shape))
if dst_name in classes_layers_list_w or dst_name in classes_layers_list_b:
if dst_name in classes_layers_list_w:
target_shape = [
ws_blob.shape[0] - src_blobs[src_name].shape[0]
]
target_shape.extend(list(ws_blob.shape[1:]))
init_weight = 0.0001 * np.random.randn(
*(tuple(target_shape)))
src_blobs[src_name] = np.append(
src_blobs[src_name], init_weight, axis=0)
else:
target_shape = [
ws_blob.shape[0] - src_blobs[src_name].shape[0]
]
target_shape.extend(list(ws_blob.shape[1:]))
init_weight = -np.log(
(1 - 0.00001) / 0.00001) * np.ones(
*(tuple(target_shape)))
src_blobs[src_name] = np.append(
src_blobs[src_name], init_weight, axis=0)
target_shape = [
ws_blob.shape[0] -
src_blobs[src_name + '_momentum'].shape[0]
]
target_shape.extend(list(ws_blob.shape[1:]))
init_weight = np.zeros(target_shape)
src_blobs[src_name + '_momentum'] = np.append(
src_blobs[src_name + '_momentum'],
init_weight,
axis=0)
# if ws_blob.shape != src_blobs[src_name].shape:
# print ("ws_blob.shape != src_blobs[src_name].shape")
# print ("-----------------" + str(ws_blob.shape) + "---------------" + str(src_blobs[src_name].shape))
# if dst_name in classes_layers_list_w or dst_name in classes_layers_list_b:
# if dst_name in classes_layers_list_w :
# src_blobs[src_name] = 0.0001 * np.random.randn(*(ws_blob.shape))
# else:
# src_blobs[src_name] = -np.log((1 - 0.00001) / 0.00001) * np.ones(*(ws_blob.shape))
#
# src_blobs[src_name + '_momentum'] = np.zeros(ws_blob.shape)
assert ws_blob.shape == src_blobs[src_name].shape, \
('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
workspace.FeedBlob(
dst_name, src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(np.float32,
copy=False))
# We preserve blobs that are in the weights file but not used by the current
# model. We load these into CPU memory under the '__preserve__/' namescope.
# These blobs will be stored when saving a model to a weights file. This
# feature allows for alternating optimization of Faster R-CNN in which blobs
# unused by one step can still be preserved forward and used to initialize
# another step.
for src_name in src_blobs.keys():
if (src_name not in unscoped_param_names
and not src_name.endswith('_momentum')
and src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob('__preserve__/{:s}'.format(src_name),
src_blobs[src_name])
logger.debug(
'{:s} preserved in workspace (unused)'.format(src_name))
def initialize_gpu_from_weights_file(model, weights_file, gup_id=0):
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
src_blobs = load_object(weights_file)
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
src_blobs = src_blobs['blobs']
unscoped_para_names = OrderedDict()
for blob in model.params:
unscoped_para_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gup_id):
for unscoped_para_name in unscoped_para_names.keys():
if (unscoped_para_name.find(']_') >= 0
and unscoped_para_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_para_name[unscoped_para_name.find((']_') +
2)]
else:
src_name = unscoped_para_name
if src_name not in src_blobs:
logger.info('{:s} not found.'.format(src_name))
continue
dst_name = core.ScopedName(unscoped_para_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum_str = ' [+ momentum] ' if has_momentum else ''
logger.info(
'{:s}{:} loaded form weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name,
src_blobs[src_name].shape))
if dst_name in ws_blobs:
# if the blob is already in the workspace, make sure that it matches
# the shape of the loaded blob
ws_blob = workspace.FetchBlob(dst_name)
assert ws_blob.shape == src_blobs[src_name].shape, \
('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
workspace.FeedBlob(
dst_name, src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(np.float32,
copy=False))
for src_name in src_blobs.keys():
if (src_name not in unscoped_para_names
and not src_name.endswith('_momentum')
and src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob('__presever__/{:s}'.format(src_name),
src_blobs[src_name])
logger.info(
'{:s} preserved in workspace (unused)'.format(src_name))
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0, preffix=''):
"""Initialize a network with ops on a specific GPU.
If you use CUDA_VISIBLE_DEVICES to target specific GPUs, Caffe2 will
automatically map logical GPU ids (starting from 0) to the physical GPUs
specified in CUDA_VISIBLE_DEVICES.
"""
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
src_blobs = load_object(weights_file)
if 'cfg' in src_blobs:
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(model, saved_cfg)
if 'blobs' in src_blobs:
# Backwards compat--dictionary used to be only blobs, now they are
# stored under the 'blobs' key
src_blobs = src_blobs['blobs']
if preffix:
for key in src_blobs.keys():
src_blobs[preffix + "_" + key] = src_blobs.pop(key)
# Initialize weights on GPU gpu_id only
unscoped_param_names = OrderedDict() # Print these out in model order
for blob in model.params:
unscoped_param_names[c2_utils.UnscopeName(str(blob))] = True
with c2_utils.NamedCudaScope(gpu_id):
for unscoped_param_name in unscoped_param_names.keys():
if (unscoped_param_name.find(']_') >= 0 and
unscoped_param_name not in src_blobs):
# Special case for sharing initialization from a pretrained
# model:
# If a blob named '_[xyz]_foo' is in model.params and not in
# the initialization blob dictionary, then load source blob
# 'foo' into destination blob '_[xyz]_foo'
src_name = unscoped_param_name[
unscoped_param_name.find(']_') + 2:]
else:
src_name = unscoped_param_name
if src_name not in src_blobs:
msg = '{:s} not found)'.format(src_name)
if len(preffix):
msg += '(prefix: {})'.format(preffix)
logger.info(msg)
continue
dst_name = core.ScopedName(unscoped_param_name)
has_momentum = src_name + '_momentum' in src_blobs
has_momentum_str = ' [+ momentum]' if has_momentum else ''
if dst_name in ws_blobs:
if cfg.SKIP_EXISTING_WEIGHTS:
msg = 'Workspace blob {} already in workspace, skipping.'.format(
src_name)
logger.warning(msg)
continue
# If the blob is already in the workspace, make sure that it
# matches the shape of the loaded blob
ws_blob = workspace.FetchBlob(dst_name)
shapes_match = ws_blob.shape == src_blobs[src_name].shape
if not shapes_match:
msg = ('Workspace blob {} with shape {} does not match '
'weights file shape {}').format(
src_name,
ws_blob.shape,
src_blobs[src_name].shape)
assert ws_blob.shape == src_blobs[src_name].shape, \
msg
logger.info(
'{:s}{:} loaded from weights file into {:s}: {}'.format(
src_name, has_momentum_str, dst_name, src_blobs[src_name]
.shape
)
)
workspace.FeedBlob(
dst_name,
src_blobs[src_name].astype(np.float32, copy=False))
if has_momentum:
workspace.FeedBlob(
dst_name + '_momentum',
src_blobs[src_name + '_momentum'].astype(
np.float32, copy=False))
# We preserve blobs that are in the weights file but not used by the current
# model. We load these into CPU memory under the '__preserve__/' namescope.
# These blobs will be stored when saving a model to a weights file. This
# feature allows for alternating optimization of Faster R-CNN in which blobs
# unused by one step can still be preserved forward and used to initialize
# another step.
for src_name in src_blobs.keys():
if (src_name not in unscoped_param_names and
not src_name.endswith('_momentum') and
src_blobs[src_name] is not None):
with c2_utils.CpuScope():
workspace.FeedBlob(
'__preserve__/{:s}'.format(src_name), src_blobs[src_name])
msg = '{:s} preserved in workspace (unused)'.format(src_name)
if len(preffix):
msg += '(prefix: {})'.format(preffix)
logger.info(msg)
