def test_eltwise_infer_none_val(self): graph = build_graph( nodes_attributes, [('node_1', 'eltw_1'), ('node_2', 'eltw_1'), ('eltw_1', 'node_3'), ('node_3', 'op_output')], { 'node_3': { 'shape': None }, 'node_1': { 'shape': np.array([1, 3, 256, 256]), 'value': None }, 'node_2': { 'shape': np.array([1, 3, 256, 256]) } }) graph.graph['layout'] = 'NCHW' eltwise_node = Node(graph, 'eltw_1') eltwise_infer(eltwise_node, lambda a, b: a * b) exp_shape = np.array([1, 3, 256, 256]) res_shape = graph.node['node_3']['shape'] res_value = eltwise_node.out_node().value for i in range(0, len(exp_shape)): self.assertEqual(exp_shape[i], res_shape[i]) self.assertIsNone(res_value)
def nodes_dict(original, transformed=None, levels=255, data=None, il=[-127], ih=[127], ol=[-127], oh=[127]): shape = [1, 2, 3, 4] if data is None else np.array(data).shape data = np.ones(shape, dtype=original) if data is None else np.array( data, dtype=original) int_data = data.astype(dtype=np.int8) transformed = transformed if transformed is not None else original return { **valued_const_with_data('weights', data), **valued_const_with_data('int_weights', int_data), **regular_op_with_shaped_data( 'weights_cast', shape, { 'type': 'Convert', 'op': 'Cast', 'infer': Cast.infer, 'dst_type': np.float32 }), **regular_op_with_shaped_data( 'cast', shape, { 'type': 'Convert', 'op': 'Cast', 'infer': Cast.infer, 'dst_type': transformed }), **valued_const_with_data('il', np.array(il)), **valued_const_with_data('ih', np.array(ih)), **valued_const_with_data('ol', np.array(ol)), **valued_const_with_data('oh', np.array(oh)), **regular_op_with_shaped_data( 'FQ', shape, { 'type': 'FakeQuantize', 'infer': FakeQuantize.infer, 'stop_value_propagation': True, 'levels': levels, 'op': 'FakeQuantize' }), **valued_const_with_data('zp', np.array([0])), **valued_const_with_data('scale', np.array([1])), **regular_op_with_shaped_data( 'sub', shape, { 'type': 'Subtract', 'op': 'Sub', 'infer': lambda node: eltwise_infer(node, Sub.operation) }), **regular_op_with_shaped_data( 'mul', shape, { 'type': 'Multiply', 'op': 'Mul', 'infer': lambda node: eltwise_infer(node, Mul.operation) }), **result() }
def infer(node: Node): name = node.soft_get('name', node.id) connected_inputs = {idx: port for idx, port in node.in_ports().items() if not port.disconnected()} assert len(connected_inputs) == 1 and 0 in connected_inputs, \ "AttributedPower should have 1 connected input port, but it doesn't for node: `{}`. Ports: {}" \ "".format(name, connected_inputs) assert node.has_valid('scale'), \ 'AttributedPower operation should have `scale` parameter set, but it doesn`t for node {}'.format(name) assert node.has_valid('shift'), \ 'AttributedPower operation should have `shift` parameter set, but it doesn`t for node {}'.format(name) assert node.has_valid('power'), \ 'AttributedPower operation should have `power` parameter set, but it doesn`t for node {}'.format(name) eltwise_infer(node, lambda a: np.power(a * node.scale + node.shift, node.power))
def __init__(self, graph: Graph, attrs: dict): operations = { 'sum': ('Add', lambda a, b: a + b), 'mul': ('Mul', lambda a, b: a * b), 'max': ('Max', lambda a, b: np.ma.maximum(a, b)), 'pow': ('Pow', lambda a, b: np.ma.power(a, b)), 'less': ('Less', lambda a, b: np.ma.less(a, b)), 'less_equal': ('LessEqual', lambda a, b: np.ma.less_equal(a, b)), 'greater': ('Greater', lambda a, b: np.ma.greater(a, b)), 'greater_equal': ('GreaterEqual', lambda a, b: np.ma.greater_equal(a, b)), 'equal': ('Equal', lambda a, b: np.ma.equal(a, b)), 'floor_mod': ('FloorMod', lambda a, b: np.ma.fmod(a, b)), 'not_equal': ('NotEqual', lambda a, b: np.ma.not_equal(a, b)), 'logical_or': ('LogicalOr', lambda a, b: bool(a) or bool(b)), 'logical_and': ('LogicalAnd', lambda a, b: bool(a) and bool(b)), 'logical_xor': ('LogicalXor', lambda a, b: bool(a) ^ bool(b)), 'log': ('Log', lambda x: np.ma.log(x)), } super().__init__( graph, { 'type': self.op, 'op': operations[attrs['operation']][0], 'infer': lambda node: eltwise_infer(node, operations[node.operation][1] ), 'in_ports_count': 2, 'out_ports_count': 1, }, attrs)
def test_eltwise_infer_none_min_max(self): graph = build_graph(nodes_attributes, [('node_1', 'eltw_1'), ('node_2', 'eltw_1'), ('eltw_1', 'node_3'), ('node_3', 'op_output') ], {'node_3': {'shape': None}, 'node_1': {'shape': np.array([1, 3, 257, 256])}, 'node_2': {'shape': np.array([1, 3, 256, 257])} }) graph.graph['layout'] = 'NCHW' eltwise_node = Node(graph, 'eltw_1') with self.assertRaisesRegex(Error, 'Input shapes mismatch*'): eltwise_infer(eltwise_node)
def test_eltwise_infer(self, value1, shape1, value2, shape2, shape_infer, exp_value, exp_shape): graph = build_graph( nodes_attributes, [('node_1', 'eltw_1'), ('node_2', 'eltw_1'), ('eltw_1', 'node_3'), ('node_3', 'op_output')], { 'node_3': { 'shape': None }, 'node_1': { 'shape': shape_array(value1).shape if value1 is not None else shape_array(shape1), 'value': value1 }, 'node_2': { 'shape': shape_array(value2).shape if value2 is not None else shape_array(shape2), 'value': value2 } }) graph.graph['layout'] = 'NCHW' eltwise_node = Node(graph, 'eltw_1') eltwise_infer(eltwise_node, shape_infer) res_shape = graph.node['node_3']['shape'] res_value = eltwise_node.out_node().value if exp_value is not None: self.assertTrue( strict_compare_tensors(res_value, shape_array(exp_value))) self.assertTrue( strict_compare_tensors(res_shape, shape_array(exp_shape)))
def __init__(self, graph: Graph, attrs: dict): super().__init__(graph, { 'op': self.op, 'type': self.op_type, 'version': self.version, 'infer': lambda node: eltwise_infer(node, self.operation), 'type_infer': self.type_infer, 'can_be_bias': True, 'can_be_fused': True, 'in_ports_count': 2, 'out_ports_count': 1, 'is_eltwise': True, 'stop_value_propagation': False, 'auto_broadcast': 'numpy' }, attrs)
def test_zero_point_optimization(self, weights, zero_point, adj_weights, adj_zero_point): nodes = lambda w, zp: { **valued_const_with_data('weights', np.array(w, dtype=np.int8)), **regular_op_with_shaped_data( 'cast', [len(w)], { 'type': 'Convert', 'op': 'Cast', 'infer': Cast.infer, 'dst_type': np.float32 }), **valued_const_with_data('zp', np.array(zp, dtype=np.float32)), **regular_op_with_shaped_data( 'sub', [len(w)], { 'type': 'Subtract', 'op': 'Sub', 'infer': lambda node: eltwise_infer(node, Sub.operation) }), **result() } edges = [ *connect("weights:0", "0:cast"), *connect("cast:0", "0:sub"), *connect("zp:0", "1:sub"), *connect("sub:0", "0:output"), ] graph = build_graph(nodes(weights, zero_point), edges, nodes_with_edges_only=True) ZeroPointOptimizer().find_and_replace_pattern(graph) graph.clean_up() graph_ref = build_graph(nodes(adj_weights, adj_zero_point), [ *connect("weights:0", "0:cast"), *connect("cast:0", "0:output"), ], nodes_with_edges_only=True) graph_ref.clean_up() (flag, resp) = compare_graphs(graph, graph_ref, 'output', check_op_attrs=True) self.assertTrue(flag, resp)
def infer(cls, node: Node): return eltwise_infer(node, node.operation)
def infer(node: Node): return eltwise_infer(node, lambda x, negative_slope: LeakyReLU.leaky_relu(x, negative_slope), negative_slope=node.negative_slope)
def infer(cls, node: Node): return eltwise_infer(node, lambda x, alpha: ThresholdedRelu.thresholded_relu(x, alpha), alpha=node.alpha)
def infer(cls, node: Node): return eltwise_infer(node, lambda x, alpha: Elu.elu(x, alpha), alpha=node.alpha)
const_value = np.random.rand(1, 3, 30, 30) nodes_attributes = {'input': {'shape': int64_array([1, 3, 30, 30]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'input_data': {'value': None, 'shape': int64_array([1, 3, 30, 30]), 'kind': 'data'}, 'const': {'type': 'Const', 'kind': 'op', 'op': 'Const', 'value': const_value}, 'const_data': {'kind': 'data', 'value': const_value}, 'shapeof_input': {'kind': 'op', 'op': 'ShapeOf', 'value': int64_array([1, 3, 30, 30])}, 'shapeof_input_data': {'value': None, 'shape': None, 'kind': 'data', 'value': int64_array([1, 3, 30, 30])}, 'shapeof_const': {'kind': 'op', 'op': 'ShapeOf', 'value': int64_array([1, 3, 30, 30])}, 'shapeof_const_data': {'value': None, 'shape': None, 'kind': 'data', 'value': int64_array([1, 3, 30, 30])}, 'mul': {'kind': 'op', 'op': 'Mul', 'infer': lambda node: eltwise_infer(node, lambda a, b: a * b)}, 'mul_data': {'kind': 'data', 'value': np.array([1, 9, 900, 900])}, 'last': {'kind': 'op', 'op': 'Result'}, # new nodes 'new_const_shapeof': {'type': 'Const', 'kind': 'op', 'op': 'Const', 'value': int64_array([1, 3, 30, 30])} } const_value2 = np.random.rand(30, 30) nodes_attributes2 = {'input': {'shape': int64_array([1, 3, 30, 30]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'input_data': {'value': None, 'shape': int64_array([1, 3, 30, 30]), 'kind': 'data'}, 'const': {'type': 'Const', 'kind': 'op', 'op': 'Const', 'value': const_value2}, 'const_data': {'kind': 'data', 'value': const_value2},
'kind': 'data', 'shape': None }, 'mul_val': { 'kind': 'op', 'op': 'Const' }, 'mul_val_d': { 'kind': 'data', 'shape': np.array([1]), 'value': np.array([5]) }, 'mul': { 'kind': 'op', 'op': 'Mul', 'infer': lambda node: eltwise_infer(node, lambda a, b: a * b) }, 'mul_d': { 'kind': 'data', 'shape': np.array([1, 3, 224, 224]), 'value': None }, 'mul_1': { 'kind': 'op', 'op': 'Mul', 'infer': lambda node: eltwise_infer(node, lambda a, b: a * b) }, 'mul_1_d': { 'kind': 'data', 'shape': np.array([1, 3, 224, 224]), 'value': None