def conv_explicit_param_names(
model, blob_in, blob_out, weight_init=None, bias_init=None, **kwargs
):
"""
Sets up operators for a convolution layer between `blob_in` and `blob_out`.
Requires that explicit weight and bias parameters. Assumes NCHW order.
:param model: The ModelHelper object whose net the operators should be added to
:blob_in: The input blob for the convolution layer
:blob_out: The output blob from the convolution layer
:weight_init: Tuple specifying weight initialization information. Its first
entry is the name of the caffe2 operator to use in creating the weight param
and second is a dictionary of kwargs it should be passed.
:bias_init: Tuple specifying bias initialization information. Its first
entry is the name of the caffe2 operator to use in creating the bias param
and second is a dictionary of kwargs it should be passed.
:dim_in: Number of input channels
:dim_out: Number of output channels
:kernel_h: Image height kernel size
:kernel_w: Image width kernel size
:weight_name: Name of blob corresponding to an initialized weight parameter
:bias_name: Name of blob corresponding to an initialized bias parameter
"""
required_kwargs = [
'dim_in', 'dim_out', 'weight_name', 'bias_name', 'kernel_h', 'kernel_w'
]
for arg in required_kwargs:
assert arg in kwargs, "Please supply kwarg {}".format(arg)
dim_in, dim_out, kernel_h, kernel_w = kwargs['dim_in'], kwargs['dim_out'], \
kwargs['kernel_h'], kwargs['kernel_w']
WeightInitializer = initializers.update_initializer(
None, weight_init, ("XavierFill", {})
)
BiasInitializer = initializers.update_initializer(
None, bias_init, ("ConstantFill", {})
)
weight_shape = [dim_out, dim_in, kernel_h, kernel_w]
weight = model.create_param(
param_name=kwargs['weight_name'],
shape=weight_shape,
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT
)
bias = model.create_param(
param_name=kwargs['bias_name'],
shape=[dim_out, ],
initializer=BiasInitializer,
tags=ParameterTags.BIAS
)
return model.net.Conv(
[blob_in, weight, bias],
blob_out,
kernel_h=kernel_h,
kernel_w=kernel_w,
)
def fc_decomp(
model, blob_in, blob_out, dim_in, dim_out,
rank_approx=5, weight_init=None, bias_init=None,
WeightInitializer=None, BiasInitializer=None, **kwargs
):
"""FC_Decomp version
Here we assume that the rank of original input is bigger than 5.
"""
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
blob_out = blob_out or model.net.NextName()
u = model.create_param(
param_name=blob_out + '_u',
shape=[dim_out, rank_approx],
initializer=WeightInitializer,
)
v = model.create_param(
param_name=blob_out + '_v',
shape=[dim_in, rank_approx],
initializer=WeightInitializer,
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_out, ],
initializer=BiasInitializer,
)
return model.net.FC_Decomp([blob_in, u, v, bias], blob_out, **kwargs)
def fc_decomp(
model, blob_in, blob_out, dim_in, dim_out,
rank_approx=5, weight_init=None, bias_init=None,
WeightInitializer=None, BiasInitializer=None, **kwargs
):
"""FC_Decomp version
Here we assume that the rank of original input is bigger than 5.
"""
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
blob_out = blob_out or model.net.NextName()
u = model.create_param(
param_name=blob_out + '_u',
shape=[dim_out, rank_approx],
initializer=WeightInitializer,
)
v = model.create_param(
param_name=blob_out + '_v',
shape=[dim_in, rank_approx],
initializer=WeightInitializer,
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_out, ],
initializer=BiasInitializer,
)
return model.net.FC_Decomp([blob_in, u, v, bias], blob_out, **kwargs)
def _FC_or_packed_FC(
model, op_call, blob_in, blob_out, dim_in, dim_out, weight_init=None,
bias_init=None, WeightInitializer=None, BiasInitializer=None,
**kwargs
):
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
if not model.init_params:
WeightInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
blob_out = blob_out or model.net.NextName()
bias_tags = [ParameterTags.BIAS]
if 'freeze_bias' in kwargs:
bias_tags.append(ParameterTags.COMPUTED_PARAM)
weight = model.create_param(
param_name=blob_out + '_w',
shape=[dim_out, dim_in],
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_out, ],
initializer=BiasInitializer,
tags=bias_tags
)
return op_call([blob_in, weight, bias], blob_out, **kwargs)
def spatial_gn(model, blob_in, blob_out, dim_in,
init_scale=1., init_bias=0.,
ScaleInitializer=None, BiasInitializer=None,
RunningMeanInitializer=None, RunningVarianceInitializer=None,
order="NCHW", **kwargs):
'''
Group normalizes the input, cf. https://arxiv.org/abs/1803.08494.
'''
blob_out = blob_out or model.net.NextName()
# Input: input, scale, bias
# Output: output, group_mean, group_inv_std
# scale: initialize with init_scale (default 1.)
# [recommendation: set init_scale = 0. in the last layer for each res block]
# bias: initialize with init_bias (default 0.)
if model.init_params:
scale_init = ("ConstantFill", {'value': init_scale})
bias_init = ("ConstantFill", {'value': init_bias})
ScaleInitializer = initializers.update_initializer(
ScaleInitializer, scale_init, ("ConstantFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
else:
ScaleInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
scale = model.create_param(
param_name=blob_out + '_s',
shape=[dim_in],
initializer=ScaleInitializer,
tags=ParameterTags.WEIGHT
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_in],
initializer=BiasInitializer,
tags=ParameterTags.BIAS
)
blob_outs = [blob_out,
blob_out + "_mean", blob_out + "_std"]
blob_outputs = model.net.GroupNorm(
[blob_in, scale, bias],
blob_outs,
**kwargs)
# Return the output
return blob_outputs[0]
def spatial_gn(model, blob_in, blob_out, dim_in,
init_scale=1., init_bias=0.,
ScaleInitializer=None, BiasInitializer=None,
RunningMeanInitializer=None, RunningVarianceInitializer=None,
order="NCHW", **kwargs):
'''
Group normalizes the input, cf. https://arxiv.org/abs/1803.08494.
'''
blob_out = blob_out or model.net.NextName()
# Input: input, scale, bias
# Output: output, group_mean, group_inv_std
# scale: initialize with init_scale (default 1.)
# [recommendation: set init_scale = 0. in the last layer for each res block]
# bias: initialize with init_bias (default 0.)
if model.init_params:
scale_init = ("ConstantFill", {'value': init_scale})
bias_init = ("ConstantFill", {'value': init_bias})
ScaleInitializer = initializers.update_initializer(
ScaleInitializer, scale_init, ("ConstantFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
else:
ScaleInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
scale = model.create_param(
param_name=blob_out + '_s',
shape=[dim_in],
initializer=ScaleInitializer,
tags=ParameterTags.WEIGHT
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_in],
initializer=BiasInitializer,
tags=ParameterTags.BIAS
)
blob_outs = [blob_out,
blob_out + "_mean", blob_out + "_std"]
blob_outputs = model.net.GroupNorm(
[blob_in, scale, bias],
blob_outs,
**kwargs)
# Return the output
return blob_outputs[0]
def fc_explicit_param_names(model,
blob_in,
blob_out,
weight_init=None,
bias_init=None,
**kwargs):
"""
Sets up operators for a fully connected layer between `blob_in`
and `blob_out`. Requires that explicit weight and bias parameters
are supplied.
:param model: The ModelHelper object whose net the operators
should be added to
:blob_in: The input blob for the fully connected layer
:blob_out: The output blob from the fully connected layer
:weight_init: Tuple specifying weight initialization information. Its first
entry is the name of the caffe2 operator to use in creating the weight param
and second is a dictionary of kwargs it should be passed.
:bias_init: Tuple specifying bias initialization information. Its first
entry is the name of the caffe2 operator to use in creating the bias param
and second is a dictionary of kwargs it should be passed.
:dim_in: Number of nodes in input layer
:dim_out: Number of nodes in output layer
:weight_name: Name of blob corresponding to an initialized weight parameter
:bias_name: Name of blob corresponding to an initialized bias parameter
"""
required_kwargs = ["dim_in", "dim_out", "weight_name", "bias_name"]
for arg in required_kwargs:
assert arg in kwargs, "Please supply kwarg {}".format(arg)
dim_in, dim_out = kwargs["dim_in"], kwargs["dim_out"]
WeightInitializer = initializers.update_initializer(
None, weight_init, ("XavierFill", {}))
BiasInitializer = initializers.update_initializer(None, bias_init,
("ConstantFill", {}))
weight = model.create_param(
param_name=kwargs["weight_name"],
shape=[dim_out, dim_in],
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT,
)
bias = model.create_param(
param_name=kwargs["bias_name"],
shape=[dim_out],
initializer=BiasInitializer,
tags=[ParameterTags.BIAS],
)
return model.net.FC([blob_in, weight, bias], blob_out)
def moments_with_running_stats(model,
blob_in,
blob_out,
dim_in,
RunningMeanInitializer=None,
RunningVarianceInitializer=None,
order="NCHW",
**kwargs):
if model.init_params:
rm_init = ("ConstantFill", {'value': 0.0})
riv_init = ("ConstantFill", {'value': 1.0})
RunningMeanInitializer = initializers.update_initializer(
RunningMeanInitializer, rm_init, ("ConstantFill", {}))
RunningVarianceInitializer = initializers.update_initializer(
RunningVarianceInitializer, riv_init, ("ConstantFill", {}))
else:
RunningMeanInitializer = initializers.ExternalInitializer()
RunningVarianceInitializer = initializers.ExternalInitializer()
running_mean = model.create_param(param_name=blob_out + '_rm',
shape=[dim_in],
initializer=RunningMeanInitializer,
tags=ParameterTags.COMPUTED_PARAM)
# this is just running variance
running_inv_var = model.create_param(
param_name=blob_out + '_riv',
shape=[dim_in],
initializer=RunningVarianceInitializer,
tags=ParameterTags.COMPUTED_PARAM)
blob_outs = [blob_out + "_sm", blob_out + "_sv"]
if order == 'NCHW':
blob_outputs = model.net.Moments([blob_in],
blob_outs,
axes=[0, 2, 3],
order=order,
keepdims=False,
**kwargs)
elif order == 'NHWC':
blob_outputs = model.net.Moments([blob_in],
blob_outs,
axes=[0, 1, 2],
order=order,
keepdims=False,
**kwargs)
return blob_outputs
def fc_explicit_param_names(
model, blob_in, blob_out, weight_init=None, bias_init=None, **kwargs
):
"""
Sets up operators for a fully connected layer between `blob_in`
and `blob_out`. Requires that explicit weight and bias parameters
are supplied.
:param model: The ModelHelper object whose net the operators
should be added to
:blob_in: The input blob for the fully connected layer
:blob_out: The output blob from the fully connected layer
:weight_init: Tuple specifying weight initialization information. Its first
entry is the name of the caffe2 operator to use in creating the weight param
and second is a dictionary of kwargs it should be passed.
:bias_init: Tuple specifying bias initialization information. Its first
entry is the name of the caffe2 operator to use in creating the bias param
and second is a dictionary of kwargs it should be passed.
:dim_in: Number of nodes in input layer
:dim_out: Number of nodes in output layer
:weight_name: Name of blob corresponding to an initialized weight parameter
:bias_name: Name of blob corresponding to an initialized bias parameter
"""
required_kwargs = ["dim_in", "dim_out", "weight_name", "bias_name"]
for arg in required_kwargs:
assert arg in kwargs, "Please supply kwarg {}".format(arg)
dim_in, dim_out = kwargs["dim_in"], kwargs["dim_out"]
WeightInitializer = initializers.update_initializer(
None, weight_init, ("XavierFill", {})
)
BiasInitializer = initializers.update_initializer(
None, bias_init, ("ConstantFill", {})
)
weight = model.create_param(
param_name=kwargs["weight_name"],
shape=[dim_out, dim_in],
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT,
)
bias = model.create_param(
param_name=kwargs["bias_name"],
shape=[dim_out],
initializer=BiasInitializer,
tags=[ParameterTags.BIAS],
)
return model.net.FC([blob_in, weight, bias], blob_out)
def conv_dw(model, inputs, inp, oup, stride, name):
W_dw = model.create_param(param_name=name + '_dw_w',
shape=[inp, 1, 3, 3],
initializer=initializers.update_initializer(
None, None, ("XavierFill", {})),
tags=ParameterTags.WEIGHT)
h = inputs.Conv([W_dw], [name + '_dw'],
kernel_h=3,
kernel_w=3,
stride_h=stride,
stride_w=stride,
pad_b=1,
pad_l=1,
pad_r=1,
pad_t=1,
order='NCHW',
group=inp)
h = brew.spatial_bn(model, h, name + '_dw_bn', inp, is_test=True)
h = brew.relu(model, h, h)
h = brew.conv(model,
h,
name + '_sep',
dim_in=inp,
dim_out=oup,
kernel=1,
pad=0,
stride=1,
no_bias=True)
h = brew.spatial_bn(model, h, name + '_sep_bn', oup, is_test=True)
h = brew.relu(model, h, h)
return h
def _FC_or_packed_FC(model,
op_call,
blob_in,
blob_out,
dim_in,
dim_out,
weight_init=None,
bias_init=None,
WeightInitializer=None,
BiasInitializer=None,
enable_tensor_core=False,
float16_compute=False,
**kwargs):
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {}))
BiasInitializer = initializers.update_initializer(BiasInitializer,
bias_init,
("ConstantFill", {}))
if not model.init_params:
WeightInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
blob_out = blob_out or model.net.NextName()
bias_tags = [ParameterTags.BIAS]
if 'freeze_bias' in kwargs:
bias_tags.append(ParameterTags.COMPUTED_PARAM)
weight = model.create_param(param_name=blob_out + '_w',
shape=[dim_out, dim_in],
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT)
bias = model.create_param(param_name=blob_out + '_b',
shape=[
dim_out,
],
initializer=BiasInitializer,
tags=bias_tags)
# enable TensorCore by setting appropriate engine
if enable_tensor_core:
kwargs['engine'] = 'TENSORCORE'
# Enable float 16 compute kernel (relevant for CUDA)
if float16_compute:
kwargs['float16_compute'] = True
return op_call([blob_in, weight, bias], blob_out, **kwargs)
def _FC_or_packed_FC(model,
op_call,
blob_in,
blob_out,
dim_in,
dim_out,
weight_init=None,
bias_init=None,
weight_initializer=None,
bias_initializer=None,
**kwargs):
weight_initializer = initializers.update_initializer(
weight_initializer, weight_init, ("XavierFill", {}))
bias_initializer = initializers.update_initializer(bias_initializer,
bias_init,
("ConstantFill", {}))
blob_out = blob_out or model.net.NextName()
if model.init_params:
weight = model.create_param(
param_name=blob_out + '_w',
shape=[dim_out, dim_in],
initializer=weight_initializer,
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[
dim_out,
],
initializer=bias_initializer,
)
else:
weight = core.ScopedBlobReference(blob_out + '_w',
model.param_init_net)
bias = core.ScopedBlobReference(blob_out + '_b', model.param_init_net)
if 'freeze_bias' in kwargs:
model.params.extend([weight])
else:
model.params.extend([weight, bias])
model.weights.append(weight)
model.biases.append(bias)
return op_call([blob_in, weight, bias], blob_out, **kwargs)
def spatial_bn(model, blob_in, blob_out, dim_in,
init_scale=1., init_bias=0.,
ScaleInitializer=None, BiasInitializer=None,
RunningMeanInitializer=None, RunningVarianceInitializer=None,
order="NCHW", **kwargs):
blob_out = blob_out or model.net.NextName()
# Input: input, scale, bias, est_mean, est_inv_var
# Output: output, running_mean, running_inv_var, saved_mean,
# saved_inv_var
# scale: initialize with init_scale (default 1.)
# bias: initialize with init_bias (default 0.)
# est mean: zero
# est var: ones
if model.init_params:
scale_init = ("ConstantFill", {'value': init_scale})
bias_init = ("ConstantFill", {'value': init_bias})
rm_init = ("ConstantFill", {'value': 0.0})
riv_init = ("ConstantFill", {'value': 1.0})
ScaleInitializer = initializers.update_initializer(
ScaleInitializer, scale_init, ("ConstantFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
RunningMeanInitializer = initializers.update_initializer(
RunningMeanInitializer, rm_init, ("ConstantFill", {})
)
RunningVarianceInitializer = initializers.update_initializer(
RunningVarianceInitializer, riv_init, ("ConstantFill", {})
)
else:
ScaleInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
RunningMeanInitializer = initializers.ExternalInitializer()
RunningVarianceInitializer = initializers.ExternalInitializer()
scale = model.create_param(
param_name=blob_out + '_s',
shape=[dim_in],
initializer=ScaleInitializer,
tags=ParameterTags.WEIGHT
)
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_in],
initializer=BiasInitializer,
tags=ParameterTags.BIAS
)
running_mean = model.create_param(
param_name=blob_out + '_rm',
shape=[dim_in],
initializer=RunningMeanInitializer,
tags=ParameterTags.COMPUTED_PARAM
)
running_inv_var = model.create_param(
param_name=blob_out + '_riv',
shape=[dim_in],
initializer=RunningVarianceInitializer,
tags=ParameterTags.COMPUTED_PARAM
)
blob_outs = [blob_out, running_mean, running_inv_var,
blob_out + "_sm", blob_out + "_siv"]
if 'is_test' in kwargs and kwargs['is_test']:
blob_outputs = model.net.SpatialBN(
[blob_in, scale, bias, blob_outs[1], blob_outs[2]], [blob_out],
order=order, **kwargs)
return blob_outputs
else:
blob_outputs = model.net.SpatialBN(
[blob_in, scale, bias, blob_outs[1], blob_outs[2]], blob_outs,
order=order, **kwargs)
# Return the output
return blob_outputs[0]
def _ConvBase(
model,
is_nd,
blob_in,
blob_out,
dim_in,
dim_out,
kernel,
weight_init=None,
bias_init=None,
WeightInitializer=None,
BiasInitializer=None,
group=1,
transform_inputs=None,
use_cudnn=False,
order="NCHW",
cudnn_exhaustive_search=False,
ws_nbytes_limit=None,
**kwargs
):
kernels = []
if is_nd:
if not isinstance(kernel, list):
kernels = [kernel]
else:
kernels = kernel
else:
if isinstance(kernel, list):
assert len(kernel) == 2, "Conv support only a 2D kernel."
kernels = kernel
else:
kernels = [kernel] * 2
requested_engine = kwargs.get('engine')
if requested_engine is not None:
if use_cudnn and requested_engine != 'CUDNN':
raise ValueError(
'When use_cudnn=True, the only engine you can specify is '
'"CUDNN"')
elif not use_cudnn and requested_engine == 'CUDNN':
raise ValueError(
'When use_cudnn=False, the only engine you can specify is '
'""')
if use_cudnn:
kwargs['engine'] = 'CUDNN'
kwargs['exhaustive_search'] = cudnn_exhaustive_search
if ws_nbytes_limit:
kwargs['ws_nbytes_limit'] = ws_nbytes_limit
use_bias =\
False if ("no_bias" in kwargs and kwargs["no_bias"]) else True
blob_out = blob_out or model.net.NextName()
weight_shape = [dim_out]
if order == "NCHW":
weight_shape.append(int(dim_in / group))
weight_shape.extend(kernels)
else:
weight_shape.extend(kernels)
weight_shape.append(int(dim_in / group))
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {})
)
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {})
)
if not model.init_params:
WeightInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
weight = model.create_param(
param_name=blob_out + '_w',
shape=weight_shape,
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT
)
if use_bias:
bias = model.create_param(
param_name=blob_out + '_b',
shape=[dim_out, ],
initializer=BiasInitializer,
tags=ParameterTags.BIAS
)
if use_bias:
inputs = [blob_in, weight, bias]
else:
inputs = [blob_in, weight]
if transform_inputs is not None:
transform_inputs(model, blob_out, inputs)
# For the operator, we no longer need to provide the no_bias field
# because it can automatically figure this out from the number of
# inputs.
if 'no_bias' in kwargs:
del kwargs['no_bias']
if group != 1:
kwargs['group'] = group
if is_nd:
return model.net.Conv(
inputs,
blob_out,
kernels=kernels,
order=order,
**kwargs)
else:
if isinstance(kernel, list):
return model.net.Conv(
inputs,
blob_out,
kernel_h=kernel[0],
kernel_w=kernel[1],
order=order,
**kwargs)
else:
return model.net.Conv(
inputs,
blob_out,
kernel=kernel,
order=order,
**kwargs)
def _ConvBase(model,
is_nd,
blob_in,
blob_out,
dim_in,
dim_out,
kernel,
weight_init=None,
bias_init=None,
WeightInitializer=None,
BiasInitializer=None,
group=1,
transform_inputs=None,
use_cudnn=False,
order="NCHW",
cudnn_exhaustive_search=False,
ws_nbytes_limit=None,
**kwargs):
kernels = []
if is_nd:
if not isinstance(kernel, list):
kernels = [kernel]
else:
kernels = kernel
else:
if isinstance(kernel, list):
assert len(kernel) == 2, "Conv support only a 2D kernel."
kernels = kernel
else:
kernels = [kernel] * 2
requested_engine = kwargs.get('engine')
if requested_engine is not None:
if use_cudnn and requested_engine != 'CUDNN':
raise ValueError(
'When use_cudnn=True, the only engine you can specify is '
'"CUDNN"')
elif not use_cudnn and requested_engine == 'CUDNN':
raise ValueError(
'When use_cudnn=False, the only engine you can specify is '
'""')
if use_cudnn:
kwargs['engine'] = 'CUDNN'
kwargs['exhaustive_search'] = cudnn_exhaustive_search
if ws_nbytes_limit:
kwargs['ws_nbytes_limit'] = ws_nbytes_limit
use_bias =\
False if ("no_bias" in kwargs and kwargs["no_bias"]) else True
blob_out = blob_out or model.net.NextName()
weight_shape = [dim_out]
if order == "NCHW":
weight_shape.append(int(dim_in / group))
weight_shape.extend(kernels)
else:
weight_shape.extend(kernels)
weight_shape.append(int(dim_in / group))
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {}))
BiasInitializer = initializers.update_initializer(BiasInitializer,
bias_init,
("ConstantFill", {}))
if not model.init_params:
WeightInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
weight = model.create_param(param_name=blob_out + '_w',
shape=weight_shape,
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT)
if use_bias:
bias = model.create_param(param_name=blob_out + '_b',
shape=[
dim_out,
],
initializer=BiasInitializer,
tags=ParameterTags.BIAS)
if use_bias:
inputs = [blob_in, weight, bias]
else:
inputs = [blob_in, weight]
if transform_inputs is not None:
transform_inputs(model, blob_out, inputs)
# For the operator, we no longer need to provide the no_bias field
# because it can automatically figure this out from the number of
# inputs.
if 'no_bias' in kwargs:
del kwargs['no_bias']
if group != 1:
kwargs['group'] = group
if is_nd:
return model.net.Conv(inputs,
blob_out,
kernels=kernels,
order=order,
**kwargs)
else:
if isinstance(kernel, list):
return model.net.Conv(inputs,
blob_out,
kernel_h=kernel[0],
kernel_w=kernel[1],
order=order,
**kwargs)
else:
return model.net.Conv(inputs,
blob_out,
kernel=kernel,
order=order,
**kwargs)
def DeformableConv(self,
blob_in,
offset,
prefix,
dim_in,
dim_out,
kernel,
stride=1,
pad=1,
weight_init=None,
bias_init=None,
WeightInitializer=None,
BiasInitializer=None,
dilation=1,
no_bias=1,
group=1,
deformable_group=4,
order="NCHW",
cudnn_exhaustive_search=False,
**kwargs):
kernels = []
if isinstance(kernel, list):
assert len(kernel) == 2, "Conv support only a 2D kernel."
kernels = kernel
else:
kernels = [kernel] * 2
blob_out = prefix
weight_shape = [dim_out]
if order == "NCHW":
weight_shape.append(int(dim_in / group))
weight_shape.extend(kernels)
else:
weight_shape.extend(kernels)
weight_shape.append(int(dim_in / group))
WeightInitializer = initializers.update_initializer(
WeightInitializer, weight_init, ("XavierFill", {}))
BiasInitializer = initializers.update_initializer(
BiasInitializer, bias_init, ("ConstantFill", {}))
if not self.init_params:
WeightInitializer = initializers.ExternalInitializer()
BiasInitializer = initializers.ExternalInitializer()
weight = self.create_param(param_name=blob_out + '_w',
shape=weight_shape,
initializer=WeightInitializer,
tags=ParameterTags.WEIGHT)
if not no_bias:
bias = self.create_param(param_name=blob_out + '_b',
shape=[
dim_out,
],
initializer=BiasInitializer,
tags=ParameterTags.BIAS)
if no_bias:
inputs = [blob_in, offset, weight]
else:
inputs = [blob_in, offset, weight, bias]
if isinstance(kernel, list):
return self.net.DeformConv(inputs,
blob_out,
kernel_h=kernel[0],
kernel_w=kernel[1],
pad=pad,
stride=stride,
dilation=dilation,
order=order,
deformable_group=deformable_group,
use_cudnn=self.use_cudnn)
else:
return self.net.DeformConv(inputs,
blob_out,
kernel=kernel,
pad=pad,
stride=stride,
dilation=dilation,
order=order,
deformable_group=deformable_group,
use_cudnn=self.use_cudnn)
