def create_image_and_mask_augmenter(): aug = iaa.SomeOf( (0, None), [ iaa.Noop(), iaa.Scale((0.75, 1.0)), iaa.CropAndPad(percent=(-0.25, 0.25)), iaa.Affine(translate_px={ "x": (-20, 20), "y": (-20, 20) }), #iaa.PiecewiseAffine(scale=(0.01, 0.05)), iaa.Fliplr(1), iaa.Flipud(1) ]) return aug
def get_training_augmenter(height, width, augmenter_level): """ Get validation augmenter according to the level of stochasticity added """ aug = iaa.Sequential( [ iaa.Fliplr(0.5), # horizontal flips *get_noise_augmenters(augmenter_level), # noisy heavy or simple iaa.Scale({ "height": height, "width": width }) ], random_order=True) # apply augmenters in random order return aug
def inference_rgb(self, img_data, orgshape): scale = (orgshape[0] * 1.0 / self.inres[0], orgshape[1] * 1.0 / self.inres[1]) img_scale = iaa.Scale({ "height": self.inres[0], "width": self.inres[1] }) img_data = img_scale.augment_image(img_data) img_data = dg.normalize_img(img_data) input = img_data[np.newaxis, :, :, :] out = self.model.predict(input) if self.num_hgstacks > 1: out = out[-1] return out, scale
def __init__(self): self.augmentor_pipeline = Pipeline() self.augmentor_pipeline.add_operation( Operations.Crop(probability=1, width=64, height=64, centre=False)) self.augmentor_pipeline.add_operation( Operations.Resize(probability=1, width=512, height=512, resample_filter="BILINEAR")) self.imgaug_transform = iaa.Sequential([ iaa.CropToFixedSize(width=64, height=64), iaa.Scale(size=512, interpolation="linear") ]) self.solt_stream = slc.Stream([ slt.CropTransform(crop_size=(64, 64), crop_mode="r"), slt.ResizeTransform(resize_to=(512, 512)) ])
def iaa_letterbox(img, new_dim): if isinstance(img, tuple): org_dim = img else: org_dim = img.shape[1], img.shape[0] padded_w, padded_h, x_pad, y_pad, ratio = letterbox_transforms( *org_dim, *new_dim) l_pad, r_pad = x_pad, new_dim[0] - padded_w - x_pad t_pad, b_pad = y_pad, new_dim[1] - padded_h - y_pad lb_reverter = np.array( [org_dim[0], org_dim[1], padded_w, padded_h, x_pad, y_pad]) return iaa.Sequential([iaa.Scale({ "width": padded_w, "height": padded_h }), iaa.Pad(px=(t_pad, r_pad, b_pad, l_pad), keep_size=False, pad_cval=128), ]), \ lb_reverter
def get_imgaug_sequence_for_camvid(width=None, height=None): if height is not None and width is not None: seq = iaa.Sequential([ iaa.SomeOf(1, [ #iaa.Sometimes(0.5, iaa.Crop(px=(0, 100))), # Crop images from each side by 0 to 16px (randomly chosen). iaa.Sometimes(0.5, iaa.Crop(percent=(0, 0.25))), # Crop images by 0-10% of their height/width. iaa.Fliplr(0.5), # Horizontally flip 50% of the images. iaa.Flipud(0.5), # Vertically flip 50% of the images. iaa.Sometimes(0.5, 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.2, 0.2), 'y': (-0.2, 0.2)}, # Translate by -20 to +20 percent (per axis). rotate=(-45, 45), # Rotate by -45 to +45 degrees. shear=(-16, 16), # Shear by -16 to +16 degrees. #order=[0, 1], # Use nearest neighbour or bilinear interpolation (fast). order=0, # Use nearest neighbour or bilinear interpolation (fast). #cval=(0, 255), # If mode is constant, use a cval between 0 and 255. #mode=ia.ALL # Use any of scikit-image's warping modes. mode='reflect' # Use any of scikit-image's warping modes. )) #iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0, 3.0))) # Blur images with a sigma of 0 to 3.0. ]), iaa.Scale(size={'height': height, 'width': width}, interpolation='nearest') # Resize. ]) else: seq = iaa.Sequential( iaa.SomeOf(1, [ #iaa.Sometimes(0.5, iaa.Crop(px=(0, 100))), # Crop images from each side by 0 to 16px (randomly chosen). iaa.Sometimes(0.5, iaa.Crop(percent=(0, 0.1))), # Crop images by 0-10% of their height/width. iaa.Fliplr(0.5), # Horizontally flip 50% of the images. iaa.Flipud(0.5), # Vertically flip 50% of the images. iaa.Sometimes(0.5, 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.2, 0.2), 'y': (-0.2, 0.2)}, # Translate by -20 to +20 percent (per axis). rotate=(-45, 45), # Rotate by -45 to +45 degrees. shear=(-16, 16), # Shear by -16 to +16 degrees. #order=[0, 1], # Use nearest neighbour or bilinear interpolation (fast). order=0, # Use nearest neighbour or bilinear interpolation (fast). #cval=(0, 255), # If mode is constant, use a cval between 0 and 255. #mode=ia.ALL # Use any of scikit-image's warping modes. mode='reflect' # Use any of scikit-image's warping modes. )) #iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0, 3.0))) # Blur images with a sigma of 0 to 3.0. ]) ) return seq
def modify_image_train(img, bb): img_height, img_width = img.shape[0], img.shape[1] x_min, y_min, width, height = bb x1, y1, x2, y2 = to_imgaugbb(x_min, y_min, width, height) bb_array = ia.BoundingBoxesOnImage([ia.BoundingBox(x1, y1, x2, y2)], shape=(img_height, img_width)) rgb_img = skimage.color.gray2rgb(img) imagenet_height, imagenet_width = 224, 224 seq = iaa.Sequential( [iaa.Scale({ "height": imagenet_height, "weight": imagenet_width })]) seq_det = seq.to_deterministic() image_aug = seq_det.augment_images([rgb_img])[0] bbs_aug = seq_det.augment_bounding_boxes([bb_array])[0] return image_aug, bbs_aug
def _scale(self, image: np.ndarray, bboxes: np.ndarray) -> Tuple[np.ndarray, ia.BoundingBoxesOnImage]: seq_lst = [ iaa.Affine(scale=0.7, mode='edge'), # scale image, preserving original image shape ] if self.resize is not None: seq_lst.append(iaa.Scale({"height": self.resize[0], "width": self.resize[1]})) seq = iaa.Sequential(seq_lst) bbs = self._ndarray_to_BoundingBoxesOnImage(bboxes, image.shape) # Make our sequence deterministic. # We can now apply it to the image and then to the BBs and it will lead to the same augmentations. seq_det = seq.to_deterministic() image_aug = seq_det.augment_images([image])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] return image_aug, bbs_aug
def __init__(self): self.aug = iaa.Sequential([ iaa.Scale((224, 224)), iaa.Sometimes(0.30, iaa.GaussianBlur(sigma=(0, 3.0))), iaa.Sometimes(0.25, iaa.Multiply((0.5, 1.5), per_channel=0.5)), iaa.Sometimes(0.20, iaa.Invert(0.25, per_channel=0.5)), iaa.Sometimes(0.25, iaa.ReplaceElementwise( iap.FromLowerResolution(iap.Binomial(0.1), size_px=8), iap.Normal(128, 0.4*128), per_channel=0.5) ), iaa.Sometimes(0.30, iaa.AdditivePoissonNoise(40)), iaa.Fliplr(0.5), iaa.Affine(rotate=(-20, 20), mode='symmetric'), iaa.Sometimes(0.30, iaa.OneOf([iaa.Dropout(p=(0, 0.1)), iaa.CoarseDropout(0.1, size_percent=0.5)])), iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True) ])
def __init__(self): self.aug = iaa.Sequential([ iaa.Scale((224, 224)), iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 3.0))), iaa.Affine(rotate=(-20, 20), mode='constant'), iaa.Sometimes( 0.25, iaa.OneOf([ iaa.Dropout(p=(0, 0.1)), iaa.CoarseDropout(0.1, size_percent=0.5), iaa.Sharpen(alpha=0.5) ])), iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True), iaa.Sometimes(0.15, iaa.WithChannels(0, iaa.Add((10, 100)))), iaa.Sometimes( 0.05, iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV")) ])
def _fliplr(self, image: np.ndarray, bboxes: np.ndarray) -> Tuple[np.ndarray, ia.BoundingBoxesOnImage]: seq_lst = [ iaa.Fliplr(1.0), # horizontally flip ] if self.resize is not None: seq_lst.append(iaa.Scale({"height": self.resize[0], "width": self.resize[1]})) seq = iaa.Sequential(seq_lst) bbs = self._ndarray_to_BoundingBoxesOnImage(bboxes, image.shape) # Make our sequence deterministic. # We can now apply it to the image and then to the BBs and it will lead to the same augmentations. seq_det = seq.to_deterministic() image_aug = seq_det.augment_images([image])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] return image_aug, bbs_aug
def _resize(self, image: np.ndarray, bboxes: np.ndarray): if self.resize is None: raise Exception('--resize option has not been specified but self.resize() ' 'method was invoked; script logic error') seq_lst = [ iaa.Scale({"height": self.resize[0], "width": self.resize[1]}), # resize not preserving the aspect ratio ] seq = iaa.Sequential(seq_lst) bbs = self._ndarray_to_BoundingBoxesOnImage(bboxes, image.shape) # Make our sequence deterministic. # We can now apply it to the image and then to the BBs and it will lead to the same augmentations. seq_det = seq.to_deterministic() image_aug = seq_det.augment_images([image])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] return image_aug, bbs_aug
def predict_on_image(model, args): # pre-processing on image image = cv2.imread(args.data, -1) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) resize = iaa.Scale({'height': args.crop_height, 'width': args.crop_width}) resize_det = resize.to_deterministic() image = resize_det.augment_image(image) image = Image.fromarray(image).convert('RGB') image = transforms.ToTensor()(image).unsqueeze(0) # read csv label path label_info = get_label_info(args.csv_path) # predict model.eval() predict = model(image).squeeze() predict = reverse_one_hot(predict) predict = colour_code_segmentation(np.array(predict), label_info) predict = cv2.resize(np.uint8(predict), (960, 720)) cv2.imwrite(args.save_path, cv2.cvtColor(np.uint8(predict), cv2.COLOR_RGB2BGR))
def __init__(self, image_size): self.image_size = image_size self.data = glob.glob( '/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/xair/land_19_bk/*/*.json' ) self.class_mapix = dict(zip(labels, range(len(labels)))) self.aug = iaa.Sequential([ iaa.Flipud(0.5), iaa.Fliplr(0.5), iaa.Affine( scale={ "x": (0.9, 1.1), "y": (0.9, 1.1) }, rotate=(-30, 30), ), ]) self.factor = iaa.Sequential([ iaa.Scale(size=(128, 128)), ])
def aligner_preprocessing(img, target, crop_coordinates, augmentation, target_size, bins_nr): height, width = target_size keypoints = ia.KeypointsOnImage([ ia.Keypoint(x=int(target.bonnet_x), y=int(target.bonnet_y)), ia.Keypoint(x=int(target.blowhead_x), y=int(target.blowhead_y)) ], shape=img.shape) crop = CropKeypoints(crop_coordinates).to_deterministic() scale = iaa.Scale({"height": height, "width": width}).to_deterministic() augmenter = iaa.Sequential([ iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.Affine(translate_px={ "x": (-4, 4), "y": (-4, 4) }, rotate=(-180, 180), scale=(1.0, 1.5)), ]).to_deterministic() if augmentation: transformations = [crop, augmenter, scale] else: transformations = [crop, scale] transformer = iaa.Sequential(transformations).to_deterministic() aug_X = transformer.augment_image(img) aug_points = transformer.augment_keypoints([keypoints]) aug_points_formatted = np.reshape(aug_points[0].get_coords_array(), -1).astype(np.float) aug_points_binned = bin_quantizer(aug_points_formatted, (height, width), bins_nr) aug_target_binned = np.hstack( [aug_points_binned, target[ALIGNER_AUXILARY_COLUMNS].values]) return aug_X, aug_target_binned
def augment_images(images, boxes): boxes_augs = [] for box1 in boxes: for box in box1: boxes_augs.append( ia.BoundingBox(x1=box[0], y1=box[1], x2=box[2], y2=box[3])) bbs = ia.BoundingBoxesOnImage(boxes_augs, shape=images[0].shape) seq = iaa.Sequential([ iaa.Scale(400), ]) seq_det = seq.to_deterministic( ) # Call this once PER BATCH, otherwise you will always get the to get random images_data = images # for i,img in enumerate(images): # images_data[i,:,:,:]=img[:,:,:] image_augs = seq_det.augment_images(images_data) bbs_augs = seq_det.augment_bounding_boxes([bbs]) return (image_augs, bbs_augs)
def edit_image(image_name): image = read_as_pil_image(image_name) if config.IMAGE_SCALE != 1: image = apply_effect(image, augmenters.Scale(config.IMAGE_SCALE)) if config.IMAGE_ROTATION != 0: image = image.rotate(config.IMAGE_ROTATION) if config.IMAGE_SHEAR != 0: image = apply_effect(image, augmenters.Affine(shear=config.IMAGE_SHEAR)) if config.IMAGE_BLUR > 0: image = apply_effect(image, augmenters.GaussianBlur(sigma=config.IMAGE_BLUR)) if config.IMAGE_SHARPEN != 0: image = apply_effect( image, augmenters.Sharpen(alpha=config.IMAGE_SHARPEN, lightness=1.0)) if config.IMAGE_EMBOSS != 0: image = apply_effect( image, augmenters.Emboss(alpha=config.IMAGE_EMBOSS, strength=1.0)) if config.IMAGE_DISTORTIONS != 0: image = apply_effect( image, augmenters.PiecewiseAffine(scale=config.IMAGE_DISTORTIONS)) if config.IMAGE_PIXEL_DISPLACEMENT != 0: image = apply_effect( image, augmenters.ElasticTransformation( alpha=config.IMAGE_PIXEL_DISPLACEMENT, sigma=0.25)) if config.IMAGE_BRIGHTNESS_INCREMENT != 1: image = ImageEnhance.Brightness(image).enhance( config.IMAGE_BRIGHTNESS_INCREMENT) if config.IMAGE_BRIGHTNESS_REDUCTION != 1: image = ImageEnhance.Brightness(image).enhance( config.IMAGE_BRIGHTNESS_REDUCTION) if config.IMAGE_CONTRAST_INCREMENT != 1: image = ImageEnhance.Contrast(image).enhance( config.IMAGE_CONTRAST_INCREMENT) if config.IMAGE_CONTRAST_REDUCTION != 1: image = ImageEnhance.Contrast(image).enhance( config.IMAGE_CONTRAST_REDUCTION) save_as_jpg(image_name, image)
def predict_on_image(model, epoch, csv_path, args): # pre-processing on image image = cv2.imread("demo/ceshi.png", -1) #image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) resize = iaa.Scale({'height': args.crop_height, 'width': args.crop_width}) resize_det = resize.to_deterministic() image = resize_det.augment_image(image) image = Image.fromarray(image).convert('RGB') image = transforms.ToTensor()(image).unsqueeze(0) #read csv label path label_info = reader_csv(csv_path) # predict model.eval() predict,_,_ = model(image.cuda()) #with torch.no_grad(): #image1 = cv2.imread("demo/ceshi.png", -1) #predict = model(image.cuda()) #predict=predict.cpu().numpy() #predict=predict[0,1,:,:] #pmin=np.min(predict) #pmax=np.max(predict) #predict=((predict-pmin)/(pmax-pmin+0.000001))*225 #predict=predict.astype(np.uint8) #predict=cv2.applyColorMap(predict,cv2.COLORMAP_JET) #predict=predict[:,:,::-1] #predict = image1+predict*0.3 #plt.imshow(predict, cmap='gray') #save_path = 'demo/epoch_%d.png' % (epoch) #cv2.imwrite(save_path, cv2.cvtColor(np.uint8(predict), cv2.COLOR_RGB2BGR)) w =predict.size()[-1] c =predict.size()[-3] predict = predict.resize(c,w,w) predict = reverse_one_hot(predict) predict = colour_code_segmentation(np.array(predict.cpu()), label_info) predict = cv2.resize(np.uint8(predict), (224, 224)) save_path = 'demo/epoch_%d.png' % (epoch) cv2.imwrite(save_path, cv2.cvtColor(np.uint8(predict), cv2.COLOR_RGB2BGR)) cv2.imwrite(save_path, cv2.cvtColor(np.uint8(predict), cv2.COLOR_RGB2BGR))
def __init__(self, root_dr, image_size, mask_pool_size=28, output_size=[128, 128]): self.root_dr = root_dr self.image_size = image_size self.mask_pool_size = mask_pool_size self.images = glob.glob(os.path.join(root_dr, '*', '*.png')) self.aug = iaa.Sequential([ iaa.Flipud(0.5), iaa.Fliplr(0.5), iaa.Affine( scale={ "x": (0.9, 1.1), "y": (0.9, 1.1) }, rotate=(-30, 30), ), ]) self.factor = iaa.Sequential([ iaa.Scale(size=output_size), ])
def __init__(self, args): if args.augment: seq_geom = iaa.Sequential([ RandomCrop(args.image_size, shared_crop=True), iaa.Fliplr(0.5), iaa.Flipud(0.5), ]) seq_color = iaa.Sequential([]) else: seq_geom = iaa.Sequential([ iaa.Scale({ "height": args.image_size, "width": args.image_size }, 'cubic') ]) seq_color = iaa.Sequential([]) self.seq_geom = seq_geom self.seq_color = seq_color
def classifier_preprocessing(img, target, aligner_coordinates, augmentation, target_size): height, width = target_size align = AlignKeypoints(aligner_coordinates, (height, width)).to_deterministic() scale = iaa.Scale({"height": height, "width": width}).to_deterministic() augmenter = iaa.Sequential([iaa.Affine(translate_px={"x": (-4, 4), "y": (-4, 4)}, rotate=(-4, 4), scale=(1.0, 1.3)), iaa.Flipud(0.5), iaa.Fliplr(0.5), ]).to_deterministic() if augmentation: transformations = [align, augmenter, scale] else: transformations = [align, scale] transformer = iaa.Sequential(transformations).to_deterministic() aug_X = transformer.augment_image(img) target_np = target.values.astype(np.int64) return aug_X, target_np
def transform_batch_images(self, batch_x): if self.mode=='train': augmenter = iaa.Sequential( [ iaa.Fliplr(0.3), iaa.Flipud(0.3), iaa.Sometimes(0.3, iaa.SomeOf(1,[ iaa.Affine(rotate=(-10,10),cval=0,mode='constant'), iaa.Affine(translate_px=(-10,10),cval=0,mode='constant'), iaa.Crop(percent=(0, 0.1)), iaa.Scale((112,112), interpolation='cubic', name=None, deterministic=False, random_state=None) iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5), ])), ], random_order=True, ) batch_x = augmenter.augment_images(batch_x) return batch_x
def __call__(self, sample): image, pose = sample['image'], sample['pose'].reshape([-1, 2]) # augmentation choices seq = iaa.SomeOf(2, [ iaa.Sometimes(0.4, iaa.Scale((0.5, 1.0))), iaa.Sometimes( 0.6, iaa.CropAndPad(percent=(-0.25, 0.25), pad_mode=["edge"], keep_size=False)), iaa.Fliplr(0.1), iaa.Sometimes(0.4, iaa.AdditiveGaussianNoise(scale=(0, 0.05 * 50))), iaa.Sometimes(0.1, iaa.GaussianBlur(sigma=(0, 3.0))) ]) seq_det = seq.to_deterministic() image_aug = seq_det.augment_images([image])[0] keypoints_aug = seq_det.augment_keypoints( [self.pose2keypoints(image, pose)])[0] return {'image': image_aug, 'pose': self.keypoints2pose(keypoints_aug)}
def __init__( self, in_shape, im_paths=[], truth_paths=None, locs2d=None, sig_prior=0.1, mode='train', cuda=False, normalize=False, # compute mean and stdev of dataset sometimes_rate=0.5, seed=0): self.im_paths = im_paths self.scale = iaa.Scale(in_shape) self.sometimes = lambda aug: iaa.Sometimes(sometimes_rate, aug) self.aug_affines = self.sometimes(iaa.Noop()) self.aug_noise = iaa.AdditiveGaussianNoise(scale=0.1) self.truth_paths = truth_paths self.locs2d = locs2d self.sig_prior = sig_prior self.device = torch.device('cuda' if cuda else 'cpu') self.in_shape = in_shape self.seed = 0 if (normalize): self.mode = 'eval' self.mean, self.std = self.comp_normalization_factors() self.normalize = utls.NormalizeAug(mean=self.mean, std=self.std) else: # Do scaling self.normalize = utls.PixelScaling() self.mode = mode
def predict_on_image(model, args, image): ''' run inference and return the resultant image ''' # pre-processing on image image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) resize = iaa.Scale({'height': args.crop_height, 'width': args.crop_width}) resize_det = resize.to_deterministic() image = resize_det.augment_image(image) image = Image.fromarray(image).convert('RGB') image = transforms.ToTensor()(image) image = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))(image).unsqueeze(0) # read csv label path label_info = get_label_info(args.csv_path) # predict model.eval() predict = model(image).squeeze() predict = reverse_one_hot(predict) # predict = colour_code_segmentation(np.array(predict), label_info) predict = colour_code_segmentation(np.array(predict.cpu()), label_info) predict = cv2.resize(np.uint8(predict), (960, 720)) # cv2.imwrite(args.save_path, cv2.cvtColor(np.uint8(predict), cv2.COLOR_RGB2BGR)) return predict
def __init__(self, blur=True, flip=False, rotate=10, shear=10, **kwargs): from imgaug import augmenters as iaa sequence = [] sequence += [ iaa.Scale((INPUT_SIZE, INPUT_SIZE)), iaa.ContrastNormalization((0.75, 1.25)), iaa.AddElementwise((-10, 10), per_channel=0.5), iaa.AddToHueAndSaturation(value=(-20, 20), per_channel=True), iaa.Multiply((0.75, 1.25)), ] sequence += [ iaa.PiecewiseAffine(scale=(0.0005, 0.005)), iaa.Affine( rotate=(-rotate, rotate), shear=(-shear, shear), mode='symmetric', ), iaa.Grayscale(alpha=(0.0, 0.5)), ] if flip: sequence += [ iaa.Fliplr(0.5), ] if blur: sequence += [ iaa.Sometimes(0.01, iaa.GaussianBlur(sigma=(0, 1.0))), ] self.aug = iaa.Sequential(sequence)
def __init__(self): from imgaug import augmenters as iaa self.aug = iaa.Sequential( [iaa.Scale((INPUT_SIZE, INPUT_SIZE))])
numInputChannels = 3 net = deeplab_xception.DeepLabv3_plus(nInputChannels=numInputChannels, n_classes=args.num_of_classes, os=args.output_stride, pretrained=True) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Let's use", torch.cuda.device_count(), "GPUs!") print("Initializing weights from: {}...".format(args.checkpoint_path)) net = nn.DataParallel(net) #Because models are trained with dataparallel and saved directly, we need to use it too. net.load_state_dict(torch.load(args.checkpoint_path)) net.to(device) augs_test = iaa.Sequential([ iaa.Scale((args.imsize, args.imsize), 0), # Resize the img ]) db_test = AlphaPilotSegmentation( input_dir=args.input_images_path, label_dir=args.label_images_path, transform=augs_test, input_only=None ) testloader = DataLoader(db_test, batch_size=testBatchSize, shuffle=False, num_workers=4, drop_last=True) num_img_ts = len(testloader) #===========================Inference Loop=====================================# net.eval() total_iou = 0.0 miou = 0.0 miou_per_class = [0] * args.num_of_classes
raise NotImplementedError device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #criterion = criterion.to(device) #TODO: IS THIS NEEDED? # Enable Multi-GPU training if torch.cuda.device_count() > 1: print("Let's use", torch.cuda.device_count(), "GPUs!") # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs net = nn.DataParallel(net) augs_train = iaa.Sequential([ # Geometric Augs iaa.Scale((imsize, imsize), 0), iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.Rot90((0, 4)), # Blur and Noise #iaa.Sometimes(0.2, iaa.GaussianBlur(sigma=(0, 1.5), name="gaus-blur")), #iaa.Sometimes(0.1, iaa.Grayscale(alpha=(0.0, 1.0), from_colorspace="RGB", name="grayscale")), # iaa.Sometimes(0.2, iaa.AdditiveLaplaceNoise(scale=(0, 0.1*255), per_channel=True, name="gaus-noise")), # Color, Contrast, etc. iaa.Sometimes(0.2, iaa.Multiply((0.75, 1.25), per_channel=0.1, name="brightness")), iaa.Sometimes(0.2, iaa.GammaContrast((0.7, 1.3), per_channel=0.1, name="contrast")), iaa.Sometimes(0.2, iaa.AddToHueAndSaturation((-20, 20), name="hue-sat")), iaa.Sometimes(0.3, iaa.Add((-20, 20), per_channel=0.5, name="color-jitter")), ]) augs_test = iaa.Sequential([ # Geometric Augs
16)), # crop images from each side by 0 to 16px (randomly chosen) iaa.Flipud(1), #Flip vertically iaa.Fliplr(1), # horizontally flip iaa.GaussianBlur(sigma=(0, 3.0)), # blur images with a sigma of 0 to 3.0 iaa.ContrastNormalization( (0.75, 1.5)), # Strengthen or weaken the contrast in each image. iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), # Add gaussian noise. iaa.Multiply( (0.8, 1.2), per_channel=0.2), # Make some images brighter and some darker. iaa.AdditiveGaussianNoise(scale=0.1 * 255), iaa.Affine(translate_px={"x": -40} ), # Augmenter to apply affine transformations to images. iaa.Scale({ "height": 512, "width": 512 }), iaa.WithChannels(0, iaa.Add((10, 100))), iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)), iaa.Add((-40, 40)), iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.CoarseDropout(0.02, size_percent=0.5), iaa.ContrastNormalization((0.5, 1.5)), iaa.Affine(rotate=(-45, 45)), ]) def thread_work(sblst_sub): imgs = [] imgpath = [] for pic_name in sblst_sub: