def extract(cls, node: Node): attrs = {'axis': node.pb.bias_param.axis} embed_input(attrs, 1, 'bias', node.model_pb.blobs[0].data, 'biases') Add.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): pb = node.pb model = node.model_pb param = pb.scale_param attrs = { 'axis': param.axis, } if model is None and len(pb.bottom) == 1: # default weights and biases for scale layer if the caffemodel file doesn't contain them model = NamedAttrsClass({ 'blobs': mo_array([ NamedAttrsClass({'data': mo_array([1])}), NamedAttrsClass({'data': mo_array([0])}) ]) }) # scale with 1 input and 1 or 2 blobs if model and len(model.blobs) != 0 and len(pb.bottom) == 1: attrs.update(weights_biases(param.bias_term, model)) # 2 inputs + bias elif len(pb.bottom) == 2 and param.bias_term: if model is None or len(model.blobs) == 0: # default bias for scale layer with 2 inputs if the caffemodel file doesn't contain them model = NamedAttrsClass({ 'blobs': mo_array([NamedAttrsClass({'data': mo_array([0])})]) }) embed_input(attrs, 1, 'biases', model.blobs[0].data) ScaleShiftOp.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<Dim>') dim = read_binary_integer32_token(pb) collect_until_token(pb, b'<BlockDim>') block_dim = read_binary_integer32_token(pb) collect_until_token(pb, b'<Epsilon>') eps = read_binary_float_token(pb) collect_until_token(pb, b'<TargetRms>') target_rms = read_binary_float_token(pb) collect_until_token(pb, b'<StatsMean>') mean = read_binary_vector(pb) collect_until_token(pb, b'<StatsVar>') var = read_binary_vector(pb) scale = target_rms / np.sqrt(var + eps) shift = -target_rms * mean / np.sqrt(var + eps) scale = np.tile(scale, dim // block_dim) shift = np.tile(shift, dim // block_dim) attrs = {'out-size': dim} embed_input(attrs, 1, 'weights', scale) embed_input(attrs, 2, 'biases', shift) ScaleShiftOp.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): pb = node.parameters read_learning_info(pb) weights = read_binary_vector(pb) mapping_rule = {} embed_input(mapping_rule, 1, 'weights', weights) ScaleShiftOp.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): pb = node.parameters read_learning_info(pb) biases = read_binary_vector(pb) bias_term = True mapping_rule = {'bias_term': bias_term} embed_input(mapping_rule, 1, 'weights', np.ones(biases.shape)) embed_input(mapping_rule, 2, 'biases', biases) ScaleShiftOp.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node: Node) -> bool: """ Extract conv parameters from node.parameters. node.parameters like file descriptor object. :param node: Convolution node :return: """ pb = node.parameters kernel = read_token_value(pb, b'<PatchDim>') stride = read_token_value(pb, b'<PatchStep>') patch_stride = read_token_value(pb, b'<PatchStride>') read_learning_info(pb) collect_until_whitespace(pb) weights, weights_shape = read_binary_matrix(pb) collect_until_whitespace(pb) biases = read_binary_vector(pb) if (patch_stride - kernel) % stride != 0: raise Error( 'Kernel size and stride does not correspond to `patch_stride` attribute of Convolution layer. ' + refer_to_faq_msg(93)) output = biases.shape[0] if weights_shape[0] != output: raise Error('Weights shape does not correspond to the `output` attribute of Convolution layer. ' + refer_to_faq_msg(93)) mapping_rule = { 'output': output, 'patch_stride': patch_stride, 'bias_term': None, 'pad': np.array([[0, 0], [0, 0], [0, 0], [0, 0]], dtype=np.int64), 'pad_spatial_shape': np.array([[0, 0], [0, 0]], dtype=np.int64), 'dilation': np.array([1, 1, 1, 1], dtype=np.int64), 'kernel': np.array([1, 1, 1, kernel], dtype=np.int64), 'stride': np.array([1, 1, 1, stride], dtype=np.int64), 'kernel_spatial': np.array([1, kernel], dtype=np.int64), 'input_feature_channel': 1, 'output_feature_channel': 0, 'kernel_spatial_idx': [2, 3], 'group': 1, 'reshape_kernel': True, } mapping_rule.update(layout_attrs()) embed_input(mapping_rule, 1, 'weights', weights) embed_input(mapping_rule, 2, 'biases', biases) mapping_rule['bias_addable'] = len(biases) > 0 Convolution.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<Params>') weights = read_binary_vector(pb) find_next_tag(pb) read_placeholder(pb, 1) mapping_rule = { 'layout': 'NCHW' } embed_input(mapping_rule, 1, 'weights', weights) ScaleShiftOp.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<Dim>') dim = read_binary_integer32_token(pb) collect_until_token(pb, b'<Scale>') scale = read_binary_float_token(pb) # TODO add real batch here attrs = {} embed_input(attrs, 1, 'weights', np.full([dim], scale)) ScaleShiftOp.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<Params>') weights, weights_shape = read_binary_matrix(pb) mapping_rule = { 'out-size': weights_shape[0], 'transpose_weights': True, } embed_input(mapping_rule, 1, 'weights', weights) FullyConnected.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): eps = node.pb.batch_norm_param.eps attrs = {'eps': eps} pb_model = None if not node.soft_get('model_pb', None) else node.model_pb if pb_model: blobs = pb_model.blobs assert len( blobs) >= 2, 'BatchNorm accepts not less then two input blobs' mean = mo_array(blobs[0].data) variance = mo_array(blobs[1].data) if len(blobs) == 3: scale = blobs[2].data[0] if scale != 0: scale = 1.0 / scale mean *= scale variance *= scale embed_input(attrs, 1, 'gamma', np.ones(mean.shape), 'gamma') embed_input(attrs, 2, 'beta', np.zeros(variance.shape), 'beta') embed_input(attrs, 3, 'mean', mean, 'biases') embed_input(attrs, 4, 'variance', variance, 'weights') BatchNormInference.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<ConvolutionModel>') in_shape = read_token_value(pb, b'<NumFiltersIn>') out_shape = read_token_value(pb, b'<NumFiltersOut>') height_in = read_token_value(pb, b'<HeightIn>') height_out = read_token_value(pb, b'<HeightOut>') height_subsample = read_token_value(pb, b'<HeightSubsampleOut>') collect_until_token(pb, b'<Offsets>') offsets = read_binary_vector_of_pairs(pb, read_token=False, dtype=np.int32) collect_until_token(pb, b'<RequiredTimeOffsets>') time_offsets = read_binary_vector(pb, read_token=False, dtype=np.int32) collect_until_token(pb, b'<LinearParams>') weights, _ = read_binary_matrix(pb) collect_until_token(pb, b'<BiasParams>') biases = read_binary_vector(pb) offsets = offsets.reshape([len(offsets) // 2, 2]) mapping_rule = { # stride for h axis 'height_subsample': height_subsample, # input dimension for h axis 'height_in': height_in, # output dimension for h axis 'height_out': height_out, # input dimension for channel axis 'in_channels': in_shape, # output dimension for channel axis 'out_channels': out_shape, # array with pairs like the following # [ (-1, -1) (-1, 0) (-1, 1) # (0, -1) (0, 0) (0, 1) # (1, -1) (1, 0) (1, 1)] # it means that kernel 3x3 will be applied to calculate current value of output 'offsets': offsets, # required time offsets to calculate current convolution # time_offsets = [-1, 0, 1] for previous example means no padding for time axis and # 3 values should be prepared # time_offsets = [0] means zero padding [1, 1] for time axis 'time_offsets': time_offsets, 'out-size': out_shape * height_out } embed_input(mapping_rule, 1, 'weights', weights) embed_input(mapping_rule, 2, 'biases', biases) TimeHeightConvolutionComponent.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): pb = node.parameters read_learning_info(pb) weights, weights_shape = read_binary_matrix(pb) biases = read_binary_vector(pb) mapping_rule = { 'out-size': weights_shape[0], 'transpose_weights': True, } embed_input(mapping_rule, 1, 'weights', weights) embed_input(mapping_rule, 2, 'biases', biases) FullyConnected.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<Bias>') biases = read_binary_vector(pb) find_next_tag(pb) read_placeholder(pb, 1) mapping_rule = { 'layout': 'NCHW', 'bias_term': True, 'out-size': biases.shape[0], } embed_input(mapping_rule, 2, 'biases', biases) ScaleShiftOp.update_node_stat(node, mapping_rule) return cls.enabled
def test_embed_input_w_bin_name(self): attrs = {} blob = np.array([1, 2]) name = 'weights' embed_input(attrs, 1, name, blob, 'special_name') exp_res = { 'weights': blob, 'embedded_inputs': [(1, name, { 'bin': 'special_name' })] } for key in exp_res.keys(): if key == name: np.testing.assert_equal(attrs[key], exp_res[key]) else: self.assertEqual(attrs[key], exp_res[key])
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<LinearParams>') weights, weights_shape = read_binary_matrix(pb) tag = find_next_tag(pb) read_placeholder(pb, 1) if tag != '<BiasParams>': raise Error('FixedAffineComponent must contain BiasParams') biases = read_binary_vector(pb) mapping_rule = { 'out-size': weights_shape[0], 'transpose_weights': True, } embed_input(mapping_rule, 1, 'weights', weights) embed_input(mapping_rule, 2, 'biases', biases) FullyConnected.update_node_stat(node, mapping_rule) return cls.enabled
def extract(cls, node): pb = node.parameters try: collect_until_token(pb, b'<Dim>') except Error: try: pb.seek(0) collect_until_token(pb, b'<InputDim>') except Error: raise Error("Neither <Dim> nor <InputDim> were found") in_dim = read_binary_integer32_token(pb) try: collect_until_token(pb, b'<TargetRms>') target_rms = read_binary_float_token(pb) except Error: # model does not contain TargetRms target_rms = 1.0 try: collect_until_token(pb, b'<AddLogStddev>') add_log = read_binary_bool_token(pb) except Error: # model does not contain AddLogStddev add_log = False if add_log is not False: raise Error("AddLogStddev True in Normalize component is not supported") scale = target_rms * np.sqrt(in_dim) attrs = { 'eps': 0.00000001, 'across_spatial': 0, 'channel_shared': 1, 'in_dim': in_dim, } embed_input(attrs, 1, 'weights', [scale]) NormalizeOp.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): pb = node.parameters collect_until_token(pb, b'<Params>') ifo_x_weights, ifo_x_weights_shape = read_binary_matrix(pb) try: use_dropout = collect_until_token_and_read(pb, b'<UseDropout>', np.bool) except Error: # layer have not UseDropout attribute, so setup it to False use_dropout = False mapping_rule = {'use_dropout': use_dropout} assert len( ifo_x_weights_shape ) == 2, "Unexpected shape of weights in LSTMNonLinearityComponent" assert ifo_x_weights_shape[ 0] == 3, "Unexpected shape of weights in LSTMNonLinearityComponent" ifo_x_weights = ifo_x_weights.reshape(ifo_x_weights_shape) embed_input(mapping_rule, 1, 'i_weights', ifo_x_weights[0][:]) embed_input(mapping_rule, 2, 'f_weights', ifo_x_weights[1][:]) embed_input(mapping_rule, 3, 'o_weights', ifo_x_weights[2][:]) LstmNonLinearity.update_node_stat(node, mapping_rule) return cls.enabled
def extract_custom_blobs(node): """ Enumerate all blobs in node.model_pb, for each blob creates a new embedded input of name 'custom_X', where X is an index >= 0 according to the order blobs appear in node.model_pb. The order is also enforced by input port index. So the order of blobs is preserved in the final IR generation. Order is important because they can be accessed by indices (in addition to names). Update node attributes in-place. """ base_port = len(node.in_nodes()) if not hasattr(node.model_pb, 'blobs'): return for i, blob in enumerate(node.model_pb.blobs): port = base_port + i internal_name = '_custom_blob_' + str(i) log.debug("Found new custom blob of length {} for node {}. ".format( len(blob.data), node.name if node.has_valid('name') else '<UNKNOWN>') + "It will appear as input {} and internal attribute {}.". format(port, internal_name)) embed_input(node.graph.node[node.id], port, internal_name, blob.data, blob_name(i))
def extract(cls, node): clip_value = 50 pb = node.parameters res = collect_until_whitespace(pb) if res == b'<CellClip>': clip_value = get_uint32(pb.read(4)) collect_until_token(pb, b'FM') gifo_x_weights, gifo_x_weights_shape = read_binary_matrix(pb, False) gifo_r_weights, gifo_r_weights_shape = read_binary_matrix(pb) gifo_biases = read_binary_vector(pb) input_gate_weights = read_binary_vector(pb) forget_gate_weights = read_binary_vector(pb) output_gate_weights = read_binary_vector(pb) projection_weights, projection_weights_shape = read_binary_matrix(pb) mapping_rule = { 'gifo_x_weights_shape': gifo_x_weights_shape, 'gifo_r_weights_shape': gifo_r_weights_shape, 'projection_weights_shape': projection_weights_shape, 'clip_value': clip_value, 'format': 'kaldi', } embed_input(mapping_rule, 1, 'gifo_x_weights', gifo_x_weights) embed_input(mapping_rule, 2, 'gifo_r_weights', gifo_r_weights) embed_input(mapping_rule, 3, 'gifo_biases', gifo_biases) embed_input(mapping_rule, 4, 'input_gate_weights', input_gate_weights) embed_input(mapping_rule, 5, 'forget_gate_weights', forget_gate_weights) embed_input(mapping_rule, 6, 'output_gate_weights', output_gate_weights) embed_input(mapping_rule, 7, 'projection_weights', projection_weights) LSTMCell.update_node_stat(node, mapping_rule) return cls.enabled