Python源码示例：imgaug.augmenters.Multiply()
示例1
def _load_augmentation_aug_non_geometric():
return iaa.Sequential([
iaa.Sometimes(0.3, iaa.Multiply((0.5, 1.5), per_channel=0.5)),
iaa.Sometimes(0.2, iaa.JpegCompression(compression=(70, 99))),
iaa.Sometimes(0.2, iaa.GaussianBlur(sigma=(0, 3.0))),
iaa.Sometimes(0.2, iaa.MotionBlur(k=15, angle=[-45, 45])),
iaa.Sometimes(0.2, iaa.MultiplyHue((0.5, 1.5))),
iaa.Sometimes(0.2, iaa.MultiplySaturation((0.5, 1.5))),
iaa.Sometimes(0.34, iaa.MultiplyHueAndSaturation((0.5, 1.5),
per_channel=True)),
iaa.Sometimes(0.34, iaa.Grayscale(alpha=(0.0, 1.0))),
iaa.Sometimes(0.2, iaa.ChangeColorTemperature((1100, 10000))),
iaa.Sometimes(0.1, iaa.GammaContrast((0.5, 2.0))),
iaa.Sometimes(0.2, iaa.SigmoidContrast(gain=(3, 10),
cutoff=(0.4, 0.6))),
iaa.Sometimes(0.1, iaa.CLAHE()),
iaa.Sometimes(0.1, iaa.HistogramEqualization()),
iaa.Sometimes(0.2, iaa.LinearContrast((0.5, 2.0), per_channel=0.5)),
iaa.Sometimes(0.1, iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)))
])
示例2
def test_single_image(self):
image = np.full((10, 10, 3), 255, dtype=np.uint8)
bbs = [ia.BoundingBox(x1=1, y1=1, x2=5, y2=5, label="bb1"),
ia.BoundingBox(x1=-3, y1=4, x2=20, y2=8, label="bb2")]
aug = iaa.BlendAlphaBoundingBoxes(
["bb1"],
nb_sample_labels=1,
foreground=iaa.Multiply(0.0)
)
image_aug, segmap_aug = aug(image=image,
bounding_boxes=[bbs])
assert np.allclose(image_aug[1:5, 1:5, :], 0, rtol=0, atol=1.01)
assert np.allclose(image_aug[0:1, 0:1, :], 255, rtol=0, atol=1.01)
assert np.allclose(image_aug[5:10, 5:10, :], 255, rtol=0, atol=1.01)
示例3
def test_zero_sized_axes(self):
shapes = [
(0, 0),
(0, 1),
(1, 0),
(0, 1, 0),
(1, 0, 0),
(0, 1, 1),
(1, 0, 1)
]
for shape in shapes:
with self.subTest(shape=shape):
image = np.full(shape, 255, dtype=np.uint8)
bbs = [ia.BoundingBox(x1=1, y1=1, x2=5, y2=5, label="bb1"),
ia.BoundingBox(x1=-3, y1=4, x2=20, y2=8, label="bb2")]
aug = iaa.BlendAlphaBoundingBoxes(
["bb1"],
foreground=iaa.Multiply(0.0))
image_aug, segmap_aug = aug(
image=image, bounding_boxes=[bbs])
assert image_aug.dtype.name == "uint8"
assert image_aug.shape == shape
示例4
def test_returns_correct_objects__mul_hue_and_mul_saturation(self):
aug = iaa.MultiplyHueAndSaturation(mul_hue=(0.9, 1.1),
mul_saturation=(0.8, 1.2))
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 2
assert isinstance(aug.children[0], iaa.WithChannels)
assert aug.children[0].channels == [0]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[0].children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[0].children[0].mul,
iap.Uniform)
assert np.isclose(aug.children[0].children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].children[0].mul.b.value, 1.1)
assert isinstance(aug.children[1], iaa.WithChannels)
assert aug.children[1].channels == [1]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[1].children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[1].children[0].mul,
iap.Uniform)
assert np.isclose(aug.children[1].children[0].mul.a.value, 0.8)
assert np.isclose(aug.children[1].children[0].mul.b.value, 1.2)
示例5
def test_returns_correct_class(self):
# this test is practically identical to
# TestMultiplyToHueAndSaturation
# .test_returns_correct_objects__mul_saturation
aug = iaa.MultiplySaturation((0.9, 1.1))
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 1
assert isinstance(aug.children[0], iaa.WithChannels)
assert aug.children[0].channels == [1]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[0].children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[0].children[0].mul,
iap.Uniform)
assert np.isclose(aug.children[0].children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].children[0].mul.b.value, 1.1)
示例6
def __init__(self):
self.seq = iaa.Sequential([
iaa.Sometimes(0.5, iaa.OneOf([
iaa.GaussianBlur((0, 3.0)), # blur images with a sigma between 0 and 3.0
iaa.AverageBlur(k=(2, 7)), # blur image using local means with kernel sizes between 2 and 7
iaa.MedianBlur(k=(3, 11)), # blur image using local medians with kernel sizes between 2 and 7
])),
iaa.Sometimes(0.5, iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5)),
iaa.Sometimes(0.5, iaa.Add((-10, 10), per_channel=0.5)),
iaa.Sometimes(0.5, iaa.AddToHueAndSaturation((-20, 20))),
iaa.Sometimes(0.5, iaa.FrequencyNoiseAlpha(
exponent=(-4, 0),
first=iaa.Multiply((0.5, 1.5), per_channel=True),
second=iaa.LinearContrast((0.5, 2.0))
)),
iaa.Sometimes(0.5, iaa.PiecewiseAffine(scale=(0.01, 0.05))),
iaa.Sometimes(0.5, iaa.PerspectiveTransform(scale=(0.01, 0.1)))
], random_order=True)
示例7
def __init__(self, augmentation_rate):
self.augs = iaa.Sometimes(
augmentation_rate,
iaa.SomeOf(
(4, 7),
[
iaa.Affine(rotate=(-10, 10)),
iaa.Fliplr(0.2),
iaa.AverageBlur(k=(2, 10)),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.75, 1.25), per_channel=0.5),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
iaa.Crop(px=(0, 20))
],
random_order=True
)
)
示例8
def augment(image, bbox):
x = random.randint(-50, 50)
y = random.randint(-50, 50)
aug = iaa.Sequential([iaa.Multiply(random.uniform(0.5, 1.5)),
iaa.AdditiveGaussianNoise(random.uniform(0.01, 0.1) * 255),
iaa.Affine(translate_px={"x": x, "y": y},
scale=random.uniform(0.5, 1.5),
rotate=random.uniform(-45, 45),
cval=(0, 255))])
bbs = ia.BoundingBoxesOnImage([ia.BoundingBox(x1=bbox[0], y1=bbox[1], x2=bbox[2], y2=bbox[3])], shape=image.shape)
aug = aug.to_deterministic()
image_aug = aug.augment_image(image)
bbs_aug = aug.augment_bounding_boxes([bbs])[0]
b = bbs_aug.bounding_boxes
bbs_aug = [b[0].x1, b[0].y1, b[0].x2, b[0].y2]
bbs_aug = np.asarray(bbs_aug)
bbs_aug[0] = bbs_aug[0] if bbs_aug[0] > 0 else 0
bbs_aug[1] = bbs_aug[1] if bbs_aug[1] > 0 else 0
bbs_aug[2] = bbs_aug[2] if bbs_aug[2] < size else size
bbs_aug[3] = bbs_aug[3] if bbs_aug[3] < size else size
return image_aug, bbs_aug
示例9
def augment(image, bbox):
x = random.randint(-60, 60)
y = random.randint(-60, 60)
aug = iaa.Sequential([iaa.AdditiveGaussianNoise(scale=random.uniform(.001, .01) * 255), # gaussian noise
iaa.Multiply(random.uniform(0.5, 1.5)), # brightness
iaa.Affine(translate_px={"x": x, "y": y}, # translation
scale=random.uniform(0.5, 1.5), # zoom in and out
rotate=random.uniform(-25, 25), # rotation
shear=random.uniform(-5, 5), # shear transformation
cval=(0, 255))]) # fill the empty space with color
aug.add(iaa.Salt(.001))
bbs = ia.BoundingBoxesOnImage([ia.BoundingBox(x1=bbox[0], y1=bbox[1], x2=bbox[2], y2=bbox[3])], shape=image.shape)
aug = aug.to_deterministic()
image_aug = aug.augment_image(image)
bbs_aug = aug.augment_bounding_boxes([bbs])[0]
b = bbs_aug.bounding_boxes
bbs_aug = [b[0].x1, b[0].y1, b[0].x2, b[0].y2]
bbs_aug = np.asarray(bbs_aug)
bbs_aug[0] = bbs_aug[0] if bbs_aug[0] > 0 else 0
bbs_aug[1] = bbs_aug[1] if bbs_aug[1] > 0 else 0
bbs_aug[2] = bbs_aug[2] if bbs_aug[2] < size else size
bbs_aug[3] = bbs_aug[3] if bbs_aug[3] < size else size
return image_aug, bbs_aug
示例10
def __init__(self):
self.imgaug_transform = iaa.Sequential(
[iaa.Multiply((1.5, 1.5), per_channel=False), iaa.Add((127, 127), per_channel=False)]
)
self.augmentor_pipeline = Pipeline()
self.augmentor_pipeline.add_operation(
Operations.RandomBrightness(probability=1, min_factor=1.5, max_factor=1.5)
)
self.augmentor_pipeline.add_operation(Operations.RandomContrast(probability=1, min_factor=1.5, max_factor=1.5))
self.solt_stream = slc.Stream(
[
slt.ImageRandomBrightness(p=1, brightness_range=(127, 127)),
slt.ImageRandomContrast(p=1, contrast_range=(1.5, 1.5)),
]
)
示例11
def __init__(self,data_dir, back_dir,
batch_size=50,gan=True,imsize=128,
res_x=640,res_y=480,
**kwargs):
'''
data_dir: Folder that contains cropped image+xyz
back_dir: Folder that contains random background images
batch_size: batch size for training
gan: if False, gt for GAN is not yielded
'''
self.data_dir = data_dir
self.back_dir = back_dir
self.imsize=imsize
self.batch_size = batch_size
self.gan = gan
self.backfiles = os.listdir(back_dir)
data_list = os.listdir(data_dir)
self.datafiles=[]
self.res_x=res_x
self.res_y=res_y
for file in data_list:
if(file.endswith(".npy")):
self.datafiles.append(file)
self.n_data = len(self.datafiles)
self.n_background = len(self.backfiles)
print("Total training views:", self.n_data)
self.seq_syn= iaa.Sequential([
iaa.WithChannels(0, iaa.Add((-15, 15))),
iaa.WithChannels(1, iaa.Add((-15, 15))),
iaa.WithChannels(2, iaa.Add((-15, 15))),
iaa.ContrastNormalization((0.8, 1.3)),
iaa.Multiply((0.8, 1.2),per_channel=0.5),
iaa.GaussianBlur(sigma=(0.0, 0.5)),
iaa.Sometimes(0.1, iaa.AdditiveGaussianNoise(scale=10, per_channel=True)),
iaa.Sometimes(0.5, iaa.ContrastNormalization((0.5, 2.2), per_channel=0.3)),
], random_order=True)
示例12
def mask_to_rle(image_id, mask, scores):
"Encodes instance masks to submission format."
assert mask.ndim == 3, "Mask must be [H, W, count]"
# If mask is empty, return line with image ID only
if mask.shape[-1] == 0:
return "{},".format(image_id)
# Remove mask overlaps
# Multiply each instance mask by its score order
# then take the maximum across the last dimension
order = np.argsort(scores)[::-1] + 1 # 1-based descending
mask = np.max(mask * np.reshape(order, [1, 1, -1]), -1)
# Loop over instance masks
lines = []
for o in order:
m = np.where(mask == o, 1, 0)
# Skip if empty
if m.sum() == 0.0:
continue
rle = rle_encode(m)
lines.append("{}, {}".format(image_id, rle))
return "\n".join(lines)
############################################################
# Detection
############################################################
示例13
def test___init___defaults(self):
aug = iaa.MultiplyBrightness()
assert isinstance(aug.children, iaa.Augmenter)
assert isinstance(aug.children[0], iaa.Multiply)
assert len(aug.to_colorspace.a) == len(self.valid_colorspaces)
for cspace in self.valid_colorspaces:
assert cspace in aug.to_colorspace.a
assert aug.from_colorspace == iaa.CSPACE_RGB
示例14
def test___init___defaults(self):
aug = iaa.MultiplyAndAddToBrightness()
assert aug.children.random_order is True
assert isinstance(aug.children[0], iaa.Multiply)
assert isinstance(aug.children[1], iaa.Add)
assert iaa.CSPACE_HSV in aug.to_colorspace.a
assert aug.from_colorspace == iaa.CSPACE_RGB
示例15
def test___init___add_is_zero(self):
aug = iaa.MultiplyAndAddToBrightness(add=0)
assert aug.children.random_order is True
assert isinstance(aug.children[0], iaa.Multiply)
assert isinstance(aug.children[1], iaa.Identity)
assert iaa.CSPACE_HSV in aug.to_colorspace.a
assert aug.from_colorspace == iaa.CSPACE_RGB
示例16
def test_returns_correct_objects__mul(self):
aug = iaa.MultiplyHueAndSaturation(
(0.9, 1.1), per_channel=True)
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 1
assert isinstance(aug.children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[0].mul, iap.Uniform)
assert np.isclose(aug.children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].mul.b.value, 1.1)
assert is_parameter_instance(aug.children[0].per_channel,
iap.Deterministic)
assert aug.children[0].per_channel.value == 1
示例17
def test_returns_correct_objects__mul_hue(self):
aug = iaa.MultiplyHueAndSaturation(mul_hue=(0.9, 1.1))
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 1
assert isinstance(aug.children[0], iaa.WithChannels)
assert aug.children[0].channels == [0]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[0].children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[0].children[0].mul,
iap.Uniform)
assert np.isclose(aug.children[0].children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].children[0].mul.b.value, 1.1)
示例18
def test_returns_correct_objects__mul_saturation(self):
aug = iaa.MultiplyHueAndSaturation(mul_saturation=(0.9, 1.1))
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 1
assert isinstance(aug.children[0], iaa.WithChannels)
assert aug.children[0].channels == [1]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[0].children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[0].children[0].mul,
iap.Uniform)
assert np.isclose(aug.children[0].children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].children[0].mul.b.value, 1.1)
示例19
def test_augment_images__mul(self):
aug = iaa.MultiplyHueAndSaturation(1.5)
# example image
image = np.arange(0, 255).reshape((1, 255, 1)).astype(np.uint8)
image = np.tile(image, (1, 1, 3))
image[..., 0] += 0
image[..., 1] += 5
image[..., 2] += 10
# compute expected output
image_hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
image_hsv = image_hsv.astype(np.int16) # simulate WithHueAndSaturation
image_hsv[..., 0] = (
(image_hsv[..., 0].astype(np.float32)/180)*255).astype(np.int16)
image_hsv = image_hsv.astype(np.float32) # simulate Multiply
image_hsv[..., 0] *= 1.5
image_hsv[..., 1] *= 1.5
image_hsv = np.round(image_hsv).astype(np.int16)
image_hsv[..., 0] = np.mod(image_hsv[..., 0], 255)
image_hsv[..., 0] = (
(image_hsv[..., 0].astype(np.float32)/255)*180).astype(np.int16)
image_hsv[..., 1] = np.clip(image_hsv[..., 1], 0, 255)
image_hsv = image_hsv.astype(np.uint8)
image_expected = cv2.cvtColor(image_hsv, cv2.COLOR_HSV2RGB)
assert not np.array_equal(image_expected, image)
# augment and verify
images_aug = aug.augment_images(np.stack([image, image], axis=0))
assert ia.is_np_array(images_aug)
for image_aug in images_aug:
assert image_aug.shape == (1, 255, 3)
diff = np.abs(image_aug.astype(np.int16) - image_expected)
assert np.all(diff <= 1)
示例20
def test_returns_correct_class(self):
# this test is practically identical to
# TestMultiplyToHueAndSaturation.test_returns_correct_objects__mul_hue
aug = iaa.MultiplyHue((0.9, 1.1))
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 1
assert isinstance(aug.children[0], iaa.WithChannels)
assert aug.children[0].channels == [0]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[0].children[0], iaa.Multiply)
assert is_parameter_instance(aug.children[0].children[0].mul,
iap.Uniform)
assert np.isclose(aug.children[0].children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].children[0].mul.b.value, 1.1)
示例21
def rotation(image, prob, keys):
""" Brightness, rotation, and scaling shear transformation """
aug = iaa.Sequential()
aug.add(iaa.Multiply(random.uniform(0.25, 1.5)))
aug.add(iaa.Affine(rotate=random.uniform(-180, 180),
scale=random.uniform(.7, 1.1),
shear=random.uniform(-25, 25),
cval=(0, 255)))
seq_det = aug.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
keys = ia.KeypointsOnImage([ia.Keypoint(x=keys[0], y=keys[1]),
ia.Keypoint(x=keys[2], y=keys[3]),
ia.Keypoint(x=keys[4], y=keys[5]),
ia.Keypoint(x=keys[6], y=keys[7]),
ia.Keypoint(x=keys[8], y=keys[9])], shape=image.shape)
keys_aug = seq_det.augment_keypoints([keys])[0]
k = keys_aug.keypoints
output = [k[0].x, k[0].y, k[1].x, k[1].y, k[2].x, k[2].y, k[3].x, k[3].y, k[4].x, k[4].y]
index = 0
for i in range(0, len(prob)):
output[index] = output[index] * prob[i]
output[index + 1] = output[index + 1] * prob[i]
index = index + 2
output = np.array(output)
return image_aug, output
示例22
def translate(image, prob, keys):
""" Translating image """
aug = iaa.Sequential()
x = random.uniform(-10, 10) * .01
aug.add(iaa.Affine(translate_percent={"x": x, "y": x},
scale=random.uniform(.7, 1.1),
rotate=random.uniform(-45, 45),
cval=(0, 255)))
aug.add(iaa.Multiply(random.uniform(0.5, 1.5)))
seq_det = aug.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
keys = ia.KeypointsOnImage([ia.Keypoint(x=keys[0], y=keys[1]),
ia.Keypoint(x=keys[2], y=keys[3]),
ia.Keypoint(x=keys[4], y=keys[5]),
ia.Keypoint(x=keys[6], y=keys[7]),
ia.Keypoint(x=keys[8], y=keys[9])], shape=image.shape)
keys_aug = seq_det.augment_keypoints([keys])[0]
k = keys_aug.keypoints
output = [k[0].x, k[0].y, k[1].x, k[1].y, k[2].x, k[2].y, k[3].x, k[3].y, k[4].x, k[4].y]
index = 0
for i in range(0, len(prob)):
output[index] = output[index] * prob[i]
output[index + 1] = output[index + 1] * prob[i]
index = index + 2
output = np.array(output)
return image_aug, output
示例23
def crop(image, prob, keys):
""" Cropping """
x = random.randint(0, 5)
y = random.randint(0, 5)
r = random.uniform(-5, 5)
aug = iaa.Sequential([iaa.Crop(px=((0, x), (0, y), (0, x), (0, y))), iaa.Affine(shear=r, cval=(0, 255))])
aug.add(iaa.Multiply(random.uniform(0.25, 1.5)))
seq_det = aug.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
keys = ia.KeypointsOnImage([ia.Keypoint(x=keys[0], y=keys[1]),
ia.Keypoint(x=keys[2], y=keys[3]),
ia.Keypoint(x=keys[4], y=keys[5]),
ia.Keypoint(x=keys[6], y=keys[7]),
ia.Keypoint(x=keys[8], y=keys[9])], shape=image.shape)
keys_aug = seq_det.augment_keypoints([keys])[0]
k = keys_aug.keypoints
output = [k[0].x, k[0].y, k[1].x, k[1].y, k[2].x, k[2].y, k[3].x, k[3].y, k[4].x, k[4].y]
index = 0
for i in range(0, len(prob)):
output[index] = output[index] * prob[i]
output[index + 1] = output[index + 1] * prob[i]
index = index + 2
output = np.array(output)
return image_aug, output
示例24
def salt(image, prob, keys):
""" Adding salt noise """
r = random.uniform(1, 5) * 0.05
aug = iaa.Sequential([iaa.Dropout(p=(0, r)), iaa.CoarseDropout(p=0.001, size_percent=0.01),
iaa.Salt(0.001), iaa.AdditiveGaussianNoise(scale=0.1 * 255)])
aug.add(iaa.Multiply(random.uniform(0.25, 1.5)))
x = random.randrange(-10, 10) * .01
y = random.randrange(-10, 10) * .01
aug.add(iaa.Affine(scale=random.uniform(.7, 1.1), translate_percent={"x": x, "y": y}, cval=(0, 255)))
seq_det = aug.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
keys = ia.KeypointsOnImage([ia.Keypoint(x=keys[0], y=keys[1]),
ia.Keypoint(x=keys[2], y=keys[3]),
ia.Keypoint(x=keys[4], y=keys[5]),
ia.Keypoint(x=keys[6], y=keys[7]),
ia.Keypoint(x=keys[8], y=keys[9])], shape=image.shape)
keys_aug = seq_det.augment_keypoints([keys])[0]
k = keys_aug.keypoints
output = [k[0].x, k[0].y, k[1].x, k[1].y, k[2].x, k[2].y, k[3].x, k[3].y, k[4].x, k[4].y]
index = 0
for i in range(0, len(prob)):
output[index] = output[index] * prob[i]
output[index + 1] = output[index + 1] * prob[i]
index = index + 2
output = np.array(output)
return image_aug, output
示例25
def chapter_augmenters_multiply():
aug = iaa.Multiply((0.5, 1.5))
run_and_save_augseq(
"multiply.jpg", aug,
[ia.quokka(size=(64, 64)) for _ in range(16)], cols=8, rows=2
)
aug = iaa.Multiply((0.5, 1.5), per_channel=0.5)
run_and_save_augseq(
"multiply_per_channel.jpg", aug,
[ia.quokka(size=(64, 64)) for _ in range(16)], cols=8, rows=2
)
示例26
def __init__(self):
self.imgaug_transform = iaa.Multiply((1.5, 1.5), per_channel=False)
self.augmentor_op = Operations.RandomContrast(probability=1, min_factor=1.5, max_factor=1.5)
self.solt_stream = slc.Stream([slt.ImageRandomContrast(p=1, contrast_range=(1.5, 1.5))])
示例27
def __init__(self):
self.imgaug_transform = iaa.Multiply(mul=1.5)
示例28
def train(model, dataset_dir, subset):
"""Train the model."""
# Training dataset.
dataset_train = NucleusDataset()
dataset_train.load_nucleus(dataset_dir, subset)
dataset_train.prepare()
# Validation dataset
dataset_val = NucleusDataset()
dataset_val.load_nucleus(dataset_dir, "val")
dataset_val.prepare()
# Image augmentation
# http://imgaug.readthedocs.io/en/latest/source/augmenters.html
augmentation = iaa.SomeOf((0, 2), [
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.OneOf([iaa.Affine(rotate=90),
iaa.Affine(rotate=180),
iaa.Affine(rotate=270)]),
iaa.Multiply((0.8, 1.5)),
iaa.GaussianBlur(sigma=(0.0, 5.0))
])
# *** This training schedule is an example. Update to your needs ***
# If starting from imagenet, train heads only for a bit
# since they have random weights
print("Train network heads")
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=20,
augmentation=augmentation,
layers='heads')
print("Train all layers")
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=40,
augmentation=augmentation,
layers='all')
############################################################
# RLE Encoding
############################################################
示例29
def test_augment_images__mul_saturation(self):
# this is almost identical to test_augment_images__mul
# only
# aug = ...
# and
# image_hsv[...] *= 1.2
# have been changed
aug = iaa.MultiplyHueAndSaturation(mul_saturation=1.5) # changed
# example image
image = np.arange(0, 255).reshape((1, 255, 1)).astype(np.uint8)
image = np.tile(image, (1, 1, 3))
image[..., 0] += 0
image[..., 1] += 5
image[..., 2] += 10
# compute expected output
image_hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
image_hsv = image_hsv.astype(np.int16) # simulate WithHueAndSaturation
image_hsv[..., 0] = (
(image_hsv[..., 0].astype(np.float32)/180)*255).astype(np.int16)
image_hsv = image_hsv.astype(np.float32) # simulate Multiply
image_hsv[..., 0] *= 1.0 # changed over __mul
image_hsv[..., 1] *= 1.5
image_hsv = np.round(image_hsv).astype(np.int16)
image_hsv[..., 0] = np.mod(image_hsv[..., 0], 255)
image_hsv[..., 0] = (
(image_hsv[..., 0].astype(np.float32)/255)*180).astype(np.int16)
image_hsv[..., 1] = np.clip(image_hsv[..., 1], 0, 255)
image_hsv = image_hsv.astype(np.uint8)
image_expected = cv2.cvtColor(image_hsv, cv2.COLOR_HSV2RGB)
assert not np.array_equal(image_expected, image)
# augment and verify
images_aug = aug.augment_images(np.stack([image, image], axis=0))
assert ia.is_np_array(images_aug)
for image_aug in images_aug:
assert image_aug.shape == (1, 255, 3)
diff = np.abs(image_aug.astype(np.int16) - image_expected)
assert np.all(diff <= 1)
示例30
def test_augment_images__mul_hue_and_mul_saturation(self):
# this is almost identical to test_augment_images__mul
# only
# aug = ...
# and
# image_hsv[...] *= 1.2
# have been changed
aug = iaa.MultiplyHueAndSaturation(mul_hue=1.5,
mul_saturation=1.6) # changed
# example image
image = np.arange(0, 255).reshape((1, 255, 1)).astype(np.uint8)
image = np.tile(image, (1, 1, 3))
image[..., 0] += 0
image[..., 1] += 5
image[..., 2] += 10
# compute expected output
image_hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
image_hsv = image_hsv.astype(np.int16) # simulate WithHueAndSaturation
image_hsv[..., 0] = (
(image_hsv[..., 0].astype(np.float32)/180)*255).astype(np.int16)
image_hsv = image_hsv.astype(np.float32) # simulate Multiply
image_hsv[..., 0] *= 1.5
image_hsv[..., 1] *= 1.6 # changed over __mul
image_hsv = np.round(image_hsv).astype(np.int16)
image_hsv[..., 0] = np.mod(image_hsv[..., 0], 255)
image_hsv[..., 0] = (
(image_hsv[..., 0].astype(np.float32)/255)*180).astype(np.int16)
image_hsv[..., 1] = np.clip(image_hsv[..., 1], 0, 255)
image_hsv = image_hsv.astype(np.uint8)
image_expected = cv2.cvtColor(image_hsv, cv2.COLOR_HSV2RGB)
assert not np.array_equal(image_expected, image)
# augment and verify
images_aug = aug.augment_images(np.stack([image, image], axis=0))
assert ia.is_np_array(images_aug)
for image_aug in images_aug:
assert image_aug.shape == (1, 255, 3)
diff = np.abs(image_aug.astype(np.int16) - image_expected)
assert np.all(diff <= 1)
