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(),
])
