コード例 #1
0
ファイル: resize_ext.py プロジェクト: Umair772/VectorBlox-SDK
 def extract(cls, node: Node):
     onnx_opset_version = get_onnx_opset_version(node)
     if onnx_opset_version is not None and onnx_opset_version >= 11:
         mode = onnx_attr(node, 'mode', 's', default=b'nearest').decode()
         transformation_mode = onnx_attr(node,
                                         'coordinate_transformation_mode',
                                         's',
                                         default=b'half_pixel').decode()
         nearest_mode = onnx_attr(node,
                                  'nearest_mode',
                                  's',
                                  default=b'round_prefer_floor').decode()
         cubic_coeff_a = onnx_attr(node,
                                   'cubic_coeff_a',
                                   'f',
                                   default=-0.75)
         attrs = {
             'mode': mode,
             'coordinate_transformation_mode': transformation_mode,
             'nearest_mode': nearest_mode,
             'cube_coeff': cubic_coeff_a
         }
         ONNXResize11Op.update_node_stat(node, attrs)
     else:
         mode = onnx_attr(node, 'mode', 's', default=b'nearest').decode()
         UpsampleOp.update_node_stat(node, {'mode': mode})
     return cls.enabled
コード例 #2
0
ファイル: upsample_ext.py プロジェクト: zhenlusu500/openvino
    def extract(cls, node):
        onnx_opset_version = get_onnx_opset_version(node)
        if onnx_opset_version is not None and onnx_opset_version >= 9:
            mode = onnx_attr(node,
                             'mode',
                             's',
                             default='nearest',
                             dst_type=lambda x: x.decode())
            ONNXResize10.update_node_stat(node, {'mode': mode})
        else:
            mode = onnx_attr(node,
                             'mode',
                             's',
                             default='nearest',
                             dst_type=lambda x: x.decode())
            scales = onnx_attr(
                node,
                'scales',
                'floats',
                dst_type=lambda x: np.array(x, dtype=np.float32))
            width_scale = onnx_attr(node, 'width_scale', 'f')
            height_scale = onnx_attr(node, 'height_scale', 'f')

            supported_modes = ['nearest', 'linear']
            if mode not in supported_modes:
                raise Error(
                    'Error decoding Upsample node {}, mode = {} is not in the list of supported modes {}.',
                    node.name, mode, supported_modes)

            if scales is not None:
                if scales.shape != (4, ):
                    raise Error(
                        'Upsample scales attribute is wrong for node {}. Only 4D scales are supported.',
                        node.name)
                if math.fabs(scales[0] - 1) > 1e-5 or math.fabs(scales[1] -
                                                                1) > 1e-5:
                    raise Error(
                        'Upsampling of batch and feature dimensions is not supported for node {}.',
                        node.name)
                height_scale = scales[2]
                width_scale = scales[3]

            if (width_scale is None
                    or height_scale is None) and len(node.in_nodes()) != 2:
                raise Error(
                    'One/both of widths_scale = {} and height_scale = {} is not defined for Upsample node {}.',
                    width_scale, height_scale, node.name)

            UpsampleOp.update_node_stat(
                node, {
                    'mode': mode,
                    'height_scale': height_scale,
                    'width_scale': width_scale
                })
        return cls.enabled
コード例 #3
0
 def extract(node: Node):
     mode = onnx_attr(node, 'mode', 's', default=b'nearest').decode()
     UpsampleOp.update_node_stat(node, {'mode': mode})
     return __class__.enabled