def TranslateConv(layer, pretrained_blobs):
param = layer.convolution_param
if param.group > 1:
return TranslateConvWithGroups(layer, pretrained_blobs)
# If there is no odd things, we will basically translate it to a standard
# caffe2 op.
caffe_op = BaseTranslate(layer, "Conv")
output = caffe_op.output[0]
caffe_op.input.extend([output + '_w', output + '_b'])
if len(param.stride) > 1 or len(param.kernel_size) != 1 or len(
param.pad) > 1:
raise NotImplementedError(
"Translator currently does not support non-conventional "
"pad/kernel/stride settings."
)
stride = param.stride[0] if len(param.stride) else 1
pad = param.pad[0] if len(param.pad) else 0
AddArgument(caffe_op, "stride", stride)
AddArgument(caffe_op, "kernel", param.kernel_size[0])
AddArgument(caffe_op, "pad", pad)
AddArgument(caffe_op, "order", "NCHW")
weight = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')
bias = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[1].flatten(), output + '_b'
)
return caffe_op, [weight, bias]
def TranslateConvNd(layer, pretrained_blobs, is_test, **kwargs):
param = layer.convolution3d_param
caffe_op = BaseTranslate(layer, "Conv")
output = caffe_op.output[0]
caffe_op.input.append(output + '_w')
AddArgument(
caffe_op,
"kernels",
[param.kernel_depth, param.kernel_size, param.kernel_size])
AddArgument(
caffe_op,
"strides",
[param.temporal_stride, param.stride, param.stride])
temporal_pad = 0
spatial_pad = 0
if hasattr(param, 'temporal_pad'):
temporal_pad = param.temporal_pad
if hasattr(param, 'pad'):
spatial_pad = param.pad
AddArgument(caffe_op, "pads", [temporal_pad, spatial_pad, spatial_pad] * 2)
# weight
params = [
utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')]
# bias
if len(pretrained_blobs) == 2:
caffe_op.input.append(output + '_b')
params.append(
utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[1].flatten(), output + '_b'))
return caffe_op, params
def TranslateBatchNorm(layer, pretrained_blobs, is_test, **kwargs):
caffe_op = BaseTranslate(layer, "SpatialBN")
output = caffe_op.output[0]
param = layer.batch_norm_param
AddArgument(caffe_op, "is_test", is_test)
AddArgument(caffe_op, "epsilon", param.eps)
AddArgument(caffe_op, "order", "NCHW")
caffe_op.input.extend([
output + "_scale", output + "_bias", output + "_mean", output + "_var"
])
if not is_test:
caffe_op.output.extend([
output + "_mean", output + "_var", output + "_saved_mean",
output + "_saved_var"
])
n_channels = pretrained_blobs[0].shape[0]
if pretrained_blobs[2][0] != 0:
mean = utils.NumpyArrayToCaffe2Tensor(
(1. / pretrained_blobs[2][0]) * pretrained_blobs[0],
output + '_mean')
var = utils.NumpyArrayToCaffe2Tensor(
(1. / pretrained_blobs[2][0]) * pretrained_blobs[1],
output + '_var')
else:
raise RuntimeError("scalar is zero.")
pretrained_blobs[2][0] = 1
pretrained_blobs[2] = np.tile(pretrained_blobs[2], (n_channels, ))
scale = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[2],
output + '_scale')
bias = utils.NumpyArrayToCaffe2Tensor(np.zeros_like(pretrained_blobs[2]),
output + '_bias')
return caffe_op, [scale, bias, mean, var]
def TranslateInnerProduct(layer, pretrained_blobs, is_test, **kwargs):
param = layer.inner_product_param
try:
if param.axis != 1 or param.transpose:
raise ValueError(
"We don't have testing case for non-default axis and transpose "
"cases yet so we are disabling it for now. If you have a model "
"with this, please do send us your model for us to update this "
"support, and you are more than welcome to send a PR for this.")
except AttributeError:
# We might be using an historic Caffe protobuf that does not have axis
# and transpose arguments, so we will silently pass.
pass
caffe_op = BaseTranslate(layer, "FC")
output = caffe_op.output[0]
caffe_op.input.extend([output + '_w', output + '_b'])
# To provide the old-style 4-dimensional blob (1, 1, dim_output, dim_input)
# case, we always explicitly reshape the pretrained blob.
if pretrained_blobs[0].ndim not in [2, 4]:
raise ValueError("Unexpected weight ndim.")
if (pretrained_blobs[0].ndim == 4 and
list(pretrained_blobs[0].shape[:2]) != [1, 1]):
raise ValueError(
"If pretrained blob has 4 dims (old-style Caffe), the first two "
"should be of value 1, but I got " + str(pretrained_blobs[0].shape))
weight = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[0].reshape(-1, pretrained_blobs[0].shape[-1]),
output + '_w'
)
bias = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[1].flatten(), output + '_b'
)
return caffe_op, [weight, bias]
def TranslateConv(layer, pretrained_blobs, is_test, **kwargs):
param = layer.convolution_param
caffe_op = BaseTranslate(layer, "Conv")
output = caffe_op.output[0]
caffe_op.input.append(output + '_w')
_TranslateStridePadKernelHelper(param, caffe_op)
# weight
params = [
utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')]
# bias
if len(pretrained_blobs) == 2:
caffe_op.input.append(output + '_b')
params.append(
utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[1].flatten(), output + '_b'))
# Group convolution option
if param.group != 1:
AddArgument(caffe_op, "group", param.group)
# Get dilation - not tested. If you have a model and this checks out,
# please provide a test and uncomment this.
if len(param.dilation) > 0:
if len(param.dilation) == 1:
AddArgument(caffe_op, "dilation", param.dilation[0])
elif len(param.dilation) == 2:
AddArgument(caffe_op, "dilation_h", param.dilation[0])
AddArgument(caffe_op, "dilation_w", param.dilation[1])
return caffe_op, params
def TranslateBatchNorm(layer, pretrained_blobs, is_test):
caffe_op = BaseTranslate(layer, "SpatialBN")
output = caffe_op.output[0]
param = layer.batch_norm_param
AddArgument(caffe_op, "is_test", is_test)
AddArgument(caffe_op, "epsilon", param.eps)
AddArgument(caffe_op, "order", "NCHW")
caffe_op.input.extend([
output + "_scale", output + "_bias", output + "_mean", output + "_var"
])
if not is_test:
caffe_op.output.extend([
output + "_mean", output + "_var", output + "_saved_mean",
output + "_saved_var"
])
mean = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0],
output + '_mean')
var = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1], output + '_var')
scale = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[2],
output + '_scale')
bias = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[3],
output + '_bias')
return caffe_op, [scale, bias, mean, var]
def TranslateInnerProduct(layer, pretrained_blobs, is_test):
caffe_op = BaseTranslate(layer, "FC")
output = caffe_op.output[0]
caffe_op.input.extend([output + '_w', output + '_b'])
weight = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')
bias = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1].flatten(),
output + '_b')
return caffe_op, [weight, bias]
def TranslateConvWithGroups(layer, pretrained_blobs, is_test):
print("Legacy warning: convolution with groups seem to be less and less " +
"popular, so we no longer have it as a first-class citizen op. " +
"Instead, we will simulate it with depth split followed by conv " +
"followed by depth concat.")
caffe_ops = []
caffe_params = []
param = layer.convolution_param
weight, bias = pretrained_blobs
bias = bias.flatten()
n, c, h, w = weight.shape
g = param.group # group
od = int(n / g) # output dimension
if (od * g != n):
# This should not happen: n should always be divisible by g.
raise ValueError("This should not happen.")
output = layer.top[0]
# first, depth_split
depth_split_op = core.CreateOperator(
"DepthSplit",
str(layer.bottom[0]),
['_' + output + '_gconv_split_' + str(i) for i in range(g)],
split=[c for i in range(g)],
order="NCHW")
caffe_ops.append(depth_split_op)
# second, convolutions
if (len(param.stride) > 1 or len(param.kernel_size) != 1
or len(param.pad) > 1):
raise NotImplementedError(
"Translator currently does not support non-conventional "
"pad/kernel/stride settings.")
stride = param.stride[0] if len(param.stride) else 1
pad = param.pad[0] if len(param.pad) else 0
for i in range(g):
# convolution layer i
this_weight = utils.NumpyArrayToCaffe2Tensor(
weight[i * od:(i + 1) * od], output + '_gconv_' + str(i) + '_w')
this_bias = utils.NumpyArrayToCaffe2Tensor(
bias[i * od:(i + 1) * od], output + '_gconv_' + str(i) + '_b')
conv_op = core.CreateOperator(
"Conv",
[depth_split_op.output[i], this_weight.name, this_bias.name],
['_' + output + '_gconv_conv_' + str(i)],
stride=stride,
kernel=param.kernel_size[0],
pad=pad,
order="NCHW")
caffe_ops.append(conv_op)
caffe_params.extend([this_weight, this_bias])
# third, depth concat
depth_concat_op = core.CreateOperator(
"Concat", ['_' + output + '_gconv_conv_' + str(i) for i in range(g)],
[output, '_' + output + '_gconv_concat_dims'],
order="NCHW")
caffe_ops.append(depth_concat_op)
return caffe_ops, caffe_params
def TranslateInstanceNorm(layer, pretrained_blobs, is_test, **kwargs):
caffe_op = BaseTranslate(layer, "InstanceNorm")
output = caffe_op.output[0]
weight = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[0].flatten(), output + '_w')
bias = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[1].flatten(), output + '_b')
caffe_op.input.extend([output + '_w', output + '_b'])
AddArgument(caffe_op, "order", "NCHW")
return caffe_op, [weight, bias]
def TranslateScale(layer, pretrained_blobs, is_test, **kwargs):
mul_op = BaseTranslate(layer, "Mul")
scale_param = layer.scale_param
AddArgument(mul_op, "axis", scale_param.axis)
AddArgument(mul_op, "broadcast", True)
if len(mul_op.input) == 1:
# the scale parameter is in pretrained blobs
if scale_param.num_axes != 1:
raise RuntimeError("This path has not been verified yet.")
output = mul_op.output[0]
mul_op_param = output + 'scale_w'
mul_op.input.append(mul_op_param)
weights = []
weights.append(
utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0].flatten(),
mul_op_param))
add_op = None
if len(pretrained_blobs) == 0:
#the bn have 5 blobs
pass
elif len(pretrained_blobs) == 1:
# No bias-term in Scale layer
pass
elif len(pretrained_blobs) == 2:
# Caffe Scale layer supports a bias term such that it computes
# (scale_param * X + bias), whereas Caffe2 Mul op doesn't.
# Include a separate Add op for the bias followed by Mul.
add_op = copy.deepcopy(mul_op)
add_op.type = "Add"
add_op_param = output + 'scale_b'
internal_blob = output + "_internal"
del mul_op.output[:]
mul_op.output.append(internal_blob)
del add_op.input[:]
add_op.input.append(internal_blob)
add_op.input.append(add_op_param)
weights.append(
utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1].flatten(),
add_op_param))
else:
raise RuntimeError(
"Unexpected number of pretrained blobs in Scale")
caffe_ops = [mul_op]
if add_op:
caffe_ops.append(add_op)
assert len(caffe_ops) == len(weights)
return caffe_ops, weights
elif len(mul_op.input) == 2:
# TODO(jiayq): find a protobuf that uses this and verify.
raise RuntimeError("This path has not been verified yet.")
else:
raise RuntimeError("Unexpected number of inputs.")
def TranslateDeconv(layer, pretrained_blobs, is_test):
param = layer.convolution_param
if param.group > 1:
raise NotImplementedError(
"Translator currently does not support group deconvolution.")
caffe_op = BaseTranslate(layer, "ConvTranspose")
output = caffe_op.output[0]
_TranslateStridePadKernelHelper(param, caffe_op)
caffe_op.input.extend([output + '_w', output + '_b'])
AddArgument(caffe_op, "order", "NCHW")
weight = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')
bias = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1].flatten(),
output + '_b')
return caffe_op, [weight, bias]
def write_db(db_type, db_name, features, labels):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for i in range(features.shape[0]):
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(features[i]),
utils.NumpyArrayToCaffe2Tensor(labels[i])
])
transaction.put('train_%03d'.format(i),
feature_and_label.SerializeToString())
# Close the transaction, and then close the db.
del transaction
del db
def TranslateConv(layer, pretrained_blobs, is_test):
param = layer.convolution_param
if param.group > 1:
return TranslateConvWithGroups(layer, pretrained_blobs, is_test)
# If there is no odd things, we will basically translate it to a standard
# caffe2 op.
caffe_op = BaseTranslate(layer, "Conv")
output = caffe_op.output[0]
caffe_op.input.extend([output + '_w', output + '_b'])
_TranslateStridePadKernelHelper(param, caffe_op)
weight = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')
bias = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1].flatten(),
output + '_b')
return caffe_op, [weight, bias]
def insert_db(db_name, data, labels):
db_type = db_name.split(".")[-1]
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for i in range(data.shape[0]):
data_and_label = caffe2_pb2.TensorProtos()
data_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(data[i]),
utils.NumpyArrayToCaffe2Tensor(labels[i])
])
transaction.put('data_%03d'.format(i),
data_and_label.SerializeToString())
# Close the transaction, and then close the db.
del transaction
del db
def TranslatePRelu(layer, pretrained_blobs, is_test, **kwargs):
caffe_op = BaseTranslate(layer, "PRelu")
output = caffe_op.output[0]
caffe_op.input.extend([output + '_Slope'])
slope = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_Slope')
return caffe_op, [slope]
def TranslateConv(layer, pretrained_blobs):
param = layer.convolution_param
if param.group > 1:
return TranslateConvWithGroups(layer, pretrained_blobs)
# If there is no odd things, we will basically translate it to a standard
# caffe2 op.
caffe_op = BaseTranslate(layer, "Conv")
output = caffe_op.output[0]
caffe_op.input.extend([output + '_w', output + '_b'])
AddArgument(caffe_op, "stride", param.stride)
AddArgument(caffe_op, "kernel", param.kernel_size)
AddArgument(caffe_op, "pad", param.pad)
AddArgument(caffe_op, "order", "NCHW")
weight = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_w')
bias = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[1].flatten(), output + '_b')
return caffe_op, [weight, bias]
def write_db(db_type, db_name, input_file):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
with open(input_file,'r') as f:
data_paths = f.readlines()
for j in range(len(data_paths)):
img_path = data_paths[j].split(' ')[0]
print(j,img_path)
label = np.array(int(data_paths[j].split(' ')[1][0]))
img = skimage.img_as_float(skimage.io.imread(img_path))
img = skimage.transform.resize(img,(224,224))
img = img[:,:,(2,1,0)]
img_data = img.transpose(2,0,1)
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([utils.NumpyArrayToCaffe2Tensor(img_data), utils.NumpyArrayToCaffe2Tensor(label)])
transaction.put('train_%04d'.format(j),feature_and_label.SerializeToString())
del transaction
del db
def write_caffe_db(db_type, db_name, folder, filetype):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
i = 0
filename = folder + '/*.' + filetype
for filename in glob.glob(filename): #assuming gif
im = skimage.img_as_float(skimage.io.imread(filename)).astype(np.float32)
img256 = skimage.transform.resize(img, w_size, y_size))
img256 = img256.swapaxes(1, 2).swapaxes(0, 1)
img256 = img256[(2, 1, 0), :, :]
lab = np.array(0, dtype = "int64")
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(img256),
utils.NumpyArrayToCaffe2Tensor(lab)
])
transaction.put(
'train_%03d'.format(i),
feature_and_label.SerializeToString())
i += 1
def TranslateBatchNorm(layer, pretrained_blobs, is_test):
caffe_op = BaseTranslate(layer, "SpatialBN")
output = caffe_op.output[0]
param = layer.batch_norm_param
AddArgument(caffe_op, "is_test", is_test)
AddArgument(caffe_op, "epsilon", param.eps)
AddArgument(caffe_op, "order", "NCHW")
caffe_op.input.extend([output + "_scale", output + "_bias", output + "_mean", output + "_var"])
if not is_test:
caffe_op.output.extend([output + "_mean", output + "_var", output + "_saved_mean", output + "_saved_var"])
n_channels = pretrained_blobs[0].shape[0]
mean = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_mean')
var = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1], output + '_var')
pretrained_blobs[2] = np.tile(pretrained_blobs[2], (n_channels, ))
scale = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[2], output + '_scale')
# Create a zero bias array the same size as the scale, we'll let the following
# Scale (Mul + Add operators in Caffe2) layer handle any bias, just like Caffe
bias = utils.NumpyArrayToCaffe2Tensor(np.zeros_like(pretrained_blobs[2]), output + '_bias')
return caffe_op, [scale, bias, mean, var]
def TranslateNormalize(layer, pretrained_blobs, is_test):
caffe_op = BaseTranslate(layer, "Norm")
output = caffe_op.output[0]
param = layer.norm_param
AddArgument(caffe_op, "across_spatial", param.across_spatial)
AddArgument(caffe_op, "eps", param.eps)
AddArgument(caffe_op, "channel_shared", param.channel_shared)
AddArgument(caffe_op, "order", "NCHW")
caffe_op.input.extend([output + "_scale"])
scale = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0], output + '_scale')
return caffe_op, [scale]
def write_db(db_type, db_name, data_lst):
''' The minidb datebase seems immutable.
'''
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for i in range(data_lst[0].shape[0]):
tensor = caffe2_pb2.TensorProtos()
temp_lst = []
for data in data_lst:
temp_lst.append(utils.NumpyArrayToCaffe2Tensor(data[i]))
tensor.protos.extend(temp_lst)
transaction.put(str(i), tensor.SerializeToString())
del transaction
del db
return db_name
def TranslateBatchNorm(layer, pretrained_blobs, is_test, **kwargs):
caffe_op = BaseTranslate(layer, "SpatialBN")
output = caffe_op.output[0]
param = layer.batch_norm_param
AddArgument(caffe_op, "is_test", is_test)
AddArgument(caffe_op, "epsilon", param.eps)
AddArgument(caffe_op, "order", "NCHW")
caffe_op.input.extend(
[output + "_scale",
output + "_bias",
output + "_mean",
output + "_var"])
if not is_test:
caffe_op.output.extend(
[output + "_mean",
output + "_var",
output + "_saved_mean",
output + "_saved_var"])
n_channels = pretrained_blobs[0].shape[0]
if pretrained_blobs[2][0] != 0:
mean = utils.NumpyArrayToCaffe2Tensor(
(1. / pretrained_blobs[2][0]) * pretrained_blobs[0],
output + '_mean')
var = utils.NumpyArrayToCaffe2Tensor(
(1. / pretrained_blobs[2][0]) * pretrained_blobs[1],
output + '_var')
else:
raise RuntimeError("scalar is zero.")
if len(pretrained_blobs) > 3:
# IntelCaffe and NVCaffe uses fused BN+Scale,
# three blobs for BN and two blobs for Scale,
# so that the total number of blobs becomes five (including scale and bias).
scale = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[3].flatten(),
output + '_scale')
bias = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[4].flatten(),
output + '_bias')
else:
pretrained_blobs[2][0] = 1
pretrained_blobs[2] = np.tile(pretrained_blobs[2], (n_channels, ))
scale = utils.NumpyArrayToCaffe2Tensor(
pretrained_blobs[2],
output + '_scale')
bias = utils.NumpyArrayToCaffe2Tensor(
np.zeros_like(pretrained_blobs[2]),
output + '_bias')
return caffe_op, [scale, bias, mean, var]
def TranslateScale(layer, pretrained_blobs, is_test):
caffe_op = BaseTranslate(layer, "Mul")
scale_param = layer.scale_param
AddArgument(caffe_op, "axis", scale_param.axis)
AddArgument(caffe_op, "broadcast", True)
if len(caffe_op.input) == 1:
# the scale parameter is in pretrained blobs
if scale_param.num_axes != 1:
raise RuntimeError("This path has not been verified yet.")
output = caffe_op.output[0]
caffe_op.input.append(output + '_w')
weight = utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0].flatten(),
output + '_w')
return caffe_op, [weight]
elif len(caffe_op.input) == 2:
# TODO(jiayq): find a protobuf that uses this and verify.
raise RuntimeError("This path has not been verified yet.")
else:
raise RuntimeError("Unexpected number of inputs.")
def TranslateScale(layer, pretrained_blobs, is_test, **kwargs):
mul_op = BaseTranslate(layer, "Mul")
scale_param = layer.scale_param
AddArgument(mul_op, "axis", scale_param.axis)
AddArgument(mul_op, "broadcast", True)
if len(mul_op.input) == 1:
# This crashes if the prototxt has a layer (e.g. pred_ab) that isn't present in caffemodel.
# Although the blobs are not defined, the filler param in scale_param
# should define what the blobs value(s) should be.
# Unfortunately, difficult to determine shape of blob. Need to read code more to understand how to do it.
#pretrained_blobs = [
# utils.CaffeBlobToNumpyArray(blob)
# for blob in pretrained_layers[0].blobs
#]
#blob_shape = utils.CaffeBlobToNumpyArray(layer.bottom[0].blobs).shape
#print blob_shape
#net, net_params, input_dims = kwargs['net'], kwargs['net_params'], kwargs['input_dims']
#n, c, h, w = input_dims
#dummy_input = np.random.randn(n, c, h, w).astype(np.float32)
#dim_map = _GetBlobDimMap(net, net_params, dummy_input)
#caffe_op = BaseTranslate(layer, "Dummy")
#input_1 = caffe_op.input[1]
#input_1_dim = dim_map[input_1]
#print input_1_dim
#print pretrained_blobs
# the scale parameter is in pretrained blobs
if scale_param.num_axes != 1:
raise RuntimeError("This path has not been verified yet.")
output = mul_op.output[0]
mul_op_param = output + '_w'
mul_op.input.append(mul_op_param)
weights = []
weights.append(
utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[0].flatten(),
mul_op_param))
add_op = None
if len(pretrained_blobs) == 1:
# No bias-term in Scale layer
pass
elif len(pretrained_blobs) == 2:
# Caffe Scale layer supports a bias term such that it computes
# (scale_param * X + bias), whereas Caffe2 Mul op doesn't.
# Include a separate Add op for the bias followed by Mul.
add_op = copy.deepcopy(mul_op)
add_op.type = "Add"
add_op_param = output + '_b'
internal_blob = output + "_internal"
del mul_op.output[:]
mul_op.output.append(internal_blob)
del add_op.input[:]
add_op.input.append(internal_blob)
add_op.input.append(add_op_param)
weights.append(
utils.NumpyArrayToCaffe2Tensor(pretrained_blobs[1].flatten(),
add_op_param))
else:
raise RuntimeError(
"Unexpected number of pretrained blobs in Scale")
caffe_ops = [mul_op]
if add_op:
caffe_ops.append(add_op)
assert len(caffe_ops) == len(weights)
return caffe_ops, weights
elif len(mul_op.input) == 2:
# TODO(jiayq): find a protobuf that uses this and verify.
raise RuntimeError("This path has not been verified yet.")
else:
raise RuntimeError("Unexpected number of inputs.")
def TranslateModel(
cls,
caffe_net,
pretrained_net,
is_test=False,
input_mean=None,
net_state=None,
):
net_state = caffe_pb2.NetState() if net_state is None else net_state
net = caffe2_pb2.NetDef()
net.name = caffe_net.name
net_params = caffe2_pb2.TensorProtos()
if len(caffe_net.layer) == 0:
raise ValueError(
'I think something is wrong. This translation script '
'only accepts new style layers that are stored in the '
'layer field.')
if input_mean:
caffenet_mean = caffe_pb2.BlobProto()
caffenet_mean.ParseFromString(open(input_mean, 'rb').read())
mean_ = utils.CaffeBlobToNumpyArray(caffenet_mean)
mean_tensor = utils.NumpyArrayToCaffe2Tensor(mean_, 'mean_')
net_params.protos.extend([mean_tensor])
mean_op = caffe2_pb2.OperatorDef()
mean_op.type = 'Sub'
mean_op.input.extend(['data_', 'mean_'])
# Assume that input blob's name is "data"
mean_op.output.extend(['data'])
net.op.extend([mean_op])
i = 0
while i < len(caffe_net.layer):
if not _ShouldInclude(net_state, caffe_net.layer[i]):
log.info('Current net state does not need layer {}'.format(
caffe_net.layer[i].name))
continue
log.info('Translate layer {}'.format(caffe_net.layer[i].name))
# Get pretrained one
pretrained_layers_index = ([
l for l in xrange(len(pretrained_net.layer))
if pretrained_net.layer[l].name == caffe_net.layer[i].name
] + [
l for l in xrange(len(pretrained_net.layers))
if pretrained_net.layers[l].name == caffe_net.layer[i].name
])
is_bn = False
if len(pretrained_layers_index) > 1:
raise ValueError(
'huh? more than one pretrained layer of one name?')
elif len(pretrained_layers_index) == 1:
if pretrained_net.layer[
pretrained_layers_index[0]].type == "BatchNorm":
# A Scale layer should follow BatchNorm layer
# according to paper https://arxiv.org/abs/1502.03167.
assert pretrained_net.layer[pretrained_layers_index[0] +
1].type == "Scale"
pretrained_blobs = [utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_net.layer[pretrained_layers_index[0]].blobs] + \
[utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_net.layer[pretrained_layers_index[0] + 1].blobs]
is_bn = True
else:
pretrained_blobs = [
utils.CaffeBlobToNumpyArray(blob) for blob in
pretrained_net.layer[pretrained_layers_index[0]].blobs
]
else:
# No pretrained layer for the given layer name. We'll just pass
# no parameter blobs.
# print 'No pretrained layer for layer', layer.name
pretrained_blobs = []
operators, params = cls.TranslateLayer(caffe_net.layer[i],
pretrained_blobs, is_test)
net.op.extend(operators)
net_params.protos.extend(params)
if is_bn:
i += 2
else:
i += 1
return net, net_params
pyplot.plot(train_features[train_labels == i, 0],
train_features[train_labels == i, 1], legend[i])
pyplot.figure()
pyplot.title("Testing data distribution, feature 0 and 1")
for i in range(3):
pyplot.plot(test_features[test_labels == i, 0],
test_features[test_labels == i, 1], legend[i])
# Now, as promised, let's put things into a Caffe2 DB. In this DB, what would happen is that we will use "train_xxx" as the key, and use a TensorProtos object to store two tensors for each data point: one as the feature and one as the label. We will use Caffe2 python's DB interface to do so.
# In[6]:
# First, let's see how one can construct a TensorProtos protocol buffer from numpy arrays.
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(features[0]),
utils.NumpyArrayToCaffe2Tensor(labels[0])
])
print('This is what the tensor proto looks like for a feature and its label:')
print(str(feature_and_label))
print('This is the compact string that gets written into the db:')
print(feature_and_label.SerializeToString())
# In[7]:
# Now, actually write the db.
def write_db(db_type, db_name, features, labels):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for _ in xrange(DATASET_SAMPLE_SIZE):
random.shuffle(data)
for num in data:
count = count + 1
if count % 100 == 0:
os.system('clear')
print GenProgressBar(count, total,
50), '%d/%d picture(s)' % (count, total)
text = str(num).zfill(DIGITS)
captcha = image.generate(text)
captcha_image = Image.open(captcha).convert('L')
img_data = np.array(captcha_image.getdata())
img_label = np.array([int(c) for c in text])
data_and_label = caffe2_pb2.TensorProtos()
data_and_label.protos.extend(
[utils.NumpyArrayToCaffe2Tensor(img_data)] + [
utils.NumpyArrayToCaffe2Tensor(img_label[i])
for i in range(DIGITS)
])
transaction.put('train_%d' % count, data_and_label.SerializeToString())
del transaction
del db
""" Report """
print 'Generated db:[' + DATABASE_NAME + '] at ' + DATABASE_PATH + '.'
