def test_reogyolo_ext_ideal_numbers(self, merge_attrs_mock): params = { 'coords': 4, 'classes': 20, 'num': 5, 'do_softmax': 1, 'anchors': 5, 'mask': 5, } params_flatten = {'axis': 1, 'end_axis': -1} merge_attrs_mock.return_value = {**params, **params_flatten} fake_pl = FakeRegionYoloProtoLayer(FakeMultiParam(params), FakeMultiParam(params_flatten)) fake_node = FakeNode(fake_pl, None) RegionYoloFrontExtractor.extract(fake_node) exp_res = { 'type': "RegionYolo", 'coords': 4, 'classes': 20, 'num': 5, 'axis': 1, 'end_axis': -1, 'do_softmax': 1, 'anchors': 5, 'mask': 5, 'infer': RegionYoloOp.regionyolo_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_check_phase_no_phase(self): phase_param = {} include_param = {'include': [FakeMultiParam(phase_param)]} graph = build_graph(nodes_attributes, [('node_1', 'node_2')], {'node_1': { 'pb': FakeMultiParam(include_param) }}) node = Node(graph, 'node_1') res = check_phase(node) exp_res = {} self.assertEqual(res, exp_res)
def test_argmax_ext_ideal_numbers(self, merge_attrs_mock): params = { 'out_max_val': True, 'top_k': 100, 'axis': 2 } merge_attrs_mock.return_value = { **params } fake_pl = FakeArgMaxProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) ArgMaxFrontExtractor.extract(fake_node) exp_res = { 'out_max_val': True, 'top_k': 100, 'axis': 2, 'infer': ArgMaxOp.argmax_infer, 'remove_values_output': True, } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_crop_ext(self, collect_attributes_mock): params = { 'axis': 0, 'offset': 0, } collect_attributes_mock.return_value = { **params, 'test': 54, 'test2': 'test3' } fake_pl = FakeCropProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) CropFrontExtractor.extract(fake_node) exp_res = { 'type': 'Crop', 'axis': 0, 'offset': 0, 'dim': None, # set in infer 'infer': crop_infer } for key in exp_res.keys(): self.assertEqual(exp_res[key], fake_node[key])
def test_pooling_ext(self): params = { 'kernel_size': 1, 'stride': 2, 'pad': 3, 'pool': 1, 'global_pooling': 0, 'ceil_mode': 0 } node = PB({'pb': FakeProtoLayer(FakeMultiParam(params))}) PoolingFrontExtractor.extract(node) res = node exp_res = { 'window': np.array([1, 1, 1, 1], dtype=np.int64), 'stride': np.array([1, 1, 2, 2], dtype=np.int64), 'pad': np.array([[0, 0], [0, 0], [3, 3], [3, 3]], dtype=np.int64), 'pad_spatial_shape': np.array([[3, 3], [3, 3]], dtype=np.int64), 'pool_method': 'avg', 'exclude_pad': 'false', 'infer': Pooling.infer, 'global_pool': 0, 'output_spatial_shape': None, 'pooling_convention': 'valid' } exp_res.update(layout_attrs()) for i in exp_res.keys(): if i in ('window', 'stride', 'pad', 'pad_spatial_shape', 'spatial_dims', 'batch_dims', 'channel_dims'): np.testing.assert_array_equal(res[i], exp_res[i]) else: self.assertEqual(res[i], exp_res[i])
def test_normalize_ext_ideal_numbers(self, collect_attributes_mock): params = { 'across_spatial': 1, 'channel_shared': 0, 'eps': 0.00001 } collect_attributes_mock.return_value = { **params } fake_pl = FakeNormalizeProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) NormalizeFrontExtractor.extract(fake_node) exp_res = { 'type': "Normalize", 'across_spatial': 1, 'channel_shared': 0, 'eps': 0.00001, 'infer': copy_shape_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_conv_ext_ideal_numbers(self, weights_biases_mock, layout_attrs_mock): weights_biases_mock.return_value = {} layout_attrs_mock.return_value = {} params = { 'pad': 10, 'kernel_size': 11, 'stride': 12, 'dilation': 13, 'group': 14, 'num_output': 15, 'bias_term': True } node = PB({'pb': FakeConvProtoLayer(FakeMultiParam(params))}) ConvFrontExtractor.extract(node) res = node exp_res = { 'op': 'Conv2D', 'pad': np.array([[0, 0], [0, 0], [10, 10], [10, 10]]), 'pad_spatial_shape': np.array([[10, 10], [10, 10]]), 'stride': np.array([1, 1, 12, 12]), 'kernel_spatial': np.array([11, 11]), 'dilation': np.array([1, 1, 13, 13]), 'group': 14, 'bias_addable': True, 'bias_term': True, } self.assertTrue(weights_biases_mock.called) self.assertTrue(layout_attrs_mock.called) for key in exp_res.keys(): if key in ('pad', 'pad_spatial_shape', 'stride', 'kernel_spatial', 'dilation'): np.testing.assert_equal(res[key], exp_res[key]) else: self.assertEqual(res[key], exp_res[key])
def test_proposal_ext_scale(self): params = { 'param_str': "'feat_stride': 16, 'scale': [1,2,3], 'ratio':[5, 6,7]" } fake_pl = FakeProposalPythonProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) ProposalPythonFrontExtractor.extract(fake_node) exp_res = { 'type': "Proposal", 'feat_stride': 16, 'base_size': 16, 'min_size': 16, 'ratio': [5, 6, 7], 'scale': [1, 2, 3], 'pre_nms_topn': 6000, 'post_nms_topn': 300, 'nms_thresh': 0.7, 'infer': ProposalOp.proposal_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_params_creation(self): params = { 'pad': None, 'kernel_size': None, 'stride': None, 'dilation': None, 'group': 14, 'num_output': 15, 'bias_term': True, 'pad_w': 3, 'pad_h': 4, 'kernel_w': 5, 'kernel_h': 6, 'stride_h': 3, 'stride_w': 2, } exp_res = { 'padding': [3, 4], 'stride': [2, 3], 'kernel': [5, 6], 'dilate': [1, 1], 'group': 14, 'output': 15 } res = conv_set_params( FakeConvProtoLayer(FakeMultiParam(params)).convolution_param, 'Conv2D') for key in exp_res.keys(): if key in ('padding', 'stride', 'stride', 'kernel', 'dilate'): np.testing.assert_equal(res[key], exp_res[key]) else: self.assertEqual(res[key], exp_res[key])
def test_inner_product_ext(self): params = {'num_output': 10, 'bias_term': True} mean_blob = np.array([1., 2.]) variance_blob = np.array([3., 4.]) blobs = [mean_blob, variance_blob] res = inner_product_ext(FakeProtoLayer(FakeMultiParam(params)), FakeModelLayer(blobs)) exp_res = { 'type': 'FullyConnected', 'out-size': 10, 'infer': caffe_inner_product, 'weights': mean_blob, 'biases': variance_blob, 'embedded_inputs': [(1, 'weights', { 'bin': 'weights' }), (2, 'biases', { 'bin': 'biases' })] } for i in exp_res: if i in ('weights', 'biases'): np.testing.assert_array_equal(res[i], exp_res[i]) else: self.assertEqual(res[i], exp_res[i])
def test_accum_ext(self, collect_attributes_mock): params = { 'top_height': 200, 'top_width': 300, 'size_divisible_by': 3, 'have_reference': 'False', } collect_attributes_mock.return_value = {**params, 'have_reference': 0} fake_pl = FakeAccumProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) AccumFrontExtractor.extract(fake_node) exp_res = { 'type': "Accum", 'top_height': 200, 'top_width': 300, 'size_divisible_by': 3, 'have_reference': 0, 'infer': AccumOp.accum_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_proposal_ext_ideal_numbers(self, merge_attrs): params = { 'feat_stride': 1, 'base_size': 16, 'min_size': 16, 'ratio': 1, 'scale': 2, 'pre_nms_topn': 6000, 'post_nms_topn': 300, 'nms_thresh': 0.7 } merge_attrs.return_value = { **params } fake_pl = FakeProposalProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) ProposalFrontExtractor.extract(fake_node) exp_res = { 'type': "Proposal", 'feat_stride': 1, 'base_size': 16, 'min_size': 16, 'ratio': 1, 'scale': 2, 'pre_nms_topn': 6000, 'post_nms_topn': 300, 'nms_thresh': 0.7, 'infer': ProposalOp.proposal_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_build_net_not_equal_inputs(self): global my_mock_net input_node_param = { 'shape': np.array([1, 3, 112, 112]), 'reshape': MagicMock(return_value=134) } my_blobs = { 'node_1': FakeMultiParam(input_node_param), } my_mock_net = Net(my_blobs) graph = build_graph(self.nodes_attributes, [('node_1', 'node_3'), ('node_3', 'node_4'), ('node_4', 'op_output')], { 'node_4': { 'shape': None }, 'node_1': { 'shape': np.array([1, 3, 227, 227]) }, 'node_3': { 'top': 'top_node' } }, nodes_with_edges_only=True) graph.proto_path = 'path_to_proto' graph.caffemodel_path = 'path_to_proto' build_net(graph) my_mock_net.reshape.assert_called_once_with() my_mock_net.forward.assert_called_once_with() self.assertIsNotNone(graph.caffe_net)
def test_interp_ext_ideal_numbers(self, merge_attrs_mock): params = { 'height': 1.1, 'width': 2.2, 'zoom_factor': 3.3, 'shrink_factor': 4.4, 'pad_beg': 5.5, 'pad_end': 6.6 } merge_attrs_mock.return_value = { **params, 'test': 54, 'test2': 'test3' } fake_pl = FakeInterpProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) InterpFrontExtractor.extract(fake_node) exp_res = { 'type': "Interp", 'height': 1.1, 'width': 2.2, 'zoom_factor': 3.3, 'shrink_factor': 4.4, 'pad_beg': 5.5, 'pad_end': 6.6, 'infer': InterpOp.interp_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_create_default_weights(self): """ There are situations when scale layer doesn't have weights and biases. This test checks that if they are not available in the caffemodel file then default values [1] and [0] are generated. """ scale_blob = np.array([1]) bias_blob = np.array([0]) params = {'type': 'Scale', 'axis': 0, 'bias_term': True} res = scale_ext(FakeProtoLayer(FakeMultiParam(params)), None) exp_res = { 'op': 'ScaleShift', 'type': 'ScaleShift', 'axis': 0, 'infer': copy_shape_infer, 'weights': scale_blob, 'biases': bias_blob, 'embedded_inputs': [(1, 'weights', { 'bin': 'weights' }), (2, 'biases', { 'bin': 'biases' })] } self.assertDictEqual(exp_res, res)
def test_scale_ext(self): mean_blob = np.array([1., 2.]) variance_blob = np.array([3., 4.]) blobs = [mean_blob, variance_blob] params = {'type': 'Scale', 'axis': 0, 'bias_term': True} res = scale_ext(FakeProtoLayer(FakeMultiParam(params)), FakeModelLayer(blobs)) exp_res = { 'op': 'ScaleShift', 'type': 'ScaleShift', 'axis': 0, 'infer': copy_shape_infer, 'weights': mean_blob, 'biases': variance_blob, 'embedded_inputs': [(1, 'weights', { 'bin': 'weights' }), (2, 'biases', { 'bin': 'biases' })] } for i in exp_res: if i in ('weights', 'biases'): np.testing.assert_array_equal(res[i], exp_res[i]) else: self.assertEqual(res[i], exp_res[i])
def test_simplernms_ext_ideal_numbers(self, merge_attrs_mock): params = { 'cls_threshold': 0.5, 'max_num_proposals': 300, 'iou_threshold': 0.7, 'min_bbox_size': 16, 'feat_stride': 16, 'pre_nms_topn': 6000, 'post_nms_topn': 150, 'scale': [1, 2, 3] } merge_attrs_mock.return_value = {**params} fake_pl = FakeSimplerNMSProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) SimplerNMSFrontExtractor.extract(fake_node) exp_res = { 'cls_threshold': 0.5, 'max_num_proposals': 300, 'iou_threshold': 0.7, 'min_bbox_size': 16, 'feat_stride': 16, 'pre_nms_topn': 6000, 'post_nms_topn': 150, 'scale': [1, 2, 3], 'infer': SimplerNMSOp.simplernms_infer } for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_resample_ext_ideal_numbers(self, merge_attrs_mock): params = { 'antialias': True, 'height': 384, 'width': 512, 'type': 2, 'factor': 1.0, } merge_attrs_mock.return_value = { 'antialias': True, 'height': 384, 'width': 512, 'type': 'caffe.ResampleParameter.LINEAR', 'factor': 1.0, } fake_pl = FakeResampleProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) ResampleFrontExtractor.extract(fake_node) exp_res = { 'op': 'Resample', 'antialias': 1, 'height': 384, 'width': 512, 'resample_type': 'caffe.ResampleParameter.LINEAR', 'factor': 1.0, 'infer': ResampleOp.resample_infer } for key in exp_res.keys(): self.assertEqual(exp_res[key], fake_node[key])
def test_pooling_ext_exception(self): params = { 'kernel_size': 1, 'stride': 2, 'pad': 3, 'pool': 3, 'global_pooling': 1 } node = PB({'pb': FakeProtoLayer(FakeMultiParam(params))}) self.assertRaises(ValueError, PoolingFrontExtractor.extract, node)
def test_python_extractor_for_extractors(self): module = 'test_module' layer = 'test_layer' CaffePythonFrontExtractorOp.registered_ops['{}.{}'.format(module, layer)] = FakePythonExtractor params = FakeMultiParam({ 'module': module, 'layer': layer, 'param_str': "'feat_stride': 16" }) self.assertTrue(PythonFrontExtractorOp.extract(FakeNode(FakePythonProtoLayer(params), None)))
def test_bias(self, embed_input_mock): embed_input_mock.return_value = {} params = {'axis': 1} add_node = FakeNode(FakeBiasProtoLayer(FakeMultiParam(params)), FakeModelLayer([1, 2, 3, 4, 5])) BiasToAdd.extract(add_node) exp_res = {'type': "Add", 'axis': 1} for key in exp_res.keys(): self.assertEqual(add_node[key], exp_res[key])
def test_python_extractor_for_op(self): module = 'test_module' layer = 'test_layer' CaffePythonFrontExtractorOp.registered_ops['{}.{}'.format(module, layer)] = \ lambda node: CaffePythonFrontExtractorOp.parse_param_str(node.pb.python_param.param_str) params = FakeMultiParam({ 'module': module, 'layer': layer, 'param_str': "'feat_stride': 16" }) ext = PythonFrontExtractorOp.extract(FakeNode(FakePythonProtoLayer(params), None)) self.assertEqual({'feat_stride': 16}, ext)
def test_scale_2inputs_ext(self): params = {'type': 'Scale', 'axis': 0, 'bias_term': False} res = scale_ext(FakeProtoLayer(FakeMultiParam(params), True), None) exp_res = { 'op': 'ScaleShift', 'type': 'ScaleShift', 'axis': 0, 'infer': copy_shape_infer, } for i in exp_res: self.assertEqual(res[i], exp_res[i])
def test_da_ext_ideal_numbers(self, merge_attrs_mock): params = { 'crop_width': 0, 'crop_height': 0, 'write_augmented': "", 'max_multiplier': 255.0, 'augment_during_test': True, 'recompute_mean': 0, 'write_mean': "", 'mean_per_pixel': False, 'mean': 0, 'mode': "add", 'bottomwidth': 0, 'bottomheight': 0, 'num': 0, 'chromatic_eigvec': [0.0] } merge_attrs_mock.return_value = { **params, 'test': 54, 'test2': 'test3' } fake_pl = FakeDAProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) DataAugmentationFrontExtractor.extract(fake_node) exp_res = { 'type': 'DataAugmentation', 'op': 'DataAugmentation', 'crop_width': 0, 'crop_height': 0, 'write_augmented': "", 'max_multiplier': 255.0, 'augment_during_test': 1, 'recompute_mean': 0, 'write_mean': "", 'mean_per_pixel': 0, 'mean': 0, 'mode': "add", 'bottomwidth': 0, 'bottomheight': 0, 'num': 0, 'chromatic_eigvec': [0.0], 'infer': DataAugmentationOp.data_augmentation_infer } for key in exp_res.keys(): if key in ('chromatic_eigvec',): np.testing.assert_equal(exp_res[key], fake_node[key]) else: self.assertEqual(exp_res[key], fake_node[key])
def test_lrn_ext_norm_reg(self): params = {'alpha': 10, 'beta': 15, 'local_size': 20, 'norm_region': 1} res = lrn_ext(FakeProtoLayer(FakeMultiParam(params)), None) exp_res = { 'op': 'LRN', 'type': 'Norm', 'alpha': 10, 'beta': 15, 'local_size': 20, 'region': 'same', 'infer': copy_shape_infer } self.assertEqual(res, exp_res)
def test_power_ext(self): params = {'power': 1, 'scale': 2, 'shift': 3} res = power_ext(FakeProtoLayer(FakeMultiParam(params)), None) exp_res = { 'power': 1, 'scale': 2, 'shift': 3, 'infer': copy_shape_infer, 'op': "Power", 'type': 'Power', 'output_spatial_shape': None, } self.assertEqual(res, exp_res)
def test_grn_ext_ideal_numbers(self, merge_attrs_mock): params = {'bias': 0.7} merge_attrs_mock.return_value = {**params} fake_pl = FakeGRNProtoLayer(FakeMultiParam(params)) fake_node = FakeNode(fake_pl, None) GRNFrontExtractor.extract(fake_node) exp_res = {'type': "GRN", 'bias': 0.7, 'infer': copy_shape_infer} for key in exp_res.keys(): self.assertEqual(fake_node[key], exp_res[key])
def test_elu_ext(self, collect_attrs_mock): params = {'alpha': 4} collect_attrs_mock.return_value = { **params, 'test': 54, 'test2': 'test3' } fn = FakeNode(FakeProtoLayer(FakeMultiParam(params)), None) ELUFrontExtractor.extract(fn) exp_res = {'type': 'Elu', 'alpha': 4} for i in exp_res: self.assertEqual(fn[i], exp_res[i])
def test_permute_check_attrs(self): attrs = {'order': np.array([0, 1, 3, 2])} res = permute_ext(FakePermuteProtoLayer(FakeMultiParam(attrs)), None) exp_attrs = { 'type': 'Permute', 'op': 'Permute', 'order': np.array([0, 1, 3, 2]), 'infer': transpose_infer } for key in exp_attrs.keys(): if key == 'order': np.testing.assert_equal(res[key], exp_attrs[key]) else: self.assertEqual(res[key], exp_attrs[key])
def test_relu_ext(self): params = { 'negative_slope': 0.1, } res = relu_ext(FakeParam('relu_param', FakeMultiParam(params)), None) exp_res = { 'negative_slope': 0.1, 'infer': copy_shape_infer, } exp_res.update(layout_attrs()) for i in exp_res.keys(): if i == 'negative_slope': self.assertEqual(res[i], exp_res[i]) else: np.testing.assert_array_equal(res[i], exp_res[i])