def test_aug(): im=cv2.imread('/media/wsl/SB@data/dataset/瓶盖分类/dataset/单字检测/聪明盖/0_0.jpg') bboxes=read_labelme('/media/wsl/SB@data/dataset/瓶盖分类/dataset/单字检测/聪明盖/0_0.json') poly_on_img=PolygonsOnImage([Polygon(bbox) for bbox in bboxes],shape=im.shape) st = lambda aug: iaa.Sometimes(1, aug) seq = iaa.Sequential([ #st(iaa.Pad(percent=((0, 0.2), (0, 0.2), (0, 0.2), (0, 0.2)), keep_size=False)), # # # st(iaa.Crop(percent=([0.0, 0.3], [0.00, 0.1], [0.0, 0.3], [0.0, 0.1]), keep_size=False)), st(iaa.Affine(scale=(0.9, 1.0), rotate=(-45, 45), shear=(-5, 5), translate_px={"x": (-16, 16), "y": (-10, 10)}, fit_output=True)), st(iaa.Add(value=(-10, 10), per_channel=True)), # st(iaa.PerspectiveTransform((0,0.1),fit_output=True)), # st(iaa.MultiplyAndAddToBrightness(mul=(0.6, 1.5), add=(0, 30))), st(iaa.ChangeColorTemperature(kelvin=(3000, 9100))), st(iaa.Sharpen(0, 0.1)), st(iaa.GaussianBlur((0, 1))), st(iaa.AddToHueAndSaturation((-2, 2))), st(iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.2), per_channel=True)), # add gaussian noise to images ]) for i in range(10): imgs_aug,poly_on_img_aug=seq(image=im,polygons=poly_on_img) res=poly_on_img_aug.draw_on_image(imgs_aug) a=poly_on_img_aug.to_xy_array() print(a.shape) cv2.imshow('a',res) cv2.waitKey(0)
def __init__(self): st = lambda aug: iaa.Sometimes(0.5, aug) self.seq = iaa.Sequential([ st(iaa.Pad(percent=((0, 0.2), (0, 0.2), (0, 0.2), (0, 0.2)), keep_size=False)), # #st(iaa.Crop(percent=([0.0, 0.1], [0.00, 0.1], [0.0, 0.1], [0.0, 0.1]), keep_size=False)), st(iaa.Affine(scale=(0.9, 1.0), rotate=(-30, 30), shear=(-5, 5), translate_px={"x": (-30, 30), "y": (-10, 10)}, fit_output=True)), # st(iaa.PerspectiveTransform((0,0.1),fit_output=True)), # st(iaa.MultiplyAndAddToBrightness(mul=(0.6, 1.5), add=(0, 30))), st(iaa.ChangeColorTemperature(kelvin=(3000, 9100))), st(iaa.LinearContrast((0.75, 1.5))), st(iaa.GaussianBlur((0, 0.2))), # st(iaa.PerspectiveTransform(scale=0.05,)), st(iaa.AddToHueAndSaturation((-20, 20))), # st(iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 16), per_channel=True)), # add gaussian noise to images # # # #st(iaa.Dropout((0.0, 0.1), per_channel=0.5)), # randomly remove up to 10% of the pixels # # # change brightness of images (by -10 to 10 of original value) st(iaa.Add((-40, 40), per_channel=True)), # # change brightness of images (50-150% of original value) st(iaa.Multiply((0.5, 1.5), per_channel=True)), ])
def main(): image = ia.quokka_square() images_aug = [] for kelvin in np.linspace(1000, 10000, 64): images_aug.append(iaa.ChangeColorTemperature(kelvin)(image=image)) ia.imshow(ia.draw_grid(images_aug))
def chapter_augmenters_changecolortemperature(): fn_start = "color/changecolortemperature" image = imageio.imread( os.path.join(INPUT_IMAGES_DIR, "Pahalgam_Valley.jpg")) image = ia.imresize_single_image(image, 0.2) aug = iaa.ChangeColorTemperature((1100, 10000)) run_and_save_augseq(fn_start + ".jpg", aug, [image] * 8, cols=3, rows=2)
def get_preview(images, augmentationList): """ Accepts a list of images and augmentationList as input. Provides a list of augmented images in that order as ouptut. """ augmented = [] for image in images: for augmentation in augmentationList: aug_id = augmentation['id'] params = augmentation['params'] if (aug_id == 1): image = iaa.SaltAndPepper(p=params[0], per_channel=params[1])(image=image) elif (aug_id == 2): image = iaa.imgcorruptlike.GaussianNoise( severity=(params[0], params[1]))(image=image) elif (aug_id == 3): image = iaa.Rain(speed=(params[0], params[1]), drop_size=(params[2], params[3]))(image=image) elif (aug_id == 4): image = iaa.imgcorruptlike.Fog( severity=(params[0], params[1]))(image=image) elif (aug_id == 5): image = iaa.imgcorruptlike.Snow( severity=(params[0], params[1]))(image=image) elif (aug_id == 6): image = iaa.imgcorruptlike.Spatter( severity=(params[0], params[1]))(image=image) elif (aug_id == 7): image = iaa.BlendAlphaSimplexNoise( iaa.EdgeDetect(1))(image=image) elif (aug_id == 8): image = iaa.Rotate(rotate=(params[0], params[1]))(image=image) elif (aug_id == 9): image = iaa.Affine()(image=image) #to be implemented elif (aug_id == 10): image = iaa.MotionBlur(k=params[0], angle=(params[1], params[2]))(image=image) elif (aug_id == 11): image = iaa.imgcorruptlike.ZoomBlur( severity=(params[0], params[1]))(image=image) elif (aug_id == 12): image = iaa.AddToBrightness()(image=image) #to be implemented elif (aug_id == 13): image = iaa.ChangeColorTemperature( kelvin=(params[0], params[1]))(image=image) elif (aug_id == 14): image = iaa.SigmoidContrast()(image=image) #to be implemented elif (aug_id == 15): image = iaa.Cutout(nb_iterations=(params[0], params[1]), size=params[2], squared=params[3])(image=image) else: print("Not implemented") augmented.append(image) return augmented
def generate_change_color_temperature(): ia.seed(1) image = imageio.imread( os.path.join(INPUT_IMAGES_DIR, "Pahalgam_Valley.jpg")) image = ia.imresize_single_image(image, 0.12) images_aug = [image] for kelvin in np.linspace(1000, 5000, 7): images_aug.append(iaa.ChangeColorTemperature(kelvin)(image=image)) _save("changecolortemperature.jpg", ia.draw_grid(images_aug, cols=8, rows=1))
def Random(self, n=5): seq = iaa.Sequential([ iaa.AddToHueAndSaturation((-20,30),per_channel=True), iaa.GaussianBlur(sigma=2), iaa.AdditiveGaussianNoise(scale=0.2*255), iaa.geometric.Affine(rotate=(-25, 25)), iaa.Crop(px=(0, 100)), iaa.Grayscale(alpha=(0.0, 1.0)), iaa.ChangeColorTemperature((1100, 10000)) ]) images_aug=[seq(image=self.image) for _ in range(n)] print(len(images_aug)) return images_aug, n
def img_aug(image, coordinate_lists, h, w): BoundingBox_list = [] for coordinate in coordinate_lists: BoundingBox_list.append( BoundingBox(x1=coordinate[0], y1=coordinate[1], x2=coordinate[2], y2=coordinate[3])) bbs = BoundingBoxesOnImage(BoundingBox_list, (h, w)) seq = iaa.Sequential([ iaa.ChangeColorTemperature((3000, 40000)), iaa.Affine(translate_px={"x": (-150, 150), "y": (-150, 150)}, scale=(0.5, 1.7), rotate=(-15, 15)) ]) image_aug, bbs_aug = seq(image=image, bounding_boxes=bbs) return image_aug, bbs_aug
def np_func(img, ann): # convert to imgaug keypoints keypoints = annotation_to_keypoints(img, ann) img = img.astype(np.uint8) p = 0.1 seq = iaa.Sequential([ iaa.Sometimes(p, iaa.Sequential([iaa.ShearY((-20, 20))])), iaa.Sometimes(p, iaa.ChangeColorTemperature((3500, 8000))), iaa.Sometimes(p, iaa.AddToBrightness((-15, 15))), iaa.Sometimes(p, iaa.AdditiveGaussianNoise(scale=(0, 0.03 * 255), per_channel=True)) ]) img, keypoints = seq(image=img, keypoints=keypoints) # convert from imgaug keypoints ann = keypoints_to_annotation(img, ann, keypoints) return img.astype(np.float32), ann
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))) ])
def augment_image(im): arr = np.asarray(im, dtype=np.uint8) blurer = iaa.GaussianBlur(1 + iap.Uniform(0.1, 3.0)) seq = iaa.Sequential([ #iaa.Crop(px=(1, 16), keep_size=False), iaa.Fliplr(0.5), iaa.GaussianBlur(sigma=(0, 1.0)), iaa.ChangeColorTemperature((1100, 10000)) ]) #aug = iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)) #aug = iaa.EdgeDetect(alpha=(0.0, 1.0)) #aug = iaa.ChangeColorTemperature((1100, 10000)) aug_arr = seq(images=[arr])[0] im2 = Image.fromarray(aug_arr) #im2.show() #im.show() #Image.fromarray(np.hstack((np.array(im),np.array(im2)))).show() return im2
def __init__(self, data, dtype): super().__init__(data, dtype) self.augmentationseq = iaa.Sequential([ # iaa.PerspectiveTransform(scale=(0.01, 0.08), keep_size=True), iaa.Rotate(rotate=(0, 359)), iaa.ChangeColorTemperature((3000, 10000)), iaa.Affine(scale=(0.8, 1.2)), iaa.GammaContrast((0.8, 1.2)), iaa.Resize({ 'width': WIDTH, 'height': HEIGHT }, interpolation=imgaug.ALL) ]) self.resizeseq = iaa.Sequential([ iaa.Resize({ 'width': WIDTH, 'height': HEIGHT }, interpolation=imgaug.ALL) ])
def init_augmenter(img_mode="color"): """Initializes the augmenters used in the training dataset :param config: the config object that contains all the """ ia.seed(10) if img_mode == 'color': return iaa.Sequential([ sometimes(iaa.Fliplr()), iaa.MultiplyBrightness((0.6, 1.4)), # TODO: try no ChangeColor or Brightness sometimes(iaa.ChangeColorTemperature((5000, 7000))), iaa.Crop(percent=( (0, 0.50), (0, 0.50), (0, 0.50), (0, 0.50) )) # sometimes(iaa.OneOf([ # iaa.Cutout(nb_iterations=(1, 4), size=0.2, # squared=False, cval=(0, 255), fill_mode="constant"), # iaa.Cutout(nb_iterations=(1, 4), size=0.2, squared=False, cval=( # 0, 255), fill_mode="gaussian", fill_per_channel=True), # iaa.AdditiveGaussianNoise(scale=(0, 0.1*255)) # ])) ]) else: return iaa.Sequential([ sometimes(iaa.Fliplr()), iaa.Crop(percent=( (0, 0.40), (0, 0.40), (0, 0.40), (0, 0.40) )) ])
import imgaug.augmenters as iaa import random import numpy as np import cv2 from PIL import Image aug_transform = iaa.SomeOf((0, None), [ iaa.OneOf([ iaa.MultiplyAndAddToBrightness(mul=(0.3, 1.6), add=(-50, 50)), iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True), iaa.ChannelShuffle(0.5), iaa.RemoveSaturation(), iaa.Grayscale(alpha=(0.0, 1.0)), iaa.ChangeColorTemperature((1100, 35000)), ]), iaa.OneOf([ iaa.MedianBlur(k=(3, 7)), iaa.BilateralBlur( d=(3, 10), sigma_color=(10, 250), sigma_space=(10, 250)), iaa.MotionBlur(k=(3, 9), angle=[-45, 45]), iaa.MeanShiftBlur(spatial_radius=(5.0, 10.0), color_radius=(5.0, 10.0)), iaa.AllChannelsCLAHE(clip_limit=(1, 10)), iaa.AllChannelsHistogramEqualization(), iaa.GammaContrast((0.5, 1.5), per_channel=True), iaa.GammaContrast((0.5, 1.5)), iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True), iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)), iaa.HistogramEqualization(), iaa.Sharpen(alpha=0.5)
def train_crossvalidation(**kwargs): check_args(kwargs, ['data_dir', 'saving_dir']) data_dir = kwargs.get('data_dir', None) saving_dir = kwargs.get('saving_dir', None) experiment_name = kwargs.get('experiment_name', 'model_training') learning_rate = kwargs.get('learning_rate', 0.00001) epochs = kwargs.get('epochs', 100) patience = kwargs.get('patience', 10) resnet_size = kwargs.get('resnet_size', 34) # allowed sizes: 18,34,50,101,152 num_workers = kwargs.get('num_workers', 4) batch_size = kwargs.get('batch_size', 64) weighted_loss = kwargs.get('weighted_loss', True) sample = kwargs.get('sample', 1.0) img_aug = kwargs.get('img_aug', 0.5) if not img_aug: img_aug_seq = None else: sometimes = lambda augmentation: iaa.Sometimes(img_aug, augmentation) img_aug_seq = iaa.Sequential([ iaa.Fliplr(img_aug), sometimes(iaa.ChangeColorTemperature((1100, 10000))), sometimes( iaa.OneOf([ iaa.GaussianBlur(sigma=(0, 2.0)), iaa.AddToHueAndSaturation((-10, 10)) ])) ]) create_dir(saving_dir) experiment_path = os.path.join(saving_dir, experiment_name) create_dir(experiment_path) #load data df = path2DataFrame(data_dir) df = df.groupby('category').apply(lambda x: x.sample(frac=sample)) #remove after testing #df = df.sample(frac=0.1) X = df['file_path'].values y = df['category'].values y_encoded, class_index_dict = label_encoding(y) n_classes = len(class_index_dict) # GPU or CPU device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(device) #set loss if weighted_loss: weights = get_class_weights(y_encoded, class_index_dict) loss_function = nn.CrossEntropyLoss( reduction='sum', weight=torch.FloatTensor(weights).to(device)) else: loss_function = nn.CrossEntropyLoss(reduction='sum') data_splits = make_train_val_test_splits( X, y_encoded, img_aug=img_aug_seq, num_workers=num_workers, batch_size=batch_size, splits=10, ) #crossvalidation for i, split in enumerate(data_splits): print(f'split {i}\n') split_path = os.path.join(experiment_path, f'split_{i}') create_dir(split_path) trainloader = split['trainloader'] valloader = split['valloader'] testloader = split['testloader'] print('size train: {}'.format(len(trainloader.dataset))) print('size val: {}'.format(len(valloader.dataset))) print('size test: {}'.format(len(testloader.dataset))) save_class_index(class_index_dict, split_path) #initialize model model = ResNet(resnet_size, n_classes).to(device) #set optimizer optimizer = optim.Adam(model.parameters(), lr=learning_rate) model, history = train(model=model, loss_function=loss_function, optimizer=optimizer, trainloader=trainloader, valloader=valloader, device=device, saving_dir=split_path, epochs=epochs, patience=patience) # evaluate on test data metrics_dict, ground_truth_list, predictions_list, test_images_list = evaluate( model=model, dataloader=testloader, device=device, loss_function=loss_function) #generate heatmaps using GradCAM for some test images save_XAI(model=model, test_images_list=test_images_list, ground_truth_list=ground_truth_list, predictions_list=predictions_list, saving_dir=split_path, device=device, class_index_dict=class_index_dict) #print test metrics for k, v in metrics_dict.items(): print(f'{k}_test: {v}') #save training history experiment = Experiment() experiment.add('class_index_dict', class_index_dict) experiment.add('model', model) experiment.add('resnet_size', resnet_size) for k, v in metrics_dict.items(): experiment.add(f'{k}_test', v) for k, v in history.items(): experiment.add(k, v) experiment.save(split_path) return
alpha_face=0.0, color_lines=(255, 0, 0)) #image_with_polygon, alpha_points=0, alpha_face=0.5, color_lines=(255, 0, 0)) if not os.path.exists(vis_dir): os.makedirs(vis_dir) save_path = os.path.join( vis_dir, self.images_name[i] + '_polygon' + '.' + self.images_format[i]) cv2.imwrite(save_path, image_with_polygon) ''' changes the color temperature of images to a random value between 1100 and 10000 Kelvin ''' aug_colorTemperature = iaa.ChangeColorTemperature((1100, 10000)) ''' Convert each image to a colorspace with a brightness-related channel, extract that channel, multiply it by a factor between 0.5 and 1.5, add a value between -30 and 30 and convert back to the original colorspace ''' aug_brightness = iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)) ''' Multiply the hue and saturation of images by random values; Sample random values from the discrete uniform range [-50..50],and add them ''' aug_hueSaturation = [ iaa.MultiplyHue((0.5, 1.5)), iaa.MultiplySaturation((0.5, 1.5)), iaa.AddToHue((-50, 50)), iaa.AddToSaturation((-50, 50))
seq = iaa.Sequential([ iaa.Fliplr(p=0),# basically this is original one iaa.Crop(px=(22, 45),keep_size=False), # crop images from each side by 0 to 16px (randomly chosen) iaa.Fliplr(1), # horizontally flip 50% of the images iaa.GaussianBlur(sigma=(5, 7.0)), # blur images with a sigma of 0 to 3.0 iaa.ImpulseNoise(p=(0.6,1)), iaa.EdgeDetect(alpha=(0.9,1)), #iaa.AddToBrightness(add=(100,124)), iaa.Canny(alpha=(0.8,0.9)), iaa.Grayscale(alpha=1.00), iaa.ChannelShuffle(p=1), iaa.geometric.Affine( scale=2,rotate=22, backend='cv2'), iaa.Cartoon(blur_ksize=(11,13)), iaa.CenterCropToAspectRatio(1), iaa.CenterCropToFixedSize(100,100), iaa.ChangeColorTemperature(kelvin=(2222,3333)), #iaa.segmentation(), iaa.CLAHE(clip_limit=(4,8)), iaa.Rotate(rotate=(-30,90)) ]) plt.figure(figsize=(12,12)) for idx,Augmentor in enumerate(seq): # print(1) ax=plt.subplot(4,4,idx+1) ax.axis('off') plt.tight_layout() title=str(Augmentor).split('(')[0] #plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, # hspace = 0.2, wspace = 0)
start_at=(0.8, 1), end_at=(0, 0.2)), iaa.BlendAlphaVerticalLinearGradient(iaa.Add( iap.Normal(iap.Choice([-40, 40]), 10)), start_at=(0, 0.2), end_at=(0.8, 1)), # Change contrast iaa.SigmoidContrast(gain=(3, 9), cutoff=(0.3, 0.7)), iaa.LinearContrast((0.4, 1.6)), iaa.GammaContrast((0.5, 2)), iaa.LogContrast(gain=(0.5, 1.5)), iaa.pillike.Autocontrast((2, 5)), iaa.Emboss(alpha=(0.1, 1), strength=(1, 2)), ]), ), iaa.Sometimes(0.25, iaa.ChangeColorTemperature((4000, 12000))), # Blur + compress iaa.Sometimes( 0.15, iaa.OneOf([ iaa.imgcorruptlike.Pixelate(severity=(1, 2)), # iaa.imgcorruptlike.JpegCompression(severity=(1, 3)), iaa.UniformColorQuantization(n_colors=(20, 100)), iaa.AveragePooling((2, 3)), iaa.GaussianBlur((1, 2)), iaa.MotionBlur((3, 5)), iaa.imgcorruptlike.DefocusBlur(severity=(1)), iaa.pillike.EnhanceSharpness(), iaa.pillike.FilterSmoothMore(), ])), ])
# plt.figure(figsize=(10,10)) # plt.imshow(im1, cmap='gray') # plt.axis('off') # plt.show() # exit() aug_seq = iaa.Sequential([ iaa.Resize({ "height": 72 * 5, "width": 128 * 5 }), iaa.MultiplyAndAddToBrightness(mul=(0.9, 1.1), add=0), # 가우시안 필터는 scale 0이 정상 0~15사이인데 정상이 중간값으로 진행되지 않습니다. iaa.SigmoidContrast(gain=5, cutoff=0.35), iaa.GammaContrast((0.9, 1.1), per_channel=True), iaa.ChangeColorTemperature(kelvin=(8000, 12000)), iaa.MultiplyHueAndSaturation((0.8, 1.1), per_channel=True), iaa.Resize({ "height": 720, "width": 1280 }), iaa.Sometimes( 0.5, iaa.Sequential([ iaa.MotionBlur(k=15, angle=[-90, 90]), iaa.AdditiveGaussianNoise(scale=(0, 15)), ])) ]) # dft = cv2.dft(np.float32(gray_img),flags = cv2.DFT_COMPLEX_OUTPUT) # dft_shift = np.fft.fftshift(dft)
def __getitem__(self, idx): img = self.file['data'][idx] img = cv2.resize(src=img, dsize=(self.img_w, self.img_h)) gt_map = self.file['gt'][idx] gt_map = cv2.resize(src=gt_map, dsize=(self.img_w, self.img_h)).astype('int32') gt_map = cv2.flip( gt_map, 0) # flip gt_cause origin DeepLab produces flipped output if self.mode == 'test': # normalized_img = img / img.max() # norm_img = np.divide(normalized_img - self.mean_mat, self.std_mat) norm_img = (2 * (img / 255)) - 1 # gt_one_hot = (np.arange(self.num_of_classes) == gt_map[..., None]).astype(int) return { 'image': np.moveaxis(norm_img, -1, 0), # 'gt': np.moveaxis(gt_one_hot, -1, 0), 'gt_reg_map': gt_map, 'idx': idx } else: segmap = SegmentationMapsOnImage(gt_map, shape=img.shape) seq = iaa.Sequential([ # iaa.CropToFixedSize(width=self.crop_w, height=self.crop_h), sometimes( iaa.OneOf([ iaa.GaussianBlur((0, 3.0)), iaa.AverageBlur(k=(2, 4)), ])), sometimes(iaa.ChangeColorTemperature((1100, 10000))), sometimes( iaa.OneOf([ iaa.Add((-10, 10), per_channel=0.5), iaa.Multiply((0.85, 1.15), per_channel=0.5) ])), # iaa.OneOf([iaa.GammaContrast((0.5, 2.0)), # iaa.GammaContrast((0.5, 2.0), per_channel=True), # iaa.LogContrast(gain=(0.6, 1.4))]), # sometimes(iaa.JpegCompression(compression=(80, 99))), # sometimes(iaa.CropAndPad(percent=(-0.5, 0.5))), sometimes(iaa.Grayscale(alpha=(0.0, 1.0))) ]) # pdb.set_trace() augmented_img, augmented_map = seq(image=img.astype('uint8'), segmentation_maps=segmap) augmented_map = augmented_map.arr[..., 0] # flip - lr: if np.random.uniform() > 0.5: augmented_img = cv2.flip(augmented_img, 1) augmented_map = cv2.flip(augmented_map, 1) # normalized_img = np.true_divide(augmented_img, augmented_img.max()) # norm_img = np.true_divide(normalized_img - self.mean_mat, self.std_mat) norm_img = (2 * (augmented_img / 255)) - 1 # gt_one_hot = (np.arange(self.num_of_classes) == augmented_map[..., None]).astype(int) # pdb.set_trace() sample = { 'image': np.moveaxis(norm_img, -1, 0), # 'gt': np.moveaxis(gt_one_hot, -1, 0), 'gt_reg_map': augmented_map, 'idx': idx } return sample
transformed_image = transform(image=image)['image'] elif augmentation == 'to_sepia': transform = ToSepia(always_apply=True) transformed_image = transform(image=image)['image'] elif augmentation == 'fancy_pca': transform = FancyPCA(always_apply=True, alpha=1.0) transformed_image = transform(image=image)['image'] elif augmentation == 'rgb_shift': transform = RGBShift(always_apply=True) transformed_image = transform(image=image)['image'] elif augmentation == 'change_color_temperature': transform = iaa.ChangeColorTemperature((1100, 10000)) transformed_image = transform(image=image) elif augmentation == 'kmeans_color_quantization': transform = iaa.KMeansColorQuantization() transformed_image = transform(image=image) elif augmentation == 'uniform_color_quantization': transform = iaa.UniformColorQuantization() transformed_image = transform(image=image) elif augmentation == 'channel_shuffle': transform = ChannelShuffle(always_apply=True) transformed_image = transform(image=image)['image'] ## Contrast
to_colorspace="HSV", from_colorspace="RGB", children=iaa.WithChannels(0,iaa.Add((0, 50)))) aug40 = iaa.WithHueAndSaturation( iaa.WithChannels(0, iaa.Add((0, 50)))) aug41 = iaa.MultiplyHueAndSaturation((0.5, 1.9), per_channel=True) aug42 = iaa.AddToHueAndSaturation((-50, 50), per_channel=True) aug43 = iaa.AddToHue((-50, 50)) aug44 = iaa.AddToSaturation((-50, 50)) aug45 = iaa.Sequential([ iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"), iaa.WithChannels(0, iaa.Add((50, 100))), iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB")]) aug46 = iaa.Grayscale(alpha=(0.0, 1.0)) aug47 = iaa.ChangeColorTemperature((1100, 10000)) aug49 = iaa.UniformColorQuantization() aug50 = iaa.UniformColorQuantizationToNBits() aug51 = iaa.GammaContrast((0.5, 2.0), per_channel=True) aug52 = iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True) aug53 = iaa.LogContrast(gain=(0.6, 1.4), per_channel=True) aug54 = iaa.LinearContrast((0.4, 1.6), per_channel=True) # aug55 = iaa.AllChannelsCLAHE(clip_limit=(1, 10), per_channel=True) aug56 = iaa.Alpha((0.0, 1.0), iaa.AllChannelsHistogramEqualization()) aug57 = iaa.HistogramEqualization( from_colorspace=iaa.HistogramEqualization.BGR, to_colorspace=iaa.HistogramEqualization.HSV) aug58 = iaa.DirectedEdgeDetect(alpha=(0.0, 0.5), direction=(0.0, 0.5)) aug59 = iaa.Canny( alpha=(0.0, 0.3),
seq = iaa.Sequential([ iaa.Fliplr(p=0),# basically this is original one iaa.Sometimes(0.05,(iaa.Crop(px=(22, 45),keep_size=True))), # crop images from each side by 0 to 16px (randomly chosen) iaa.Sometimes(0.5,(iaa.Fliplr(1))), # horizontally flip 50% of the images iaa.Sometimes(0.02,iaa.GaussianBlur(sigma=(5, 7.0))), # blur images with a sigma of 0 to 3.0 iaa.Sometimes(0.02 ,iaa.ImpulseNoise(p=(0.6,1))), iaa.Sometimes(0.02 ,iaa.EdgeDetect(alpha=(0.09,1))), #iaa.AddToBrightness(add=(100,124)), iaa.Sometimes(0.02 ,iaa.Canny(alpha=(0.8,0.9))), iaa.Sometimes(0.5 ,iaa.Grayscale(alpha=1.00)), iaa.Sometimes(0.5 ,iaa.ChannelShuffle(p=1)), #iaa.Sometimes(0.02 ,(iaa.geometric.Affine( scale=2,rotate=22,order=1))), iaa.Sometimes(0.5 ,iaa.Cartoon(blur_ksize=(11,13))), iaa.Sometimes(0.02 ,iaa.CenterCropToAspectRatio(1)), iaa.Sometimes(0.02 ,iaa.CenterCropToFixedSize(100,100)), iaa.Sometimes(0.12 ,iaa.ChangeColorTemperature(kelvin=(2222,3333))), #iaa.segmentation(), iaa.Sometimes(0.12 ,iaa.CLAHE(clip_limit=(4,8))), iaa.Sometimes(0.8 ,iaa.Rotate(rotate=(-90,90),order=1)) ]) plt.figure(figsize=(12,12)) ls=glob.glob(path) res=[] for idx,l in enumerate(ls): res.append(Parser.myType(l,idx,classes=['bird','zebra'])) def our_generator(res):
def __init__(self, ColorTemperature=None): self.ColorTemperature = ColorTemperature self.seq = iaa.Sequential([ iaa.ChangeColorTemperature((4300, 6000)), ])
def ColorTemperature(self): temp = iaa.ChangeColorTemperature((1100, 10000)) image_temp = temp.augment_images([self.image]) return image_temp[0]
import numpy as np import cv2 import imgaug as ia from imgaug import augmenters as iaa from imgaug.augmentables import Keypoint, KeypointsOnImage sometimes = lambda aug: iaa.Sometimes(0.5, aug) KPT_AUGS = [ iaa.LinearContrast((0.95, 1.05), per_channel=0.25), iaa.Add((-10, 10), per_channel=False), iaa.GammaContrast((0.95, 1.05)), iaa.GaussianBlur(sigma=(0.0, 0.6)), iaa.MultiplySaturation((0.95, 1.05)), iaa.AddToHueAndSaturation((-255, 255)), iaa.ChangeColorTemperature((1000, 20000)), iaa.AdditiveGaussianNoise(scale=(0, 0.0125 * 255)), iaa.flip.Flipud(0.5), sometimes( iaa.Affine( scale={ "x": (0.8, 1.2), "y": (0.8, 1.2) }, # scale images to 80-120% of their size, individually per axis translate_percent={ "x": (-0.25, 0.25), "y": (-0.2, 0.2) }, # translate by -20 to +20 percent (per axis) rotate=(-30, 30), # rotate by -45 to +45 degrees shear=(-10, 10), # shear by -16 to +16 degrees order=[0, 1
import numpy as np from imgaug import augmenters as iaa from torch.utils.data import DataLoader, Dataset from torchvision import transforms from skimage import io import os tfs = transforms.Compose([ iaa.Sequential([ iaa.Sometimes(0.5, iaa.Fliplr(1.0)), iaa.Sometimes(0.5, iaa.MultiplyBrightness((0.3, 1.3))), iaa.Sometimes(0.2, iaa.ChangeColorTemperature((4300, 6000))), #iaa.Sometimes(0.9, iaa.Affine(rotate=(-180, 180), shear=(-6, 6))), ]).augment_image, transforms.ToTensor() ]) class CustomDataset(Dataset): def __init__(self, n_images, n_classes=15, transform=None): self.images = [] self.transform = transform test_path = "/content/gdrive/My Drive/Arirang/data/test/images" file_list = os.listdir(test_path) file_list_png = [file for file in file_list if file.endswith(".png")] for idx, filename in enumerate(file_list_png): self.images.append( os.path.join(test_path, filename))
def _write_tfrecord(dataset_split, anno_lines): labels_list = [] width_list = [] long_label = [] long_pic = [] if not os.path.exists(FLAGS.data_dir): os.makedirs(FLAGS.data_dir) if not FLAGS.aug: fix = '.tfrecord' else: if FLAGS.MotionBlur: fix = '_motion_blur.tfrecord' if FLAGS.ColorTemp: fix = '_color_temp.tfrecord' if FLAGS.HUE: fix = '_hue.tfrecord' tfrecords_path = os.path.join(FLAGS.data_dir, dataset_split + '-' + cfg.Lang + '-' + time.strftime("%Y-%m-%d_%H-%M-%S", time.localtime(time.time())) + fix) # 记录tfrecord信息,图片最大宽度 tfrecord_info = open(os.path.join(FLAGS.data_dir, 'info.txt'), 'a+', encoding='utf8') with tf.python_io.TFRecordWriter(tfrecords_path) as writer: for i, line in enumerate(anno_lines): line = line.strip() image_name, label = parse_textrender_label(line) if label == '卍': continue # 如果label中含有模糊行,整行过滤 if '###' in label: continue ########## !!!!暂时处理,需要删去 ############# if 'ô' in label: continue ########################################## # 阿拉伯语label要特殊处理 if cfg.Lang == 'AB': label = label[::-1] # label最大字符长度,超过此长度过滤 if len(label) > FLAGS.max_label_lenth: continue # label最短字符长度,小于此长度过滤 if len(label) < FLAGS.min_label_lenth: continue image_path = os.path.join(FLAGS.image_dir, image_name) image = cv2.imread(image_path) if image is None: continue # skip bad image. h, w, c = image.shape if w > h: height = _IMAGE_HEIGHT width = int(w * height / h) labels_list.append(len(label)) width_list.append(width) image = cv2.resize(image, (width, height)) if not FLAGS.aug: is_success, image_buffer = cv2.imencode('.jpg', image) else: if FLAGS.MotionBlur: aug = iaa.MotionBlur(k = 10, angle = np.random.randint(-45, 45)) if FLAGS.ColorTemp: aug = iaa.ChangeColorTemperature((1100, 10000)) if FLAGS.HUE: aug = iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True) img_aug = aug(image = image) is_success, image_buffer = cv2.imencode('.jpg', img_aug) if not is_success: continue # convert string object to bytes in py3 image_name = image_name if sys.version_info[0] < 3 else image_name.encode('utf-8') features = tf.train.Features(feature={ 'labels': _int64_feature(_string_to_int(label)), 'images': _bytes_feature(image_buffer.tostring()), 'imagenames': _bytes_feature(image_name) }) example = tf.train.Example(features=features) writer.write(example.SerializeToString()) sys.stdout.write('\r>>Writing to {:s}.tfrecords {:d}/{:d}'.format(dataset_split, i + 1, len(anno_lines))) sys.stdout.flush() sys.stdout.write('\n') sys.stdout.write('>> {:s}.tfrecords write finish.\n'.format(dataset_split)) sys.stdout.flush() if width_list: tfrecord_info.write('{}: {}\n'.format(tfrecords_path.split('/')[-1], max(width_list)))
def __iter__(self): data = [] labels = [] if self.mode == 'train': data = self.data_files labels = self.label_files elif self.mode == 'eval': data = self.eval_files labels = self.eval_labels elif self.mode == 'test': data = self.test_files data_size = len(data) if self.mode == 'test': input_batch = torch.zeros([1, 3, self.input_height, self.input_width], dtype=torch.float32) else: input_batch = torch.zeros([self.batch_size, 3, self.input_height, self.input_width], dtype=torch.float32) target_batch = torch.zeros([self.batch_size, 1, self.input_height, self.input_width], dtype=torch.float32) if self.mode == 'test': current = 0 while current < data_size: data_image_orig = cv2.imread(data[current]) data_image_orig = cv2.resize(data_image_orig, (self.input_width, self.input_height), interpolation=cv2.INTER_NEAREST) input_batch[0, :, :, :] = self.normalize(data_image_orig) yield input_batch, data[current] current += 1 else: current = 0 while current < data_size: count = 0 while count < self.batch_size and current < data_size: # print(data[current]) # print(labels[current]) data_image_orig = cv2.imread(data[current]) label_image_orig = cv2.imread(labels[current], cv2.IMREAD_GRAYSCALE) # Resizing data_image_orig = cv2.resize(data_image_orig, (self.input_width, self.input_height), interpolation=cv2.INTER_NEAREST) # To crop change to 572 and un comment next line # To not crop 388 (check assignment chart again) #label_image_orig = label_image_orig.resize((388,388)) label_image_orig = cv2.resize(label_image_orig, (self.input_width, self.input_height), interpolation=cv2.INTER_NEAREST) _, label_image_orig = cv2.threshold(label_image_orig, 127, 255, cv2.THRESH_BINARY) ## AUGMENTATION ## # img_size = np.shape(label_image_orig) # segmap = np.zeros(img_size, dtype=np.uint8) # segmap[:] = label_image_orig # segmap = SegmentationMapOnImage(segmap, shape=img_size) segmap = SegmentationMapsOnImage(label_image_orig, shape=np.shape(label_image_orig)) # Augementation pipeline # pipeline = iaa.Sometimes( # 0.7, pipeline = iaa.OneOf([ iaa.Affine(scale=(0.5, 1.5)), iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), iaa.WithBrightnessChannels(iaa.Add((-50, 50))), iaa.WithHueAndSaturation(iaa.WithChannels(0, iaa.Add((0, 50)))), iaa.ChangeColorTemperature((1100, 10000)), iaa.GammaContrast((0.5, 2.0)) ]) # ) if random.random() > 0.3: if random.random() > 0.4: data_image_aug, label_image_aug = pipeline(image = data_image_orig, segmentation_maps=segmap) label_image_aug = label_image_aug.get_arr() else: data_image_aug = self.warming_transform(data_image_orig) label_image_aug = label_image_orig else: data_image_aug = data_image_orig label_image_aug = label_image_orig # data_image_aug = data_image_aug.transpose((2, 0, 1)) # label_image_aug = np.expand_dims(label_image_aug.get_arr(), axis=0).astype('uint8') input_batch[count, :, :, :] = self.normalize(data_image_aug) # label_image_aug = label_image_aug.get_arr() // 255 # label_image_aug = label_image_aug.astype('uint8') # target_batch[count, :, :] = torch.from_numpy(label_image_aug).long() label_image_aug = np.expand_dims(label_image_aug.astype(np.float32) / 255.0, axis=0) target_batch[count, :, :, :] = torch.from_numpy(label_image_aug) count += 1 current += 1 yield input_batch, target_batch