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 + '.'