def test_custom_normalization_with_std(self):
normalization = Preprocessor.provide('normalization', {
'type': 'normalization',
'std': '(1, 2, 3)'
})
source = np.full_like((3, 300, 300), 100)
input_ref = source.copy() / (1, 2, 3)
result = normalization(DataRepresentation(source))
assert normalization.mean is None
assert normalization.std == (1, 2, 3)
assert np.all(input_ref == result.data)
assert result.metadata == {'image_size': (3, )}
def test_custom_normalization_with_mean_as_scalar(self):
normalization = Preprocessor.provide('normalization', {
'type': 'normalization',
'mean': '1'
})
source = np.full_like((3, 300, 300), 100)
input_ref = source.copy() - 1
result = normalization(DataRepresentation(source))
assert normalization.mean == (1.0, )
assert normalization.std is None
assert np.all(input_ref == result.data)
assert result.metadata == {'image_size': (3, )}
def test_custom_normalization_with_precomputed_mean(self):
normalization = Preprocessor.provide('normalization', {
'type': 'normalization',
'mean': 'cifar10'
})
source = np.full_like((3, 300, 300), 100)
input_ref = source.copy() - normalization.PRECOMPUTED_MEANS['cifar10']
result = normalization(DataRepresentation(source))
assert normalization.mean == normalization.PRECOMPUTED_MEANS['cifar10']
assert normalization.std is None
assert np.all(input_ref == result.data)
assert result.metadata == {'image_size': (3, )}
def test_resize_with_both_provided_size_and_dst_height_dst_width_warn(
self):
input_image = np.ones((100, 50, 3))
with pytest.warns(None) as warnings:
resize = Preprocessor.provide('resize', {
'type': 'resize',
'dst_width': 100,
'dst_height': 100,
'size': 200
})
assert len(warnings) == 1
result = resize(DataRepresentation(input_image)).data
assert result.shape == (200, 200, 3)
def test_custom_normalization_with_mean_and_std_as_scalars(self):
normalization = Preprocessor.provide('normalization', {
'type': 'normalization',
'mean': '2',
'std': '5'
})
input_ = np.full_like((300, 300, 3), 100)
input_ref = (input_ - (2, )) / (5, )
result = normalization(DataRepresentation(input_))
assert normalization.mean == (2, )
assert normalization.std == (5, )
assert np.all(input_ref == result.data)
assert result.metadata == {'image_size': (3, )}
def test_custom_normalization_with_mean_and_std(self):
normalization = Preprocessor.provide('normalization', {
'type': 'normalization',
'mean': '(1, 2, 3)',
'std': '(4, 5, 6)'
})
input_ = np.full_like((3, 300, 300), 100)
input_ref = (input_ - (1, 2, 3)) / (4, 5, 6)
result = normalization(DataRepresentation(input_))
assert normalization.mean == (1, 2, 3)
assert normalization.std == (4, 5, 6)
assert np.all(input_ref == result.data)
assert result.metadata == {'image_size': (3, )}
def test_custom_normalization_multi_input(self):
normalization = Preprocessor.provide('normalization', {
'type': 'normalization',
'mean': '2',
'std': '2'
})
source = np.full_like((300, 300, 3), 100)
input_ref = (source.copy() - 2) / 2
result = normalization(DataRepresentation([source, source]))
assert normalization.mean == (2, )
assert normalization.std == (2, )
assert len(result.data) == 2
assert np.all(input_ref == result.data[0])
assert np.all(input_ref == result.data[1])
assert result.metadata == {'image_size': (3, )}
def test_custom_normalization_with_mean_and_std(self):
name = 'mock_preprocessor'
config = {
'type': 'normalization',
'mean': '(1, 2, 3)',
'std': '(4, 5, 6)'
}
normalization = Preprocessor.provide('normalization', config, name)
input_ = np.full_like((3, 300, 300), 100)
input_ref = (input_ - (1, 2, 3)) / (4, 5, 6)
res = normalization(input_)
assert normalization.mean == (1, 2, 3)
assert normalization.std == (4, 5, 6)
assert np.all(input_ref == res)
def test_default_resize(self, mocker):
cv2_resize_mock = mocker.patch(
'accuracy_checker.preprocessor.preprocessors.cv2.resize')
name = 'mock_preprocessor'
config = {'type': 'resize', 'size': 200}
resize = Preprocessor.provide('resize', config, name)
input_mock = mocker.Mock()
resize(input_mock)
assert not resize.use_pil
assert resize.dst_width == 200
assert resize.dst_height == 200
cv2_resize_mock.assert_called_once_with(
input_mock, (200, 200),
interpolation=Resize.OPENCV_INTERPOLATION['LINEAR'])
def test_default_resize(self, mocker):
cv2_resize_mock = mocker.patch(
'accuracy_checker.preprocessor.preprocessors.cv2.resize')
resize = Preprocessor.provide('resize', {
'type': 'resize',
'size': 200
})
input_mock = mocker.Mock()
input_mock.shape = (480, 640, 3)
resize(DataRepresentation(input_mock))
assert resize.dst_width == 200
assert resize.dst_height == 200
cv2_resize_mock.assert_called_once_with(
input_mock, (200, 200),
interpolation=_OpenCVResizer.supported_interpolations['LINEAR'])
def test_custom_resize(self, mocker):
cv2_resize_mock = mocker.patch('accuracy_checker.preprocessor.geometric_transformations.cv2.resize')
resize = Preprocessor.provide(
'resize', {'type': 'resize', 'dst_width': 126, 'dst_height': 128, 'interpolation': 'CUBIC'}
)
input_mock = mocker.Mock()
input_mock.shape = (480, 640, 3)
resize(DataRepresentation(input_mock))
assert resize.dst_width == 126
assert resize.dst_height == 128
cv2_resize_mock.assert_called_once_with(
input_mock, (126, 128),
interpolation=_OpenCVResizer.supported_interpolations()['CUBIC']
)
def test_custom_resize(self, mocker):
cv2_resize_mock = mocker.patch('accuracy_checker.preprocessor.preprocessors.cv2.resize')
name = 'mock_preprocessor'
config = {
'type': 'resize',
'dst_width': 126,
'dst_height': 128,
'interpolation': 'CUBIC'
}
resize = Preprocessor.provide('resize', config, name)
input_mock = mocker.Mock()
resize(DataRepresentation(input_mock))
assert not resize.use_pil
assert resize.dst_width == 126
assert resize.dst_height == 128
cv2_resize_mock.assert_called_once_with(input_mock, (126, 128),
interpolation=Resize.OPENCV_INTERPOLATION['CUBIC'])
def test_resize_save_aspect_ratio_frcnn_keep_aspect_ratio(self):
input_image = np.ones((480, 640, 3))
resize = Preprocessor.provide(
'resize', {
'type': 'resize',
'dst_width': 100,
'dst_height': 150,
'aspect_ratio_scale': 'frcnn_keep_aspect_ratio'
})
result = resize(DataRepresentation(input_image))
assert result.data.shape == (100, 133, 3)
assert result.metadata == {
'geometric_operations': [
GeometricOperationMetadata(type='resize',
parameters={
'scale_x': 0.2078125,
'scale_y': 0.20833333333333334,
'image_info': [100, 133, 1],
'original_width': 640,
'original_height': 480,
'preferable_width': 133,
'preferable_height': 150
})
],
'image_info': [100, 133, 1],
'image_size': (480, 640, 3),
'original_height':
480,
'original_width':
640,
'preferable_height':
150,
'preferable_width':
133,
'scale_x':
0.2078125,
'scale_y':
0.20833333333333334
}
def test_default_auto_resize(self, mocker):
cv2_resize_mock = mocker.patch('accuracy_checker.preprocessor.geometric_transformations.cv2.resize')
resize = Preprocessor.provide('auto_resize', {'type': 'auto_resize'})
resize.set_input_shape({'data': (1, 3, 200, 200)})
input_data = np.zeros((100, 100, 3))
input_rep = DataRepresentation(input_data)
expected_meta = {
'preferable_width': 200,
'preferable_height':200,
'image_info': [200, 200, 1],
'scale_x': 2.0,
'scale_y': 2.0,
'original_width': 100,
'original_height': 100,
}
resize(input_rep)
assert resize.dst_width == 200
assert resize.dst_height == 200
cv2_resize_mock.assert_called_once_with(input_data, (200, 200))
for key, value in expected_meta.items():
assert key in input_rep.metadata
assert input_rep.metadata[key] == value
def test_auto_resize_input_shape_not_provided_raise_config_error(
self, mocker):
input_mock = mocker.Mock()
with pytest.raises(ConfigError):
Preprocessor.provide('auto_resize', {'type': 'auto_resize'})(
DataRepresentation(input_mock))
def test_resize_provided_only_dst_width_raise_config_error(self):
with pytest.raises(ValueError):
Preprocessor.provide('resize', {
'type': 'resize',
'dst_width': 100
})
def test_resize_to_negative_size_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide('resize', {'type': 'resize', 'size': -100})
def test_point_alignment_raise_config_error_on_extra_args(self):
with pytest.raises(ConfigError):
Preprocessor.provide('point_alignment', {
'type': 'point_alignment',
'something_extra': 'extra'
})
def test_auto_resize_input_shape_not_provided_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide('auto_resize', {'type': 'auto_resize'})
def test_normalization_without_mean_and_std_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide('normalization', {'type': 'normalization'})
def test_normalization_raise_config_error_on_extra_args(self):
preprocessor_config = {'type': 'normalization', 'mean': 0, 'something_extra': 'extra'}
with pytest.raises(ConfigError):
Preprocessor.provide('normalization', preprocessor_config)
def test_resize_raise_config_error_on_extra_args(self):
preprocessor_config = {'type': 'resize', 'size': 1, 'something_extra': 'extra'}
with pytest.raises(ConfigError):
Preprocessor.provide('resize', preprocessor_config)
def test_auto_resize_with_non_image_input_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide('auto_resize', {
'type': 'auto_resize'
}).set_input_shape({'im_info': [200, 200, 1]})
def test_flip_raise_config_error_on_extra_args(self):
with pytest.raises(ConfigError):
Preprocessor.provide('flip', {
'type': 'flip',
'something_extra': 'extra'
})
def test_auto_resize_empty_input_shapes_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide('auto_resize', {
'type': 'auto_resize'
}).set_input_shape({})
def test_extend_around_rect_raise_config_error_on_extra_args(self):
with pytest.raises(ConfigError):
Preprocessor.provide('extend_around_rect', {
'type': 'extend_around_rect',
'something_extra': 'extra'
})
def test_bgr_to_rgb_raise_config_error_on_extra_args(self):
preprocessor_config = {'type': 'bgr_to_rgb', 'something_extra': 'extra'}
with pytest.raises(ConfigError):
Preprocessor.provide('bgr_to_rgb', preprocessor_config, None)
def test_resize_save_aspect_ratio_unknown_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide(
'resize', {'type': 'resize', 'dst_width': 100, 'dst_height': 150, 'aspect_ratio_scale': 'unknown'}
)
def test_normalization_with_zero_as_std_value_raise_config_error(self):
with pytest.raises(ConfigError):
Preprocessor.provide('normalization', {
'type': 'normalization',
'std': '0'
})
def test_crop_accuracy_raise_config_error_on_extra_args(self):
preprocessor_config = {'type': 'crop', 'size': 1, 'something_extra': 'extra'}
with pytest.raises(ConfigError):
Preprocessor.provide('crop', preprocessor_config, None)
