def test_transform_with_featurewise_mean_fit_not_called(self):
#Arrange
images = TestImageDataTransformation.get_featurewise_mean_examples()
#Transformation object
parameters = ImageDataTransformation.Parameters(featurewise_mean = True)
transformation = ImageDataTransformation(parameters = parameters)
with self.assertRaises(ValueError):
transformation.transform(images)
class Instance(object):
"""It executes a transformation instance.
"""
def __init__(self, transformation_params, num_output_images=1):
"""It initializes the augmentation parameters.
Arguments:
transformation_params {A ImageDataTransformation.Parameters object} -- The transformation parameters.
num_output_images {int} -- The number of transformed images.
"""
#Required parameters
self._transformation_params = transformation_params
self._num_output_images = num_output_images
#Validation
if self._transformation_params is None:
raise ValueError('transformation_params must be valid')
#Derived parameters
self._transformer = ImageDataTransformation(
self._transformation_params)
def augmentations(self, image_objs):
"""It executes the tranformations to produce output images.
Arguments:
image_objs {A numpy array} -- The input image to be transformed.
Returns:
{A numpy array} - The list of output images.
"""
#Output images placeholder
output_image_objs = []
#Generate the required number of the transformed images
for _ in range(self._num_output_images):
#Transform
transformed_image_obj = self._transformer.transform(image_objs)
#Add to the list of output images
output_image_objs.append(transformed_image_obj)
#Convert to numpy array
augmented_images = np.concatenate(output_image_objs, axis=0)
return augmented_images
def __str__(self):
return """Parameters::
transformation_params: {}
num_output_images: {}""".format(
self._transformation_params, self._num_output_images)
def __len__(self):
return self._num_output_images
def transform_featurewise_std_normalization(self, featurewise_std_normalization, images, result):
#Transformation object
parameters = ImageDataTransformation.Parameters(featurewise_std_normalization = featurewise_std_normalization)
transformation = ImageDataTransformation(parameters = parameters)
#Fit and perform transformation
transformation.fit(images)
transformed_images = transformation.transform(images)
transformed_std = transformed_images.std(axis = 0)
#Assert
self.assertTrue(np.allclose(transformed_std, result))
def transform_horizontal_flip(self, horizontal_flip, images, results):
#Transformation object
parameters = ImageDataTransformation.Parameters(horizontal_flip = horizontal_flip, horizontal_flip_prob = 1.0)
transformation = ImageDataTransformation(parameters = parameters)
#Transform
transformed_images = transformation.transform(images)
#Assert
self.assertTrue(
np.array_equal(transformed_images, results),
"transformed_images: {} != expected: {}".format(transformed_images, results))
def transform_samplewise_mean(self, samplewise_mean, images, results):
#Transformation object
parameters = ImageDataTransformation.Parameters(samplewise_mean = samplewise_mean)
transformation = ImageDataTransformation(parameters = parameters)
#Transform
transformed_images = transformation.transform(images)
#Assert
self.assertTrue(
np.array_equal(transformed_images, results),
"transformed_images: {} != expected: {}".format(transformed_images, results))
def transform_affine(self, parameters):
#Image dataset
images = np.random.rand(5, 50, 50, 3)
#Transformation object
transformation = ImageDataTransformation(parameters = parameters)
no_transformation = ImageDataTransformation()
#Act
transformed_images = transformation.transform(images)
no_transformed_images = no_transformation.transform(images)
#No transformation assertions
np.testing.assert_array_almost_equal(
no_transformed_images,
images,
err_msg = "Unexpected transformation for parameters: {}".format(parameters))
#Transformation assertions
self.assertFalse(
np.array_equal(transformed_images, images),
"Expected rotation transformation for parameters: {}".format(parameters))
def transform_featurewise_mean(self, featurewise_mean, images, result):
#Transformation object
parameters = ImageDataTransformation.Parameters(featurewise_mean = featurewise_mean)
transformation = ImageDataTransformation(parameters = parameters)
#Fit and perform transformation
transformation.fit(images)
transformed_images = transformation.transform(images)
sum_image = transformed_images.sum(axis = 0)
#Assert
self.assertTrue(
np.array_equal(sum_image, result),
"Sum images: {} expected: {}".format(sum_image, result))
def transform_samplewise_std_normalization(self, samplewise_std_normalization, images):
#Transformation object
parameters = ImageDataTransformation.Parameters(samplewise_std_normalization = samplewise_std_normalization)
transformation = ImageDataTransformation(parameters = parameters)
#Transform
transformed_images = transformation.transform(images)
#Compute standard deviation
standard_deviations = np.std(transformed_images, axis = (1, 2, 3))
#Assert
if samplewise_std_normalization:
self.assertAlmostEqual(
np.sum(standard_deviations),
2.,
places = 2,
msg = "standard_deviations: {} != expected: 2.".format(standard_deviations))
else:
self.assertNotEqual(np.sum(standard_deviations), 2.)