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()
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))
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):
"""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, 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, 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)
