def aug_daniel_prepadded(prob=1.0, image_size=448): return Compose([ RandomRotate90(p=0.5), Transpose(p=0.5), Flip(p=0.5), OneOf([ RandomCrop(height=image_size, width=image_size, p=0.3), Compose([ #3.94 determined by largest angle possible rotatable without introducing nodata pixels into center crop area ShiftScaleRotate(shift_limit=0.0, scale_limit=0.0, rotate_limit=6, border_mode=cv2.BORDER_CONSTANT, p=1.0), CenterCrop(height=int(round(236/224*image_size)), width=int(round(236/224*image_size)), p=1.0), RandomCrop(height=image_size, width=image_size, p=1.0) ], p=0.4), Compose([ #3.94 determined by largest angle possible rotatable without introducing nodata pixels into center crop area ShiftScaleRotate(shift_limit=0.0, scale_limit=0.0, rotate_limit=12, border_mode=cv2.BORDER_CONSTANT, p=1.0), CenterCrop(height=image_size, width=image_size, p=1.0) ], p=0.3) ], p=1.0), #OneOf([ #IAASharpen(), #IAAEmboss(), # RandomBrightnessContrast(brightness_limit=0.01, contrast_limit=0.01) # This causes a blackout for some reason #Blur(), #GaussNoise() #], p=0.5), IAASharpen(p=0.2), IAAAdditiveGaussianNoise(p=0.2), # HueSaturationValue(p=0.3) #ShiftScaleRotate(shift_limit=0.0, scale_limit=0.0, rotate_limit=2, border_mode=cv2.BORDER_CONSTANT, p=.75), #ChannelShuffle(p=0.33) ], p=prob)
def __init__(self, dataset_path, image_size, transform=None): """ BreastPathQ dataset: supervised fine-tuning on downstream task """ self.image_size = image_size self.transform = transform # Resize images self.transform1 = Compose([Resize(image_size, image_size, interpolation=2)]) # 256 # Data augmentations self.transform4 = Compose([Rotate(limit=(-90, 90), interpolation=2), CenterCrop(image_size, image_size)]) self.transform5 = Compose( [Rotate(limit=(-90, 90), interpolation=2), RandomScale(scale_limit=(0.8, 1.2), interpolation=2), Resize(image_size + 20, image_size + 20, interpolation=2), RandomCrop(image_size, image_size)]) self.datalist = [] data_paths = glob.glob(dataset_path + "*.h5") with tqdm(enumerate(sorted(data_paths)), disable=True) as t: for wj, data_path in t: data = h5py.File(data_path) data_patches = data['x'][:] cls_id = data['y'][:] for idx in range(len(data_patches)): self.datalist.append((data_patches[idx], cls_id[idx]))
def test_image(model, image_path): img_transforms = transforms.Compose( [transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]) # size_transform = Compose([ # PadIfNeeded(736, 1280) # ]) crop = CenterCrop(720, 720) img = cv2.imread(image_path) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # img_s = size_transform(image=img)['image'] img_s = crop(image=img)['image'] img_tensor = torch.from_numpy( np.transpose(img_s / 255, (2, 0, 1)).astype('float32')) img_tensor = img_transforms(img_tensor) with torch.no_grad(): img_tensor = Variable(img_tensor.unsqueeze(0).cuda()) result_image = model(img_tensor) result_image = result_image[0].cpu().float().numpy() result_image = (np.transpose(result_image, (1, 2, 0)) + 1) / 2.0 * 255.0 result_image = result_image.astype('uint8') # gt_image = get_gt_image(image_path) _, filename = os.path.split(image_path) #save_image(result_image,filename) psnr = PSNR(result_image, img_s) pilFake = Image.fromarray(result_image) pilReal = Image.fromarray(img_s) ssim = calculate_ssim(result_image, img_s) return psnr, ssim
def albumentations_transforms(p=1.0, is_train=False): # Mean and standard deviation of train dataset mean = np.array([0.4914, 0.4822, 0.4465]) std = np.array([0.2023, 0.1994, 0.2010]) transforms_list = [] # Use data aug only for train data if is_train: transforms_list.extend([ PadIfNeeded(min_height=40, min_width=40, border_mode=BORDER_CONSTANT, value=mean*255.0, p=1.0), OneOf([ RandomCrop(height=32, width=32, p=0.8), CenterCrop(height=32, width=32, p=0.2), ], p=1.0), HorizontalFlip(p=0.5), CoarseDropout(max_holes=1, max_height=8, max_width=8, min_height=8, min_width=8, fill_value=mean*255.0, p=0.75), ]) transforms_list.extend([ Normalize( mean=mean, std=std, max_pixel_value=255.0, p=1.0 ), ToTensor() ]) transforms = Compose(transforms_list, p=p) return lambda img:transforms(image=np.array(img))["image"]
def box_segmentation_aug(): return Compose([ OneOf([ RandomBrightnessContrast(brightness_limit=0.2, p=0.5), RandomGamma(gamma_limit=50, p=0.5), ChannelShuffle(p=0.5) ]), OneOf([ ImageCompression(quality_lower=0, quality_upper=20, p=0.5), MultiplicativeNoise(multiplier=(0.3, 0.8), elementwise=True, per_channel=True, p=0.5), Blur(blur_limit=(15, 15), p=0.5) ]), OneOf([ CenterCrop(height=1000, width=1000, p=0.1), RandomGridShuffle(grid=(3, 3), p=0.2), CoarseDropout(max_holes=20, max_height=100, max_width=100, fill_value=53, p=0.2) ]), OneOf([ GridDistortion(p=0.5, num_steps=2, distort_limit=0.2), ElasticTransform(alpha=157, sigma=80, alpha_affine=196, p=0.5), OpticalDistortion(distort_limit=0.5, shift_limit=0.5, p=0.5) ]), OneOf([ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), Rotate(limit=44, p=0.5) ]) ])
def get_valid_transforms(): return Compose([ CenterCrop(CFG['height'], CFG['width'], p=1.), Resize(CFG['height'], CFG['width']), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), ToTensorV2(p=1.0), ], p=1.)
def inference(args): with open(args.config) as cfg: config = yaml.load(cfg) model = get_generator(config['model']) model.load_state_dict(torch.load(args.weights)['model']) model = model.cuda() os.makedirs(os.path.dirname(args.output), exist_ok=True) img_transforms = transforms.Compose( [transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]) size_transform = Compose([PadIfNeeded(736, 1280)]) crop = CenterCrop(720, 1280) img = cv2.imread(args.input) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_s = size_transform(image=img)['image'] img_tensor = torch.from_numpy( np.transpose(img_s / 255, (2, 0, 1)).astype('float32')) img_tensor = img_transforms(img_tensor) with torch.no_grad(): img_tensor = Variable(img_tensor.unsqueeze(0).cuda()) result_image = model(img_tensor) result_image = result_image[0].cpu().float().numpy() result_image = (np.transpose(result_image, (1, 2, 0)) + 1) / 2.0 * 255.0 result_image = crop(image=result_image)['image'] result_image = result_image.astype('uint8') cv2.imwrite(args.output, cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR))
def make_transforms(data_shape, resize=None, windows=('soft_tissue', ), windows_force_rgb=True, max_value=1.0, apply_crop=True, **kwargs): transforms = [] if resize == 'auto': resize = data_shape if resize: transforms.append(Resize(*resize)) if apply_crop: transforms.append(CenterCrop(height=data_shape[1], width=data_shape[0])) transforms.append( ChannelWindowing( windows=windows, force_rgb=windows_force_rgb, )) transforms.append(ToFloat(max_value=max_value)) return Compose(transforms)
def __init__(self,phase='train',datalabel='', resize=(320,320),imgs_per_video=30,min_frames=0,\ normalize=dict(mean=[0.5,0.5,0.5],std=[0.5,0.5,0.5]),frame_interval=10,max_frames=300,augment='augment0'): assert phase in ['train', 'val', 'test'] self.datalabel = datalabel self.phase = phase self.imgs_per_video = imgs_per_video self.frame_interval = frame_interval self.num_classes = 2 self.epoch = 0 self.max_frames = max_frames if min_frames: self.min_frames = min_frames else: self.min_frames = max_frames * 0.3 self.dataset = [] self.aug = augmentations[augment] resize_ = (int(resize[0] / 0.8), int(resize[1] / 0.8)) self.resize = resize #Resize(*resize_,interpolation=cv2.INTER_CUBIC), self.trans = Compose( [CenterCrop(*resize), ToTensor(normalize=normalize)]) ############### # doing resize and center crop in trans if type(datalabel) != str: self.dataset = datalabel return if 'ff-5' in self.datalabel: for i, j in enumerate([ 'Origin', 'Deepfakes', 'NeuralTextures', 'FaceSwap', 'Face2Face' ]): temp = FF_dataset(j, self.datalabel.split('-')[2], phase) temp = [[k[0], i] for k in temp] self.dataset += temp elif 'ff-all' in self.datalabel: for i in [ 'Origin', 'Deepfakes', 'NeuralTextures', 'FaceSwap', 'Face2Face' ]: self.dataset += FF_dataset(i, self.datalabel.split('-')[2], phase) if phase != 'test': self.dataset = make_balance(self.dataset) elif 'ff' in self.datalabel: self.dataset += FF_dataset( self.datalabel.split('-')[1], self.datalabel.split('-')[2], phase) + FF_dataset( "Origin", self.datalabel.split('-')[2], phase) elif 'celeb' in self.datalabel: self.dataset = Celeb_test elif 'deeper' in self.datalabel: self.dataset = deeperforensics_dataset(phase) + FF_dataset( 'Origin', self.datalabel.split('-')[1], phase) elif 'dfdc' in self.datalabel: self.dataset = dfdc_dataset(phase) else: raise (Exception('no such datset'))
def __call__(self, img): for attempt in range(10): area = img.size[0] * img.size[1] target_area = random.uniform(self.min_area, self.max_area) * area aspect_ratio = random.uniform(self.min_aspect, self.max_aspect) w = int(round(math.sqrt(target_area * aspect_ratio))) h = int(round(math.sqrt(target_area / aspect_ratio))) if random.random() < 0.5: w, h = h, w if w <= img.size[0] and h <= img.size[1]: x1 = random.randint(0, img.size[0] - w) y1 = random.randint(0, img.size[1] - h) img = img.crop((x1, y1, x1 + w, y1 + h)) assert(img.size == (w, h)) return img.resize((self.size, self.size), self.interpolation) # Fallback scale = Resize(self.size, interpolation=self.interpolation) crop = CenterCrop(self.size) return crop(scale(img))
def inspect_images2(model, device, num_samples=2, channels=None, gen_only=False): """ Visualizing learned segmentation MSI image embedding. """ model.eval() rows = [] transforms = Compose([CenterCrop(224, 224)]) dataset = HsiSegmentationDataset( root='/home/mate/datasets/grss/Track1-MSI_A_val', gt_root='/home/mate/datasets/grss/Train-Track1-Truth', channels=None, transforms=transforms) for index in range(num_samples): rgb_images = [] converted_images = [] for category_id in range(num_samples * 2): with torch.set_grad_enabled(False): img_npy, gt_tensor = dataset[index + 10 * category_id] image_in = torch.tensor(img_npy).unsqueeze(0).to(device) out, transformed = model(image_in) rgb_images.append(to_color_image(image_in, pil=False)) converted_images.append(to_color_image(transformed, pil=False)) appended_rgb = np.hstack(rgb_images) appended_conv = np.hstack(converted_images) row = np.vstack([appended_rgb, appended_conv]) rows.append(row) single_image = np.vstack(rows) return Image.fromarray(single_image)
def __init__(self, is_train: bool, to_pytorch: bool): if is_train: self._aug = Compose([ OneOf([ Compose([ SmallestMaxSize( max_size=min(data_height, data_width) * 1.1, p=1), RandomCrop(height=data_height, width=data_width, p=1) ], p=1), Resize(height=data_height, width=data_width, p=1) ], p=1), GaussNoise(p=0.5), RandomGamma(p=0.5), RandomBrightnessContrast(p=0.5), HorizontalFlip(p=0.5) ], p=1) else: self._aug = Compose([ SmallestMaxSize(max_size=min(data_height, data_width), p=1), CenterCrop(height=data_height, width=data_width, p=1) ], p=1) self._need_to_pytorch = to_pytorch
def Rotate_Crop(img, v): # [-90, 90] assert -90 <= v <= 90 if random.random() < 0.5: v = -v transform = Compose([Flip(), Rotate(limit=v, interpolation=2), CenterCrop(img.shape[1], img.shape[1])]) Aug_img = transform(image=img) return Aug_img
def test_image(model, save_path, image_path): img_transforms = transforms.Compose( [transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]) size_transform = Compose([PadIfNeeded(736, 1280)]) crop = CenterCrop(720, 1280) img = cv2.imread(image_path) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_s = size_transform(image=img)['image'] img_tensor = torch.from_numpy( np.transpose(img_s / 255, (2, 0, 1)).astype('float32')) img_tensor = img_transforms(img_tensor) with torch.no_grad(): img_tensor = Variable(img_tensor.unsqueeze(0).cuda()) result_image = model(img_tensor) result_image = result_image[0].cpu().float().numpy() result_image = (np.transpose(result_image, (1, 2, 0)) + 1) / 2.0 * 255.0 result_image = crop(image=result_image)['image'] result_image = result_image.astype('uint8') gt_image = get_gt_image(image_path) lap = estimate_blur(result_image) lap_sharp = estimate_blur(gt_image) lap_blur = estimate_blur(img) _, filename = os.path.split(image_path) psnr = PSNR(result_image, gt_image) pilFake = Image.fromarray(result_image) pilReal = Image.fromarray(gt_image) ssim = SSIM(pilFake).cw_ssim_value(pilReal) #result_image = np.hstack((img_s, result_image, gt_image)) #cv2.imwrite(os.path.join(save_path, filename), cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR)) return psnr, ssim, lap, lap_blur, lap_sharp
def test_image(model, image_path): img_transforms = transforms.Compose([ transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) size_transform = Compose([ PadIfNeeded(736, 1280) ]) crop = CenterCrop(720, 1280) img = cv2.imread(image_path + '_blur_err.png') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_s = size_transform(image=img)['image'] img_tensor = torch.from_numpy(np.transpose(img_s / 255, (2, 0, 1)).astype('float32')) img_tensor = img_transforms(img_tensor) with torch.no_grad(): img_tensor = Variable(img_tensor.unsqueeze(0).cuda()) result_image = model(img_tensor) result_image = result_image[0].cpu().float().numpy() result_image = (np.transpose(result_image, (1, 2, 0)) + 1) / 2.0 * 255.0 result_image = crop(image=result_image)['image'] result_image = result_image.astype('uint8') # gt_image = get_gt_image(image_path) gt_image = cv2.cvtColor(cv2.imread(image_path + '_ref.png'), cv2.COLOR_BGR2RGB) _, file = os.path.split(image_path) psnr = PSNR(result_image, gt_image) pilFake = Image.fromarray(result_image) pilReal = Image.fromarray(gt_image) ssim = SSIM(pilFake).cw_ssim_value(pilReal) sample_img_names = set(["010221", "024071", "033451", "051271", "060201", "070041", "090541", "100841", "101031", "113201"]) if file[-3:] == '001' or file in sample_img_names: print('test_{}: PSNR = {} dB, SSIM = {}'.format(file, psnr, ssim)) result_image = cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR) cv2.imwrite(os.path.join('./test', 'test_'+image_path[-6:]+'.png'), result_image) return psnr, ssim
def __init__(self, weights_path): model = EfficientNet.from_name('efficientnet-b7', override_params={'num_classes': 1}) for module in model.modules(): if isinstance(module, MBConvBlock): if module._block_args.expand_ratio != 1: expand_conv = module._expand_conv seq_expand_conv = SeqExpandConv( expand_conv.in_channels, expand_conv.out_channels, VIDEO_SEQUENCE_MODEL_SEQUENCE_LENGTH) module._expand_conv = seq_expand_conv self.model = model.cuda().eval() normalize = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) self.transform = Compose([ SmallestMaxSize(VIDEO_MODEL_MIN_SIZE), CenterCrop(VIDEO_MODEL_CROP_HEIGHT, VIDEO_MODEL_CROP_WIDTH), normalize, ToTensor() ]) state = torch.load(weights_path, map_location=lambda storage, loc: storage) state = {key: value.float() for key, value in state.items()} self.model.load_state_dict(state)
def get_train_transforms(): augmentations = Compose([ Resize(236,236), Flip(), OneOf([ IAAAdditiveGaussianNoise(p=.5), GaussNoise(p=.4), ], p=0.4), OneOf([ MotionBlur(p=0.6), Blur(blur_limit=3, p=0.2), ], p=0.4), ShiftScaleRotate(shift_limit=0.0725, scale_limit=0.2, rotate_limit=45, p=0.6), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=0.4), IAAPiecewiseAffine(p=0.2), ], p=0.3), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.25), HueSaturationValue(p=0.3), CenterCrop(224,224), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ), ToTensor() ]) return lambda img:augmentations(image=np.array(img))
def get_train_transform(smallest_max_size: int, size: int): return Compose([ SmallestMaxSize(smallest_max_size), RandomScale(scale_limit=0.125), # PadIfNeeded(256, 256, border_mode=cv2.BORDER_CONSTANT., value=0, p=1.), # ShiftScaleRotate( # shift_limit=0.0625, scale_limit=0.1, rotate_limit=30, # border_mode=cv2.BORDER_REFLECT_101, p=1.), Rotate(limit=20, border_mode=cv2.BORDER_REFLECT_101, p=1.), OneOf([ RandomCrop(size, size, p=0.9), CenterCrop(size, size, p=0.1), ], p=1.), HorizontalFlip(p=0.5), RandomContrast(limit=0.2, p=0.5), RandomGamma(gamma_limit=(80, 120), p=0.5), RandomBrightness(limit=0.2, p=0.5), # HueSaturationValue(hue_shift_limit=5, sat_shift_limit=20, # val_shift_limit=10, p=1.), # OneOf([ # OpticalDistortion(p=0.3), # GridDistortion(p=0.1), # IAAPiecewiseAffine(p=0.3), # ], p=0.2), # OneOf([ # IAAAdditiveGaussianNoise( # loc=0, scale=(1., 6.75), per_channel=False, p=0.3), # GaussNoise(var_limit=(5.0, 20.0), p=0.6), # ], p=0.5), # Cutout(num_holes=4, max_h_size=30, max_w_size=50, p=0.75), # JpegCompression(quality_lower=50, quality_upper=100, p=0.5) ])
def test_compose_with_additional_targets(): image = np.ones((100, 100, 3)) keypoints = [[10, 10], [50, 50]] kp1 = [[15, 15], [55, 55]] aug = Compose([CenterCrop(50, 50)], keypoint_params={'format': 'xy'}, additional_targets={'kp1': 'keypoints'}) transformed = aug(image=image, keypoints=keypoints, kp1=kp1) assert transformed['keypoints'] == [[25, 25]] assert transformed['kp1'] == [[30, 30]]
def get_test_transforms(): augmentations = Compose([ Resize(236, 236), CenterCrop(224, 224), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensor() ]) return lambda img: augmentations(image=np.array(img))
def val_transform(p=1): return Compose([ PadIfNeeded(min_height=args.val_crop_height, min_width=args.val_crop_width, p=1), CenterCrop(height=args.val_crop_height, width=args.val_crop_width, p=1), Normalize(p=1) ], p=p)
def test_compose_with_additional_targets(): image = np.ones((100, 100, 3)) keypoints = [(10, 10), (50, 50)] kp1 = [(15, 15), (55, 55)] aug = Compose([CenterCrop(50, 50)], keypoint_params={"format": "xy"}, additional_targets={"kp1": "keypoints"}) transformed = aug(image=image, keypoints=keypoints, kp1=kp1) assert transformed["keypoints"] == [(25, 25)] assert transformed["kp1"] == [(30, 30)]
def __init__(self, resize_height, resize_width): self.resize_height = resize_height self.resize_width = resize_width self.transformer = Compose([ CenterCrop(height=self.resize_height, width=self.resize_width), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), albumentations.pytorch.transforms.ToTensor(), ])
def main(): parser = argparse.ArgumentParser() parser.add_argument('--weight-path', required=True) parser.add_argument('--image-dirs', required=True, type=str, nargs='+') parser.add_argument('--mask-dirs', required=True, type=str, nargs='+') parser.add_argument('--model-name', type=str, default='unet11') parser.add_argument('--dataset-type', type=str, default='base') parser.add_argument('--save-path', default='forward') parser.add_argument('--category-type', default='binary', choices=['binary', 'simple']) parser.add_argument('--cpu', action='store_true') parser.add_argument('--device-id', type=int, default=0) parser.add_argument('--seed', type=int, default=1) parser.add_argument('--input-size', type=int, nargs=2, default=(640, 640)) parser.add_argument('--jaccard-weight', type=float, default=0.3) args = parser.parse_args() print(args) image_dirs = [Path(p) for p in args.image_dirs] mask_dirs = [Path(p) for p in args.mask_dirs] for data_dir in (image_dirs + mask_dirs): assert data_dir.exists(), f'{str(data_dir)} does not exist.' device = torch_tools.get_device(args.cpu, args.device_id) torch_tools.set_seeds(args.seed, device) weight_path = Path(args.weight_path) category_type = datasets.surface_types.from_string(args.category_type) save_path = Path(args.save_path) if not save_path.exists(): save_path.mkdir(parents=True) net = models.load_model(args.model_name, category_type).to(device) state_dict = torch.load(weight_path, map_location=device) net.load_state_dict(state_dict=state_dict) input_size = args.input_size transform = Compose([ CenterCrop(*input_size), ]) dataset = datasets.create_dataset( args.dataset_type, image_dirs, mask_dirs, category_type, transform, ) loader = DataLoader(dataset, batch_size=1, shuffle=False) criterion = models.loss.get_criterion(category_type, args.jaccard_weight) evaluate(net, loader, criterion, device, save_path, category_type)
def __init__(self, first_weights_path, second_weights_path): first_model = EfficientNet.from_name( 'efficientnet-b7', override_params={'num_classes': 1}) self.first_model = first_model.cuda().eval() second_model = EfficientNet.from_name( 'efficientnet-b7', override_params={'num_classes': 1}) self.second_model = second_model.cuda().eval() first_normalize = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) self.first_transform = Compose([ SmallestMaxSize(VIDEO_MODEL_CROP_WIDTH), PadIfNeeded(VIDEO_MODEL_CROP_HEIGHT, VIDEO_MODEL_CROP_WIDTH), CenterCrop(VIDEO_MODEL_CROP_HEIGHT, VIDEO_MODEL_CROP_WIDTH), first_normalize, ToTensor() ]) second_normalize = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) self.second_transform = Compose([ SmallestMaxSize(VIDEO_MODEL_MIN_SIZE), CenterCrop(VIDEO_MODEL_CROP_HEIGHT, VIDEO_MODEL_CROP_WIDTH), second_normalize, ToTensor() ]) first_state = torch.load(first_weights_path, map_location=lambda storage, loc: storage) first_state = { key: value.float() for key, value in first_state.items() } self.first_model.load_state_dict(first_state) second_state = torch.load(second_weights_path, map_location=lambda storage, loc: storage) second_state = { key: value.float() for key, value in second_state.items() } self.second_model.load_state_dict(second_state)
def __init__(self): # Variables to hold the description of the experiment self.description = "Training configuration file for the RGB version of the ResNet50 network." # System dependent variable self._workers = 10 self._multiprocessing = True # Variables for comet.ml self._project_name = "jpeg-deep" self._workspace = "classification_resnet50" # Network variables self._weights = None self._network = ResNet50() # Training variables self._epochs = 90 self._batch_size = 32 self._steps_per_epoch = 1281167 // self.batch_size self._validation_steps = 50000 // self._batch_size self.optimizer_parameters = {"lr": 0.0125, "momentum": 0.9} self._optimizer = SGD(**self.optimizer_parameters) self._loss = categorical_crossentropy self._metrics = ['accuracy', 'top_k_categorical_accuracy'] self.train_directory = join(environ["DATASET_PATH_TRAIN"], "train") self.validation_directory = join(environ["DATASET_PATH_VAL"], "validation") self.test_directory = join(environ["DATASET_PATH_TEST"], "validation") self.index_file = "data/imagenet_class_index.json" # Defining the transformations that will be applied to the inputs. self.train_transformations = [ SmallestMaxSize(256), RandomCrop(224, 224), HorizontalFlip() ] self.validation_transformations = [ SmallestMaxSize(256), CenterCrop(224, 224) ] self.test_transformations = [SmallestMaxSize(256)] # Keras stuff self._callbacks = [] self._train_generator = None self._validation_generator = None self._test_generator = None # Stuff for display self._displayer = ImageNetDisplayer(self.index_file)
def get_augmentations(self): if self.strength is None: return None transformations = [ Compose([ CenterCrop( config.CROP_SIDE, config.CROP_SIDE, always_apply=True), ], p=1.), ] return Compose(transformations)
def get_test_transform(smallest_max_size: int, size: int): return Compose([ # RandomScale(scale_limit=0.125), SmallestMaxSize(smallest_max_size), # PadIfNeeded(256, 256, border_mode=cv2.BORDER_REFLECT_101, value=0, p=1.), # OneOf([ # RandomCrop(224, 224, p=0.9), # CenterCrop(224, 224, p=0.1), # ], p=1.), CenterCrop(size, size, p=1.) # HorizontalFlip(p=0.5), ])
def __init__(self, data_path, json_path, image_size, transform=None): """ Camelyon16 dataset: supervised fine-tuning on downstream task """ self.transform = transform self.data_path = data_path self.json_path = json_path self._preprocess() # Data augmentations self.transform1 = Compose([Rotate(limit=(-90, 90), interpolation=2), CenterCrop(image_size, image_size)]) self.transform2 = Compose([Rotate(limit=(-90, 90), interpolation=2), RandomScale(scale_limit=(0.8, 1.2), interpolation=2), Resize(image_size + 20, image_size + 20, interpolation=2), RandomCrop(image_size, image_size)])
def __init__(self, resize_height, resize_width): self.resize_height = resize_height self.resize_width = resize_width self.transformer = Compose([ CenterCrop(height=self.resize_height, width=self.resize_width, always_apply=True), RandomBrightnessContrast(p=0.5), HorizontalFlip(p=0.5), Rotate(limit=3, p=0.5), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), albumentations.pytorch.transforms.ToTensor(), ])