def strong_aug(p=0.5, crop_size=(512, 512)):
return Compose([
RandomResizedCrop(crop_size[0],
crop_size[1],
scale=(0.3, 1.0),
ratio=(0.75, 1.3),
interpolation=4,
p=1.0),
RandomRotate90(),
Flip(),
Transpose(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.8),
OneOf([
MotionBlur(p=0.5),
MedianBlur(blur_limit=3, p=0.5),
Blur(blur_limit=3, p=0.5),
],
p=0.3),
ShiftScaleRotate(
shift_limit=0.2, scale_limit=0.5, rotate_limit=180, p=0.8),
OneOf([
OpticalDistortion(p=0.5),
GridDistortion(p=0.5),
IAAPiecewiseAffine(p=0.5),
ElasticTransform(p=0.5),
],
p=0.3),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomBrightnessContrast(),
],
p=0.3),
OneOf([
GaussNoise(),
RandomRain(
p=0.2, brightness_coefficient=0.9, drop_width=1, blur_value=5),
RandomSnow(p=0.4,
brightness_coeff=0.5,
snow_point_lower=0.1,
snow_point_upper=0.3),
RandomShadow(p=0.2,
num_shadows_lower=1,
num_shadows_upper=1,
shadow_dimension=5,
shadow_roi=(0, 0.5, 1, 1)),
RandomFog(
p=0.5, fog_coef_lower=0.3, fog_coef_upper=0.5, alpha_coef=0.1)
],
p=0.3),
RGBShift(),
HueSaturationValue(p=0.9),
],
p=p)
def generate_aug_images(path=PATH_TO_IMAGES):
"""
Generates augmented images of a specific folder
Augmentations:
- Randomly change brightness and contrast of the input image
- Apply Contrast Limited Adaptive Histogram Equalization to the input image
- Convert the input RGB image to grayscale
- Blur the input image using a random-sized kernel
- Simulates fog for the image
- Randomly change hue, saturation and value of the input image
"""
log.info('Generating augmentation of the images...')
log.info('Path of the images: ' + PATH_TO_IMAGES)
for i, pig_name in enumerate(os.listdir(path)):
img_path = os.path.join(path, pig_name)
image_names = glob.glob(os.path.join(img_path, 'DSC*'))
for image_name in image_names:
image_name = os.path.basename(image_name)
img_orig = cv2.imread(os.path.join(img_path, image_name))
img_orig = cv2.cvtColor(img_orig, cv2.COLOR_BGR2RGB)
alpha = 1.2
aug = RandomBrightnessContrast(p=1)
pig_img_aug1 = aug.apply(img_orig, alpha=alpha)
save_aug_image(image_name, img_path, pig_img_aug1, 'A1-')
aug = CLAHE(p=1.0)
pig_img_aug2 = aug.apply(img_orig)
save_aug_image(image_name, img_path, pig_img_aug2, 'A2-')
aug = ToGray(p=0.5)
pig_img_aug3 = aug.apply(img_orig)
save_aug_image(image_name, img_path, pig_img_aug3, 'A3-')
aug = Blur(p=0.5, blur_limit=7)
pig_img_aug4 = aug.apply(img_orig)
save_aug_image(image_name, img_path, pig_img_aug4, 'A4-')
aug = RandomFog(p=1,
fog_coef_lower=0.1,
fog_coef_upper=0.1,
alpha_coef=0.8)
pig_img_aug5 = aug.apply(img_orig)
save_aug_image(image_name, img_path, pig_img_aug5, 'A5-')
aug = HueSaturationValue(hue_shift_limit=200,
sat_shift_limit=70,
val_shift_limit=27,
p=1)
pig_img_aug6 = aug.apply(img_orig)
save_aug_image(image_name, img_path, pig_img_aug6, 'A6-')
print("augmentation in process A1: " + str(i))
print('augmentation finished (sharpness)')
def get_transforms(self):
list_transforms = []
if self.phase == "train":
list_transforms.extend([
# Spatial transforms
HorizontalFlip(p=0.6),
RandomCrop(self.random_crop_h, self.random_crop_w, p=0.8),
Resize(self.orig_h, self.orig_w, interpolation=4, p=1.0),
# RGB transormations
OneOf([
RandomBrightness(p=0.5, limit=0.2),
RandomContrast(p=0.5, limit=0.2),
RandomGamma(p=0.5, gamma_limit=(80, 120))
],
p=1.)
])
if self.hard_augs:
list_transforms.extend(
# Hard augs
OneOf(
[
RandomFog(p=0.5,
fog_coef_lower=0.1,
fog_coef_upper=.3,
alpha_coef=0.08),
RandomRain(
p=0.5,
slant_lower=-20,
slant_upper=20,
rain_type=None
), # [None, "drizzle", "heavy", "torrestial"]
RandomSnow(p=0.5,
snow_point_lower=0.1,
snow_point_upper=0.3,
brightness_coeff=2.5),
RandomSunFlare(p=0.5,
flare_roi=(0, 0, 1, 0.5),
angle_lower=0,
angle_upper=1,
num_flare_circles_lower=3,
num_flare_circles_upper=6,
src_radius=400,
src_color=(255, 255, 255))
],
p=0.8))
list_transforms.append(Normalize(mean=self.mean, std=self.std, p=1))
list_trfms = Compose(list_transforms)
return list_trfms
def setUpClass(cls):
from cral.tracking import set_experiment
from cral.pipeline.core import ClassificationPipe
from cral.augmentations.engine import Classification as Classification_augmentor
zip_url = 'https://segmind-data.s3.ap-south-1.amazonaws.com/edge/data/classification/bikes_persons_dataset.zip'
path_to_zip_file = tf.keras.utils.get_file('bikes_persons_dataset.zip',
zip_url,
cache_dir='/tmp',
cache_subdir='',
extract=False)
directory_to_extract_to = '/tmp'
with zipfile.ZipFile(path_to_zip_file, 'r') as zip_ref:
zip_ref.extractall(directory_to_extract_to)
set_experiment('6f2c48d8-970a-4e28-a609-38088cab599a')
cls.new_pipe = ClassificationPipe()
cls.new_pipe.add_data(train_images_dir='/tmp/bikes_persons_dataset',
val_images_dir=None,
split=0.2)
cls.new_pipe.lock_data()
aug = [
OneOf([
RandomFog(
fog_coef_lower=1, fog_coef_upper=1, alpha_coef=0.05,
p=1.0),
RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=10.5, p=1.0),
RandomShadow(shadow_roi=(0, 0.5, 1, 1),
num_shadows_lower=1,
num_shadows_upper=2,
shadow_dimension=5,
p=0.5),
RandomSnow(),
RandomSunFlare()
],
p=0.2)
]
augmentor = Classification_augmentor(aug=aug)
cls.new_pipe.set_aug(augmentor)
cls.report_path = '/tmp/reports'
if os.path.isdir(cls.report_path) is False:
os.mkdir(cls.report_path)
def __init__(self):
self.random_brightness_contrast = RandomBrightnessContrast()
self.hue_saturation_value = HueSaturationValue()
self.random_gamma = RandomGamma()
self.clahe = CLAHE()
self.blur = Blur()
self.gauss_noise = GaussNoise()
self.channel_shuffle = ChannelShuffle()
self.rgb_shift = RGBShift()
self.channel_dropout = ChannelDropout()
self.random_fog = RandomFog(fog_coef_upper=0.4)
self.random_rain = RandomRain()
self.random_snow = RandomSnow()
self.random_shadow = RandomShadow()
self.random_sunflare = RandomSunFlare(angle_upper=0.2)
[
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406][::-1], std=[0.225, 0.224, 0.225][::-1]
),
]
)
transformaug = Compose(
[
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
ISONoise(p=0.5),
RandomBrightnessContrast(p=0.5),
RandomGamma(p=0.5),
RandomFog(fog_coef_lower=0.025, fog_coef_upper=0.1, p=0.5),
]
)
class XViewDataset(Dataset):
def __init__(
self, size=None, aug=True, pattern="data/train/images1024/*pre_disaster*.png"
):
self.name = "train"
self.aug = aug
self.pre = glob(pattern)
if size:
self.pre = self.pre[:size]
self.post = [fn.replace("pre_disaster", "post_disaster") for fn in self.pre]
self.prey = [
def transform(image, mask, image_name, mask_name):
x, y = image, mask
rand = random.uniform(0, 1)
if (rand > 0.5):
images_name = [f"{image_name}"]
masks_name = [f"{mask_name}"]
images_aug = [x]
masks_aug = [y]
it = iter(images_name)
it2 = iter(images_aug)
imagedict = dict(zip(it, it2))
it = iter(masks_name)
it2 = iter(masks_aug)
masksdict = dict(zip(it, it2))
return imagedict, masksdict
mask_density = np.count_nonzero(y)
## Augmenting only images with Gloms
if (mask_density > 0):
try:
h, w, c = x.shape
except Exception as e:
image = image[:-1]
x, y = image, mask
h, w, c = x.shape
aug = Blur(p=1, blur_limit=3)
augmented = aug(image=x, mask=y)
x0 = augmented['image']
y0 = augmented['mask']
# aug = CenterCrop(p=1, height=32, width=32)
# augmented = aug(image=x, mask=y)
# x1 = augmented['image']
# y1 = augmented['mask']
## Horizontal Flip
aug = HorizontalFlip(p=1)
augmented = aug(image=x, mask=y)
x2 = augmented['image']
y2 = augmented['mask']
aug = VerticalFlip(p=1)
augmented = aug(image=x, mask=y)
x3 = augmented['image']
y3 = augmented['mask']
# aug = Normalize(p=1)
# augmented = aug(image=x, mask=y)
# x4 = augmented['image']
# y4 = augmented['mask']
aug = Transpose(p=1)
augmented = aug(image=x, mask=y)
x5 = augmented['image']
y5 = augmented['mask']
aug = RandomGamma(p=1)
augmented = aug(image=x, mask=y)
x6 = augmented['image']
y6 = augmented['mask']
## Optical Distortion
aug = OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5)
augmented = aug(image=x, mask=y)
x7 = augmented['image']
y7 = augmented['mask']
## Grid Distortion
aug = GridDistortion(p=1)
augmented = aug(image=x, mask=y)
x8 = augmented['image']
y8 = augmented['mask']
aug = RandomGridShuffle(p=1)
augmented = aug(image=x, mask=y)
x9 = augmented['image']
y9 = augmented['mask']
aug = HueSaturationValue(p=1)
augmented = aug(image=x, mask=y)
x10 = augmented['image']
y10 = augmented['mask']
# aug = PadIfNeeded(p=1)
# augmented = aug(image=x, mask=y)
# x11 = augmented['image']
# y11 = augmented['mask']
aug = RGBShift(p=1)
augmented = aug(image=x, mask=y)
x12 = augmented['image']
y12 = augmented['mask']
## Random Brightness
aug = RandomBrightness(p=1)
augmented = aug(image=x, mask=y)
x13 = augmented['image']
y13 = augmented['mask']
## Random Contrast
aug = RandomContrast(p=1)
augmented = aug(image=x, mask=y)
x14 = augmented['image']
y14 = augmented['mask']
#aug = MotionBlur(p=1)
#augmented = aug(image=x, mask=y)
# x15 = augmented['image']
# y15 = augmented['mask']
aug = MedianBlur(p=1, blur_limit=5)
augmented = aug(image=x, mask=y)
x16 = augmented['image']
y16 = augmented['mask']
aug = GaussianBlur(p=1, blur_limit=3)
augmented = aug(image=x, mask=y)
x17 = augmented['image']
y17 = augmented['mask']
aug = GaussNoise(p=1)
augmented = aug(image=x, mask=y)
x18 = augmented['image']
y18 = augmented['mask']
aug = GlassBlur(p=1)
augmented = aug(image=x, mask=y)
x19 = augmented['image']
y19 = augmented['mask']
aug = CLAHE(clip_limit=1.0,
tile_grid_size=(8, 8),
always_apply=False,
p=1)
augmented = aug(image=x, mask=y)
x20 = augmented['image']
y20 = augmented['mask']
aug = ChannelShuffle(p=1)
augmented = aug(image=x, mask=y)
x21 = augmented['image']
y21 = augmented['mask']
aug = ToGray(p=1)
augmented = aug(image=x, mask=y)
x22 = augmented['image']
y22 = augmented['mask']
aug = ToSepia(p=1)
augmented = aug(image=x, mask=y)
x23 = augmented['image']
y23 = augmented['mask']
aug = JpegCompression(p=1)
augmented = aug(image=x, mask=y)
x24 = augmented['image']
y24 = augmented['mask']
aug = ImageCompression(p=1)
augmented = aug(image=x, mask=y)
x25 = augmented['image']
y25 = augmented['mask']
aug = Cutout(p=1)
augmented = aug(image=x, mask=y)
x26 = augmented['image']
y26 = augmented['mask']
# aug = CoarseDropout(p=1, max_holes=8, max_height=32, max_width=32)
# augmented = aug(image=x, mask=y)
# x27 = augmented['image']
# y27 = augmented['mask']
# aug = ToFloat(p=1)
# augmented = aug(image=x, mask=y)
# x28 = augmented['image']
# y28 = augmented['mask']
aug = FromFloat(p=1)
augmented = aug(image=x, mask=y)
x29 = augmented['image']
y29 = augmented['mask']
## Random Brightness and Contrast
aug = RandomBrightnessContrast(p=1)
augmented = aug(image=x, mask=y)
x30 = augmented['image']
y30 = augmented['mask']
aug = RandomSnow(p=1)
augmented = aug(image=x, mask=y)
x31 = augmented['image']
y31 = augmented['mask']
aug = RandomRain(p=1)
augmented = aug(image=x, mask=y)
x32 = augmented['image']
y32 = augmented['mask']
aug = RandomFog(p=1)
augmented = aug(image=x, mask=y)
x33 = augmented['image']
y33 = augmented['mask']
aug = RandomSunFlare(p=1)
augmented = aug(image=x, mask=y)
x34 = augmented['image']
y34 = augmented['mask']
aug = RandomShadow(p=1)
augmented = aug(image=x, mask=y)
x35 = augmented['image']
y35 = augmented['mask']
aug = Lambda(p=1)
augmented = aug(image=x, mask=y)
x36 = augmented['image']
y36 = augmented['mask']
aug = ChannelDropout(p=1)
augmented = aug(image=x, mask=y)
x37 = augmented['image']
y37 = augmented['mask']
aug = ISONoise(p=1)
augmented = aug(image=x, mask=y)
x38 = augmented['image']
y38 = augmented['mask']
aug = Solarize(p=1)
augmented = aug(image=x, mask=y)
x39 = augmented['image']
y39 = augmented['mask']
aug = Equalize(p=1)
augmented = aug(image=x, mask=y)
x40 = augmented['image']
y40 = augmented['mask']
aug = Posterize(p=1)
augmented = aug(image=x, mask=y)
x41 = augmented['image']
y41 = augmented['mask']
aug = Downscale(p=1)
augmented = aug(image=x, mask=y)
x42 = augmented['image']
y42 = augmented['mask']
aug = MultiplicativeNoise(p=1)
augmented = aug(image=x, mask=y)
x43 = augmented['image']
y43 = augmented['mask']
aug = FancyPCA(p=1)
augmented = aug(image=x, mask=y)
x44 = augmented['image']
y44 = augmented['mask']
# aug = MaskDropout(p=1)
# augmented = aug(image=x, mask=y)
# x45 = augmented['image']
# y45 = augmented['mask']
aug = GridDropout(p=1)
augmented = aug(image=x, mask=y)
x46 = augmented['image']
y46 = augmented['mask']
aug = ColorJitter(p=1)
augmented = aug(image=x, mask=y)
x47 = augmented['image']
y47 = augmented['mask']
## ElasticTransform
aug = ElasticTransform(p=1,
alpha=120,
sigma=512 * 0.05,
alpha_affine=512 * 0.03)
augmented = aug(image=x, mask=y)
x50 = augmented['image']
y50 = augmented['mask']
aug = CropNonEmptyMaskIfExists(p=1, height=22, width=32)
augmented = aug(image=x, mask=y)
x51 = augmented['image']
y51 = augmented['mask']
aug = IAAAffine(p=1)
augmented = aug(image=x, mask=y)
x52 = augmented['image']
y52 = augmented['mask']
# aug = IAACropAndPad(p=1)
# augmented = aug(image=x, mask=y)
# x53 = augmented['image']
# y53 = augmented['mask']
aug = IAAFliplr(p=1)
augmented = aug(image=x, mask=y)
x54 = augmented['image']
y54 = augmented['mask']
aug = IAAFlipud(p=1)
augmented = aug(image=x, mask=y)
x55 = augmented['image']
y55 = augmented['mask']
aug = IAAPerspective(p=1)
augmented = aug(image=x, mask=y)
x56 = augmented['image']
y56 = augmented['mask']
aug = IAAPiecewiseAffine(p=1)
augmented = aug(image=x, mask=y)
x57 = augmented['image']
y57 = augmented['mask']
aug = LongestMaxSize(p=1)
augmented = aug(image=x, mask=y)
x58 = augmented['image']
y58 = augmented['mask']
aug = NoOp(p=1)
augmented = aug(image=x, mask=y)
x59 = augmented['image']
y59 = augmented['mask']
# aug = RandomCrop(p=1, height=22, width=22)
# augmented = aug(image=x, mask=y)
# x61 = augmented['image']
# y61 = augmented['mask']
# aug = RandomResizedCrop(p=1, height=22, width=20)
# augmented = aug(image=x, mask=y)
# x63 = augmented['image']
# y63 = augmented['mask']
aug = RandomScale(p=1)
augmented = aug(image=x, mask=y)
x64 = augmented['image']
y64 = augmented['mask']
# aug = RandomSizedCrop(p=1, height=22, width=20, min_max_height = [32,32])
# augmented = aug(image=x, mask=y)
# x66 = augmented['image']
# y66 = augmented['mask']
# aug = Resize(p=1, height=22, width=20)
# augmented = aug(image=x, mask=y)
# x67 = augmented['image']
# y67 = augmented['mask']
aug = Rotate(p=1)
augmented = aug(image=x, mask=y)
x68 = augmented['image']
y68 = augmented['mask']
aug = ShiftScaleRotate(p=1)
augmented = aug(image=x, mask=y)
x69 = augmented['image']
y69 = augmented['mask']
aug = SmallestMaxSize(p=1)
augmented = aug(image=x, mask=y)
x70 = augmented['image']
y70 = augmented['mask']
images_aug.extend([
x, x0, x2, x3, x5, x6, x7, x8, x9, x10, x12, x13, x14, x16, x17,
x18, x19, x20, x21, x22, x23, x24, x25, x26, x29, x30, x31, x32,
x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x46,
x47, x50, x51, x52, x54, x55, x56, x57, x58, x59, x64, x68, x69,
x70
])
masks_aug.extend([
y, y0, y2, y3, y5, y6, y7, y8, y9, y10, y12, y13, y14, y16, y17,
y18, y19, y20, y21, y22, y23, y24, y25, y26, y29, y30, y31, y32,
y33, y34, y35, y36, y37, y38, y39, y40, y41, y42, y43, y44, y46,
y47, y50, y51, y52, y54, y55, y56, y57, y58, y59, y64, y68, y69,
y70
])
idx = -1
images_name = []
masks_name = []
for i, m in zip(images_aug, masks_aug):
if idx == -1:
tmp_image_name = f"{image_name}"
tmp_mask_name = f"{mask_name}"
else:
tmp_image_name = f"{image_name}_{smalllist[idx]}"
tmp_mask_name = f"{mask_name}_{smalllist[idx]}"
images_name.extend(tmp_image_name)
masks_name.extend(tmp_mask_name)
idx += 1
it = iter(images_name)
it2 = iter(images_aug)
imagedict = dict(zip(it, it2))
it = iter(masks_name)
it2 = iter(masks_aug)
masksdict = dict(zip(it, it2))
return imagedict, masksdict
def train(file_pattern,
train_num_batches=None,
train_aug=False,
train_batch_size=1,
val_batch_size=1,
learning_rate=1e-3,
epochs=1,
verbosity=2,
file_directory=None,
resume=None,
train_shuffle=True,
pre_image_mean=None,
post_image_mean=None):
"""
Function to train the UNet model
Parameters
----------
file_pattern : string
Location where the image folder is for the data. Example format:
"images/*pre_disaster*.png"
train_num_batches : int
Number of batches for the training set, if none, the full dataset will
be used.
train_aug : bool
If true, augmentations are performed.
train_batch_size : int, default 5
Batch size for the training set.
val_batch_size : int, default 5
Batch size for the validation set.
learning_rate : float, default 0.00001
Learning rate for the UNet.
epochs : int, default 1
How many epochs for the training to run.
verbosity : int, default 2
How verbose you'd like the output to be.
file_directory : string, default None:
Directory where you'd like the output files saved.
resume : string, default None
Enter in a string for the saved model file and training will resume
from this instance.
train_shuffle : bool
If True, the training data is shuffled for each epoch.
pre_image_mean : str
The filepath for the pre image mean numpy array file.
post_image_mean : str
The filepath for the post image mean numpy array file.
Returns
-------
Saves the model weights, csv logs, and tensorboard files in the original
directories specified.
"""
if file_directory is None:
file_directory = os.path.abspath(
os.path.join(os.getcwd(), "saved_models"))
tensorboard_path = os.path.join(
file_directory, "logs",
"tboard_{}".format(datetime.datetime.now().strftime("%Y%m%d-%H%M")))
weights_path = os.path.join(
file_directory, "unet_weights_{}".format(
datetime.datetime.now().strftime("%Y%m%d-%H%M")))
csv_logger_path = os.path.join(
file_directory,
"log_unet_{}{}".format(datetime.datetime.now().strftime("%Y%m%d-%H%M"),
".csv"))
if train_aug:
train_augs = Compose([
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
ISONoise(p=0.5),
RandomBrightnessContrast(p=0.5),
RandomGamma(p=0.5),
RandomFog(fog_coef_lower=0.025, fog_coef_upper=0.1, p=0.5),
])
else:
train_augs = None
# Weighted categorical cross entropy weights
# class_weights = tf.constant([0.1, 1.0, 2.0, 2.0, 2.0])
# class_weights = tf.constant([1.0, 1.0, 0.5, 0.5, 0.5])
class_weights = tf.constant([1.0, 1.0, 3.0, 3.0, 3.0])
train_data = LabeledImageDataset(num_batches=train_num_batches,
augmentations=train_augs,
pattern=file_pattern,
shuffle=train_shuffle,
n_classes=5,
batch_size=train_batch_size,
normalize=True)
# Using random samples from train for validation
val_data = LabeledImageDataset(num_batches=100,
augmentations=train_augs,
pattern=file_pattern,
shuffle=train_shuffle,
n_classes=5,
batch_size=val_batch_size,
normalize=True)
if resume:
try:
print("the pretrained model was loaded")
model = UNet(num_classes=5).model((None, None, 3))
model.load_weights(resume)
except OSError:
print("The model file could not be found. "
"Starting from a new model instance")
model = UNet(num_classes=5).model((None, None, 3))
else:
model = UNet(num_classes=5).model((None, None, 3))
metrics = [tf.keras.metrics.CategoricalAccuracy()]
for i in range(5):
metrics.append(Precision(class_id=i, name=f"prec_class_{i}"))
metrics.append(Recall(class_id=i, name=f"rec_class_{i}"))
model.compile(optimizer=keras.optimizers.RMSprop(lr=learning_rate),
loss=CombinedLoss(class_weights),
metrics=metrics)
# Creating a checkpoint to save the model after every epoch if the
# validation loss has decreased
model_checkpoint = ModelCheckpoint("dual_unet_{epoch:02d}-{loss:.2f}.hdf5",
monitor='loss',
save_best_only=False,
mode='min',
save_weights_only=True,
verbose=verbosity)
csv_logger = CSVLogger(csv_logger_path, append=True, separator=',')
lr_logger = ReduceLROnPlateau(monitor='loss',
factor=0.2,
patience=1,
verbose=verbosity,
mode='min',
min_lr=1e-6)
tensorboard_cb = TensorBoard(log_dir=tensorboard_path, write_images=True)
try:
model.fit(train_data,
epochs=epochs,
verbose=verbosity,
callbacks=[
LossAndErrorPrintingCallback(), model_checkpoint,
csv_logger, lr_logger, tensorboard_cb
],
validation_data=val_data,
workers=6)
except KeyboardInterrupt:
save_model(model, pause=1)
sys.exit()
except Exception as exc:
save_model(model, pause=0)
raise exc
p=0.2),
RGBShift(r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=0.15),
RandomBrightnessContrast(p=0.2),
MotionBlur(blur_limit=7, p=0.2),
GaussianBlur(blur_limit=7, p=0.15),
CLAHE(p=0.05),
ChannelShuffle(p=0.05),
ToGray(p=0.1),
ImageCompression(quality_lower=10, quality_upper=100, p=0.15),
CoarseDropout(max_holes=32, max_height=12, max_width=12, p=0.05),
Downscale(p=0.3),
FancyPCA(alpha=0.4, p=0.1),
Posterize(num_bits=4, p=0.03),
Equalize(p=0.05),
ISONoise(color_shift=(0.1, 0.5), p=0.07),
RandomFog(p=0.03)
]
BACKGROUNDS_PATHS = glob(BACKGROUNDS_WILDRCARD)
BACKGROUNDS = [
load_image(path, cv.COLOR_BGR2RGB) for path in BACKGROUNDS_PATHS
]
ENTRY_TRANSFORMATION = EntryTransformation(class_mapping=CLASS_MAPPINGS,
target_size=MODEL_INPUT_SIZE,
backgrounds=BACKGROUNDS)
DATA_AUGMENTATIONS = [
DataAugmentation(transformations=AUGMENTATIONS,
global_application_probab=0.6),
DataStandardisation()
[
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406][::-1], std=[0.225, 0.224, 0.225][::-1]
),
]
)
transformaug = Compose(
[
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
ISONoise(p=0.5),
RandomBrightnessContrast(p=0.5),
RandomGamma(p=0.5),
RandomFog(fog_coef_lower=0.05, fog_coef_upper=0.15, p=0.5),
]
)
class XViewDataset(Dataset):
def __init__(
self, size=None, aug=True, pattern="data/train/images1024/*pre_disaster*.png"
):
self.name = "train"
self.aug = aug
self.pre = glob(pattern)
if size:
self.pre = self.pre[:size]
self.prey = [
def ImageAugument():
imgs_save_dir = 'data/albu_imgs/'
if not os.path.exists(imgs_save_dir):
os.makedirs(imgs_save_dir)
xmls_save_dir = 'data/albu_xmls/'
if not os.path.exists(xmls_save_dir):
os.makedirs(xmls_save_dir)
path = "data/img" # 文件夹目录
xml_path = "data/xml"
files = os.listdir(path) # 得到文件夹下的所有文件名称
# 遍历文件夹
prefix = path + '/'
print("begin>>>")
for file in tqdm(files):
image = cv2.imread(prefix + file)
# cv2.imwrite("origin.jpg",image)
xml = xml_path + "/" + file[:-4] + ".xml"
#示例：使用具有随机孔径线性大小的中值滤波器来模糊输入图像
aug = MedianBlur(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'mb' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "mb" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机大小的内核模糊输入图像
aug = Blur(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'blur' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "blur" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#高斯模糊
aug = GaussNoise(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'gau' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "gau" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机雨
aug = RandomRain(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'rain' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "rain" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机雾
aug = RandomFog(fog_coef_lower=0.2,
fog_coef_upper=0.5,
alpha_coef=0.1,
p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'fog' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "fog" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#太阳耀斑RandomSunFlare
aug = RandomSunFlare(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'sun' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "sun" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#阴影RandomShadow
aug = RandomShadow(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'shadow' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "shadow" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机雪RandomSnow
aug = RandomSnow(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'snow' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "snow" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机CoarseDropout
aug = CoarseDropout(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'drop' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "drop" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机cutout
aug = Cutout(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'cut' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "cut" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
print("Done")
def __call__(self, image, boxes=None, labels=None):
image = RandomFog(p=0.1)(image=image)['image']
return image.astype(np.float32), boxes, labels