def replace_pattern(self, graph: Graph, match: dict):
            Adds layers with type 'Const' that produce blob from 'bin' file. The pass finds data nodes with one output which
            doesn't have edge with 'bin' attribute (or with two outputs and at least one output havent 'bin' attr)
            and generate Const op node before the node and data node before the Const node. The data node before 'Const'
            node is needed because the op node dumps input tensors to bin file.
        node = match['data']
        if len(node.in_nodes()) > 0:

        if self._check_bin_attrs(node):
            if node.has_valid('value'):
                const_node_name = graph.unique_id( + '_const')
                log.debug("Added Const node '{}'".format(const_node_name))
                const_node = Const(
                    graph, {
                        node.soft_get('force_shape', None),
                        node.soft_get('force_type', None),
                        node.soft_get('correct_data_type', None),
                graph.add_edges_from([(const_node_name,, {'out': 0})])

                node_copy = node.copy_node()
                graph.add_edges_from([(, const_node_name, {
                    'in': 0,
                    'bin': 'custom'
            elif not self._check_that_node_from_body(node):
                log.debug('node = {}'.format(node.graph.node[]))
                raise Error(
                    'Discovered data node without inputs and value, = {}, = {}. '
                    + refer_to_faq_msg(23), node.soft_get('name'),
                    if len(node.out_nodes()) else "<no consumer>")
Exemple #2
    def extract(cls, node: Node):
        unsupported_attrs = []
        for attr_name in [
                'adjoint_a', 'adjoint_b', 'a_is_sparse', 'b_is_sparse'
            if attr_name in node.pb.attr and node.pb.attr[attr_name].b:
        if len(unsupported_attrs) != 0:
            raise Error('MatMul operation {} use unsupported attrs: {}'.format(
      , unsupported_attrs))

            node, {
                'transpose_a': node.pb.attr['transpose_a'].b,
                'transpose_b': node.pb.attr['transpose_b'].b,
        return cls.enabled
Exemple #3
def convert_blob(blob: np.ndarray, dst_type: type):
    if blob.dtype == dst_type:
        return blob, None, None

    converted_blob = blob.astype(dtype=dst_type, casting="unsafe")
    if dst_type in (np.int32, np.int64, np.uint8,
                    np.int8) and not np.array_equal(blob, converted_blob):
        raise Error(
            'The conversion of blob with value "{}" to dst_type "{}" results in rounding'
            .format(blob, dst_type))

    finite_match = (np.isfinite(blob) != np.isfinite(converted_blob))
    zero_match = ((blob == 0) != (converted_blob == 0))
    finite_match_count = np.count_nonzero(finite_match)
    zero_match_count = np.count_nonzero(zero_match)

    return converted_blob, finite_match_count, zero_match_count
Exemple #4
 def __init__(self, graph: Graph, attrs: dict):
     mandatory_props = {
         'type': __class__.op,
         'op': __class__.op,
         'levels': None,
         'is_eltwise': True,
         # flag to switch between dumping FakeQuantize as statistics and keeping it as layer in IR
         'keep_in_IR': None,
         'infer': __class__.infer,
         'in_ports_count': 5,
         'out_ports_count': 1,
     super().__init__(graph, mandatory_props, attrs)
     if self.attrs['levels'] is None:
         raise Error("FakeQuantize operation has no levels parameter")
     # TODO remove following lines after FakeQuantize supported for int8 workflow
     self.attrs['keep_in_IR'] = self.attrs['levels'] == 2 or graph.graph['cmd_params'].keep_quantize_ops_in_IR
Exemple #5
def _check_unique_ids():
    Check that idxs is unique for all registered replacements.
    unique_idxs = set()
    for class_type, classes_set in _registered_classes_dict.items():
        for cls in classes_set:
            replacers = [c for c in cls.registered_cls if not hasattr(c, 'op')] + \
                        [c for op, c in cls.registered_ops.items() if c]
            for replacer_cls in replacers:
                if hasattr(replacer_cls, 'id'):
                    id_cls = getattr(replacer_cls, 'id')

                    if id_cls in unique_idxs:
                        raise Error('Found replacer {} with not unique id!'.format(replacer_cls))
    log.debug("All replacers has unique idxs.")
Exemple #6
def collect_until_token(file_desc: io.BufferedReader, token):
    Read from file until the token
    :param file_desc: file descriptor
    while True:
        # usually there is the following structure <CellDim> DIM<ClipGradient> VALUEFM
        res = collect_until_whitespace(file_desc)
        if res == token or res[-len(token):] == token:
        if isinstance(file_desc, io.BytesIO):
            size = len(file_desc.getbuffer())
        elif isinstance(file_desc, io.BufferedReader):
            size = os.fstat(file_desc.fileno()).st_size
        if file_desc.tell() == size:
            raise Error('End of the file. Token {} not found. {}'.format(token, file_desc.tell()))
Exemple #7
def convert(graph: nx.MultiDiGraph, data_type_str: str):
    for node_name, node_attrs in graph.nodes(data=True):
        node = Node(graph, node_name)
        # if the data type is forcibly set then use it
        if node.has_valid('force_precision'):
            real_data_type_str = node_attrs['force_precision']
            real_data_type_str = data_type_str
        node_attrs['precision'] = data_type_str_to_precision(
        if node.kind == 'data' and node.value is not None:
                convert_blob(graph, node,
            except Exception as e:
                raise Error('Coudn\'t convert blob {}, details: {}',
                            node.soft_get('name'), e) from e
Exemple #8
    def merge_nodes_permutations(graph: Graph):
        # Iterate over all data nodes and check all permutations for similarity
        # In case of equal permutations, this permutation will be set as attribute for data node
        # otherwise exception will be raised
        for node in graph.nodes():
            node = Node(graph, node)
            if node.kind != 'data':

            permutations = []

            # Get all permutations from in edges
            for in_node in node.in_nodes():
                edge_attrs = node.graph.get_edge_data(,[0]
                if 'permutation' in edge_attrs:

            # Get all permutations from out edges
            for out_node in node.out_nodes():
                edge_attrs = node.graph.get_edge_data(,[0]
                if 'permutation' in edge_attrs:

            # Check that all permutations are equal
            final_permutations = []
            for p in permutations:
                if p is not None:

            if len(final_permutations) == 0:

            if not all([
                    np.array_equal(final_permutations[0], perm)
                    for perm in final_permutations
                raise Error(
                    'Permutations requested for {} data node are not equal! List of permutations: {}'
                    ''.format(, [p.perm for p in permutations]))

            assert not node.has_valid('permutation') or np.array_equal(
                node.permutation, permutations[0])
            node['permutation'] = permutations[0]
Exemple #9
 def extract(cls, node):
     attrs = get_mxnet_layer_attrs(node.symbol_dict)
     act_type = attrs.str('act_type', 'relu')
     if act_type == 'sigmoid':
         act_class = Sigmoid
     elif act_type == 'tanh':
         act_class = Tanh
     elif act_type == 'relu':
         act_class = ReLU
     elif act_type == 'softrelu':
         act_class = SoftPlus
         raise Error(
             "Operation '{}' not supported. Please register it as custom op. "
             + refer_to_faq_msg(86), act_type)
     return cls.enabled
Exemple #10
def decode_name_with_port(input_model: InputModel, node_name: str):
    Decode name with optional port specification w/o traversing all the nodes in the graph
    TODO: in future node_name can specify input/output port groups and indices (58562)
    :param input_model: Input Model
    :param node_name: user provided node name
    :return: decoded place in the graph
    # Check exact match with one of the names in the graph first
    node = input_model.get_place_by_tensor_name(node_name)
    if node:
        return node

    # TODO: Add support for input/output group name and port index here (58562)
    # Legacy frontends use format "number:name:number" to specify input and output port indices
    # For new frontends this logic shall be extended to additionally support input and output group names
    raise Error('There is no node with name {}'.format(node_name))
Exemple #11
 def check_shapes_consistency(self):
     data_nodes = self.get_data_nodes()
     data_nodes_with_wrong_shapes = []
     for data_node in data_nodes:
         if not data_node.has('shape'):
                 (, "no shape attribute"))
         if data_node.shape is not None and not isinstance(
                 data_node.shape, np.ndarray):
                 (, type(data_node.shape)))
     if len(data_nodes_with_wrong_shapes) > 0:
         raise Error(
             "Graph contains data nodes ({}) with inconsistent shapes: {}".
Exemple #12
def onnx_attr(node: Node, name: str, field: str, default=None, dst_type=None):
    """ Retrieves ONNX attribute with name `name` from ONNX protobuf `node.pb`.
        The final value is casted to dst_type if attribute really exists.
        The function returns `default` otherwise.
    attrs = [a for a in node.pb.attribute if == name]
    if len(attrs) == 0:
        # there is no requested attribute in the protobuf message
        return default
    elif len(attrs) > 1:
        raise Error('Found multiple entries for attribute name {} when at most one is expected. Protobuf message with '
                    'the issue: {}.', name, node.pb)
        res = getattr(attrs[0], field)
        if dst_type is not None:
            return dst_type(res)
            return res
Exemple #13
def shape_inference(graph: Graph):
    nodes = pseudo_topological_sort(graph)
    for node in nodes:
        node = Node(graph, node)
        if node.has_and_set('need_shape_inference'):
            old_out_shapes = [
       for port in node.out_ports().values()
            new_out_shapes = [
       for port in node.out_ports().values()
            for shape1, shape2 in zip(old_out_shapes, new_out_shapes):
                if shape1 is not None and not np.array_equal(shape1, shape2):
                    raise Error(
                        "After partial shape inference were found shape collision for node {} (old shape: {}, new shape: {})"
                        .format(, shape1, shape2))
            node.need_shape_inference = False
 def replace_sub_graph(self, graph: Graph, match: [dict, SubgraphMatch]):
     node = match['reduce']
     connected_in_ports = [
         port for port in node.in_ports().values()
         if not port.disconnected()
     if len(connected_in_ports) == 1:
         # if the 'axis' is None then we still add a second input to the layer with a 1D array with 1 element equal
         # to None. The infer function handles this case because the input shape is known at this stage only
         if node.has('axis'):
             const = Const(graph, {'value': node.axis}).create_node()
             node.add_input_port(1, skip_if_exist=True)
             del graph.node[]['axis']
             raise Error(
                 'Can not deduce `reduce_axis` for {}: only one in_port and no `axis` parameter.'
    def find_and_replace_pattern(self, graph: Graph):
        for node in graph.get_op_nodes():
            node_type = node.soft_get('type').lower()
            name = node.soft_get('name',

            if node.soft_get('version', None) == 'opset1' and node_type not in self.opset_1_types:
                raise Error('Node {} has `version` attribute set to `opset1`, but it is a reserved word, '
                            'please use another'.format(name))

            if not node.has_valid('version'):
                if node_type in self.opset_1_types:
                    node['version'] = 'opset1'
                elif node_type in self.opset_1_experimental_ops:
                    node['version'] = 'experimental'
                    node['version'] = 'extension'
                    log.error('Please set `version` attribute for node {} with type={}'
                              ''.format(name, node.soft_get('type')), extra={'is_warning': True})
 def replace_sub_graph(self, graph: Graph, match: [dict, SubgraphMatch]):
     node = match['transpose']
     connected_in_ports = [
         port for port in node.in_ports().values()
         if not port.disconnected()
     if len(connected_in_ports) == 1:
         if node.has_valid('order'):
             const = Const(graph, {'value': node.order}).create_node()
             node.add_input_port(1, skip_if_exist=True)
             del graph.node[]['order']
         elif node.has('order') and node.order is None:
             assert node.has_and_set('reverse_order')
             raise Error(
                 'Can not deduce transpose `order` for {}: only one in_port and no `order` parameter.'
Exemple #17
 def find_and_replace_pattern(self, graph: Graph):
     for squeeze_node in graph.get_op_nodes(op='Squeeze'):
         if len(squeeze_node.in_nodes()) == 1 and squeeze_node.has_valid(
             dims_node = Const(
                 graph, {
                     'name': + '/Dims',
                     'value': int64_array(squeeze_node.squeeze_dims)
             del squeeze_node['squeeze_dims']
         elif len(squeeze_node.in_nodes()) == 2:
             log.debug('The Squeeze node "{}" is already normalized'.format(
             raise Error(
                 'The Squeeze layer "{}" should either have 2 inputs or one input and an "squeeze_dims" '
Exemple #18
    def extract(cls, node):
        if get_onnx_opset_version(node) < 10:
            starts = int64_array(onnx_attr(node, 'starts', 'ints', default=[]))
            ends = int64_array(onnx_attr(node, 'ends', 'ints', default=[]))
            axes = int64_array(onnx_attr(node, 'axes', 'ints', default=[]))

            if len(starts) == 0 or len(ends) == 0:
                raise Error(
                    "starts or/and ends are not specified for the node {}".
            if len(axes) == 0:
                axes = np.arange(len(starts),

            attrs = {'axes': axes, 'starts': starts, 'ends': ends}
            AttributedSlice.update_node_stat(node, attrs)
        else:  # onnx_opset_version >= 10
        return cls.enabled
Exemple #19
 def backend_attrs(self):
     version = self.get_opset()
     if version == 'opset2':
         return [
              lambda node: bool_to_str(node, 'across_channels')),
              lambda node: bool_to_str(node, 'normalize_variance'))
     elif version == 'opset6':
         return [
             'eps', 'eps_mode',
              lambda node: bool_to_str(node, 'normalize_variance'))
         raise Error('Unsupported MVN opset version "{}"'.format(version))
Exemple #20
 def extract_port(node_port):
     if isinstance(node_port, tuple):
         node = node_port[0]
         port = node_port[1]
         node = node_port
         port = 0
     # 'data' nodes do not have 'out' edge attribute but always has one output
     out_ids = [
         for _, __, attr in node.graph.out_edges(, data=True)
         if 'out' in attr
     if len(set(out_ids)) > 1 and not isinstance(node_port, tuple):
         raise Error(
             'Node {} has more than one outputs. Provide output port explicitly. '
     return node, port
Exemple #21
    def find_and_replace_pattern(self, graph: Graph):
        iter_get_next_shapes = defaultdict(list)
        for iter_get_next in graph.get_op_nodes(op='IteratorGetNext'):
            iter_get_next_name = iter_get_next.soft_get(
            for port in iter_get_next.out_ports():
                if not np_data_type_to_precision(
                        iter_get_next.types[port]) in SUPPORTED_DATA_TYPES:
                    raise Error(
                        "In IteratorGetNext node '{}' data type '{}' is not supported"
                        .format(iter_get_next_name, iter_get_next.types[port]))


        add_input_ops(graph, iter_get_next_shapes, True)
Exemple #22
def tf_tensor_content(tf_dtype, shape, pb_tensor):
    type_helper = tf_data_type_decode[tf_dtype] if tf_dtype in tf_data_type_decode else None
    if type_helper is None:
        raise Error("Data type is unsupported: {}. " +
                    refer_to_faq_msg(50), tf_dtype)

    if pb_tensor.tensor_content:
        value = np.array(np.frombuffer(pb_tensor.tensor_content, type_helper[0]))
        # load typed value
        if type_helper[0] != np.str:
            value = np.array(type_helper[1](pb_tensor), dtype=type_helper[0])
                value = np.array(type_helper[1](pb_tensor), dtype=type_helper[0])
            except UnicodeDecodeError:
                    'Failed to parse a tensor with Unicode characters. Note that Inference Engine does not support '
                    'string literals, so the string constant should be eliminated from the graph.',
                    extra={'is_warning': True})
                value = np.array(type_helper[1](pb_tensor))

    if len(shape) == 0 or == 0:
        if len(value) == 1:
            # return scalar if shape is [] otherwise broadcast according to shape
            return np.array(value[0], dtype=type_helper[0])
            # no shape, return value as is
            return value

    if len(value) !=
        log.warning("Shape and content size of tensor don't match, shape: {} content size: {}".
                    format(shape, len(value)))
        # broadcast semantics according to TensorFlow v1.5 documentation:
        # The argument value can be a constant value, or a list of values of type dtype. If value is a list,
        # then the length of the list must be less than or equal to the number of elements implied by the shape
        # argument (if specified). In the case where the list length is less than the number of elements specified
        # by shape, the last element in the list will be used to fill the remaining entries.
        value_flatten = value.flatten()
        add_value = value_flatten[-1]
        add_length = - len(value_flatten)
        value = np.concatenate([value_flatten, np.full([add_length], add_value)])

    return value.reshape(shape)
Exemple #23
 def find_and_replace_pattern(self, graph: Graph):
     for node in graph.get_op_nodes(squeeze_axis=True):
         name = node.soft_get('name',
         for out_port in node.out_ports().values():
             if node.has_valid('axis'):
                 squeeze_node = create_op_with_const_inputs(
                     graph, Squeeze, {1: np.array(node.axis)},
                     {'name': name + '/Squeeze_'})
             elif node.is_in_port_connected(1):
                 squeeze_node = Squeeze(graph, {
                     'name': name + '/Squeeze_'
                 raise Error(
                     'Unknown axis to squeeze for node {}'.format(name))
Exemple #24
def shape_insert(shape: [np.ndarray, list], pos: int,
                 obj: [int, list, np.ndarray, dynamic_dimension]):
    Insert element(s) in the input tensor shape (presumably the numpy masked array) specified by position pos.
    The function is implemented to avoid usage of np.insert which corrupts information about the masked elements.

    :param shape: the shape object to insert element(s) to
    :param pos: the position to insert the elements into
    :param obj: the list or a single integer or the dynamic_dimension_value or numpy array to insert
    :return: shape with inserted elements
    if isinstance(obj,
                  (int, np.int64, np.int32)) or obj is dynamic_dimension_value:
        return shape_insert(shape, pos, [obj])
    elif isinstance(obj, (np.ndarray, list)):
        return[:pos]), shape_array(obj),
        raise Error('Incorrect parameter type of "obj": {}'.format(type(obj)))
Exemple #25
    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
Exemple #26
    def _set_value(self, value):
        if self.node.graph.stage == 'front':
            raise Error("set_value is not applicable for graph front phase")
            data_node_caller = self.node.in_node if self.type == 'in' else self.node.out_node
            data_node = data_node_caller(self.idx, control_flow=self.control_flow)
            const_node = data_node.in_node(control_flow=self.control_flow) if self.type == 'in' else self.node

            force_shape = data_node.soft_get('force_shape', const_node.soft_get('force_shape', None))
            shape = int64_array(value.shape if force_shape is None else force_shape)

            # Set value to data node
            data_node.value = value
            data_node.shape = shape

            # Set value to constant producer
            if const_node.soft_get('type') == 'Const':
                const_node.value = value
                const_node.shape = shape
 def save_custom_replacement_config_file(descriptions: list,
                                         file_name: str):
     Save custom layer(s) description(s) to the file.
     :param file_name: file to save description information to.
     :param descriptions: list with instances of the CustomLayerDescriptor classes.
     :return: True if operation is successful.
             for replacement_desc in descriptions
                   open(file_name, "w"),
     except Exception as ex:
         raise Error("failed to update configuration file {}: {}".format(
             file_name, str(ex)))
Exemple #28
    def find_and_replace_pattern(self, graph: Graph):
        unsupported_nodes = []
        for node in graph.nodes():
            node = Node(graph, node)
            if node.kind == 'op' and node.soft_get('type') in self.unsupported_operations:
                input_shape = node.in_node(0).shape
                if len(input_shape) > 4:
                    unsupported_nodes.append((, node.type))

        if len(unsupported_nodes) == 0:

        error_message = "\nOperations below were marked as unsupported due to they expect more than two spatial dims" \
                        " (input shape length more than 4)\n"
        error_message += "List of unsupported operations ({})\n".format(len(unsupported_nodes))
        for node, type in unsupported_nodes:
            error_message += "      {} {}\n".format(type, node)

        raise Error(error_message)
Exemple #29
def read_token_value(file_desc: io.BufferedReader, token: bytes = b'', value_type: type = np.uint32):
    Get value of the token.
    Read next token (until whitespace) and check if next teg equals token
    :param file_desc: file descriptor
    :param token: token
    :param value_type:  type of the reading value
    :return: value of the token
    getters = {
        np.uint32: read_binary_integer32_token,
        np.uint64: read_binary_integer64_token,
        np.bool: read_binary_bool_token
    current_token = collect_until_whitespace(file_desc)
    if token != b'' and token != current_token:
        raise Error('Can not load token {} from Kaldi model'.format(token) +
    return getters[value_type](file_desc)
    def replace_op(self, graph: Graph, node: Node):
        ss_node = create_op_with_const_inputs(graph, Split, {1: int64_array(1)}, {'name': 'Split_eltwise_' +,
                                                                                  'num_splits': node['num_inputs']})

        inp = node.get_inputs()
        in_node = inp[0][0]
        edge_attrs = inp[0][1]
        graph.add_edge(in_node,, **edge_attrs)
        if ss_node.num_splits == 2:
            eltwise_node = Eltwise(graph, attrs={'name': 'Eltwise_' +,
                                                 'operation': node['operation']}).create_node()
        elif ss_node.num_splits > 2:
            eltwise_node = EltwiseN(graph, attrs={'name': 'Eltwise_' +,
                                                  'operation': node['operation']}).create_node()
            raise Error('Error on replacing Kaldi eltwise')
        for i in range(ss_node.num_splits):
        return []