def create(model_type_func, train=False, gpu_id=0):
"""Generic model creation function that dispatches to specific model
building functions.
By default, this function will generate a data parallel model configured to
run on cfg.NUM_GPUS devices. However, you can restrict it to build a model
targeted to a specific GPU by specifying gpu_id. This is used by
optimizer.build_data_parallel_model() during test time.
"""
model = DetectionModelHelper(name=model_type_func,
train=train,
num_classes=cfg.MODEL.NUM_CLASSES,
init_params=train)
model.only_build_forward_pass = False
model.target_gpu_id = gpu_id
model = get_func(model_type_func)(model)
if cfg.CASCADE_RCNN.SCALE_GRAD:
# replace the grad op's "scale" by "scale_grad"
# so the fprop and bprop scale can be different
for o in model.net.Proto().op:
if hasattr(o, "arg") and o.is_gradient_op:
value = None
for a in o.arg:
if a.name == "scale_grad":
value = a.f
if value is None:
continue
for a in o.arg:
if a.name == "scale":
a.f = value
return model
def create(model_type_func, train=False, gpu_id=0):
"""Generic model creation function that dispatches to specific model
building functions.
By default, this function will generate a data parallel model configured to
run on cfg.NUM_GPUS devices. However, you can restrict it to build a model
targeted to a specific GPU by specifying gpu_id. This is used by
optimizer.build_data_parallel_model() during test time.
"""
model = DetectionModelHelper(
name=model_type_func,
train=train,
num_classes=cfg.MODEL.NUM_CLASSES,
init_params=(train or cfg.VIS_NET)
)
model.only_build_forward_pass = False
model.target_gpu_id = gpu_id
model = get_func(model_type_func)(model)
# Stop gradient at specified nodes
if len(cfg.TRAIN.FREEZE_BLOBS):
blob_references = []
for gpu_id in range(cfg.NUM_GPUS):
with c2_utils.NamedCudaScope(gpu_id):
for blob_name in cfg.TRAIN.FREEZE_BLOBS:
try:
blob_references.append(model.net.GetBlobRef(core.ScopedName(blob_name)))
except KeyError, e:
logger.warn('Failed to freeze blob. {}'.format(e))
if not cfg.CONTINUE_ON_ERROR:
raise
for blob_ref in blob_references:
logger.info('Freezing blob. {}'.format(blob_ref))
model.StopGradient(blob_ref, blob_ref)
def _add_track_outputs(self, X, track_n_rois):
model = DetectionModelHelper(train=False, num_classes=1)
X = model.GivenTensorFill([], 'X', values=X, shape=X.shape)
add_track_outputs(model, X, cfg.TRCNN.MLP_HEAD_DIM)
workspace.FeedBlob('track_n_rois', track_n_rois)
workspace.FeedBlob('track_n_rois_one', np.array([track_n_rois[0]]))
workspace.FeedBlob('track_n_rois_two', np.array([track_n_rois[1]]))
workspace.RunNetOnce(model.net)
return workspace.FetchBlob('track_similarity')
def create(model_type_func, train=False, gpu_id=0):
"""Generic model creation function that dispatches to specific model
building functions.
By default, this function will generate a data parallel model configured to
run on cfg.NUM_GPUS devices. However, you can restrict it to build a model
targeted to a specific GPU by specifying gpu_id. This is used by
optimizer.build_data_parallel_model() during test time.
"""
model = DetectionModelHelper(name=model_type_func,
train=train,
num_classes=cfg.MODEL.NUM_CLASSES,
init_params=train)
model.only_build_forward_pass = False
model.target_gpu_id = gpu_id
return get_func(model_type_func)(model)
def _add_track_losses(self, X, X_gt):
model = DetectionModelHelper(train=False, num_classes=1)
add_track_losses(model)
workspace.FeedBlob('track_similarity', X)
workspace.FeedBlob('track_int32', X_gt)
workspace.RunNetOnce(model.net)
return workspace.FetchBlob('loss_track')
def create(model_type_func, train=False, gpu_id=0):
"""Generic model creation function that dispatches to specific model
building functions.
By default, this function will generate a data parallel model configured to
run on cfg.NUM_GPUS devices. However, you can restrict it to build a model
targeted to a specific GPU by specifying gpu_id. This is used by
optimizer.build_data_parallel_model() during test time.
"""
model = DetectionModelHelper(
name=model_type_func,
train=train,
num_classes=cfg.MODEL.NUM_CLASSES,
init_params=train
)
model.only_build_forward_pass = False
model.target_gpu_id = gpu_id
return get_func(model_type_func)(model)
def create_model(train, cfg, output_dir):
logger = logging.getLogger(__name__)
start_iter = 0
checkpoints = {}
weights_file = None
if cfg.TRAIN.AUTO_RESUME:
# Check for the final model (indicates training already finished)
final_path = os.path.join(output_dir, 'model_final.pkl')
if os.path.exists(final_path):
logger.info('model_final.pkl exists; no need to train!')
return None, None, None, {'final': final_path}, output_dir
# Find the most recent checkpoint (highest iteration number)
files = os.listdir(output_dir)
for f in files:
iter_string = re.findall(r'(?<=model_iter)\d+(?=\.pkl)', f)
if len(iter_string) > 0:
checkpoint_iter = int(iter_string[0])
if checkpoint_iter > start_iter:
# Start one iteration immediately after the checkpoint iter
start_iter = checkpoint_iter + 1
resume_weights_file = f
if start_iter > 0:
# Override the initialization weights with the found checkpoint
weights_file = os.path.join(output_dir, resume_weights_file)
logger.info(
'========> Resuming from checkpoint {} at start iter {}'.
format(weights_file, start_iter))
logger.info('Building model: {}'.format(cfg.MODEL.TYPE))
model = DetectionModelHelper(name="fusion",
train=train,
num_classes=cfg.MODEL.NUM_CLASSES,
init_params=train)
model.only_build_forward_pass = False
model.target_gpu_id = gpu_id
def _single_gpu_build_func(model):
loss = {"loss": None}
p = model.Conv("data_stage2",
'conv1_stage2',
40,
20,
kernel=3,
pad=1,
stride=1,
no_bias=1,
weight_init=(cfg.MRCNN.CONV_INIT, {
'std': 0.001
}))
p = model.AffineChannel(p, 'conv1_bn_stage2', dim=20, inplace=True)
p = model.Relu(p, p)
human_fc = model.Conv(p,
'conv2_stage2',
20,
20,
kernel=1,
pad=0,
stride=1,
weight_init=(cfg.MRCNN.CONV_INIT, {
'std': 0.001
}))
if not model.train:
model.net.NCHW2NHWC(human_fc, 'seg_score_NHWC_stage2')
model.net.Softmax('seg_score_NHWC_stage2',
'probs_human_NHWC_stage2',
axis=3)
model.net.NHWC2NCHW('probs_human_NHWC_stage2',
'probs_human_NCHW_stage2')
loss_gradient = None
if model.train:
model.net.NCHW2NHWC(human_fc, 'seg_score_NHWC_stage2')
model.Reshape(
'seg_score_NHWC_stage2',
['seg_score_reshape_stage2', 'seg_score_old_shape_stage2'],
shape=[-1, model.num_classes])
model.Reshape('gt_label_stage2',
['gt_label_reshape_stage2', 'gt_label_shape_stage2'],
shape=[
-1,
])
probs_human, loss_human = model.net.SoftmaxWithLoss(
['seg_score_reshape_stage2', 'gt_label_reshape_stage2'],
['probs_human_stage2', 'loss_human_stage2'],
scale=1. / cfg.NUM_GPUS)
loss_gradient = blob_utils.get_loss_gradients(model, [loss_human])
model.AddLosses('loss_human_stage2')
loss['loss'] = loss_gradient
if model.train:
loss_gradients = {}
for lg in loss.values():
if lg is not None:
loss_gradients.update(lg)
return loss_gradients
else:
return None
optim.build_data_parallel_model(model, _single_gpu_build_func)
# Performs random weight initialization as defined by the model
workspace.RunNetOnce(model.param_init_net)
return model, weights_file, start_iter, checkpoints
