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)