def test_transforms(self):
transforms_list = []
if (self.normalize):
transforms_list.append(A.Normalize(self.mean, self.stdev))
transforms_list.append(AP.ToTensor())
self.transforms = A.Compose(transforms_list)
def __init__(self, path: str = './data', folder: str = 'dataset_crf/lab', special_folder: str = '',
df: object = None, datatype: object = 'train', dataset='crf',
img_ids: object = None,
transforms: object = albu.Compose([albu.HorizontalFlip(), AT.ToTensor()]),
preprocessing: object = None,
use_mask: bool = False, use_corrected: bool = False, log_transform=False, load_any_mask=True) -> object:
self.df = df
self.datatype = datatype
self.img_ids = img_ids
self.transforms = transforms
self.preprocessing = preprocessing
self.use_mask = use_mask
self.path = path
self.folder = folder
self.log_transform = log_transform
self.use_corrected = use_corrected
self.dataset = dataset
self.load_any_mask = load_any_mask
if self.use_corrected:
self.image_names = os.listdir(f"{path}/{folder}/img_corrected_1/{special_folder}")
else:
if self.dataset != 'crf':
self.image_names = os.listdir(f"{path}/{folder}/images/{special_folder}")
else:
self.image_names = os.listdir(f"{path}/{folder}/srgb8bit/{special_folder}")
self.path = path
self.folder = folder
def __init__(
self,
images_path:
str = 'C:\\Users\\Donik\\Dropbox\\Donik\\fax\\10_semestar\\Diplomski\\CubeDataset\\data\\Cube+\\',
gt_path:
str = 'C:\\Users\\Donik\\Dropbox\\Donik\\fax\\10_semestar\\Diplomski\\CubeDataset\\data\\Cube+\\cube+_gt.txt',
df: object = None,
datatype: object = 'train',
transforms: object = albu.Compose(
[albu.HorizontalFlip(), AT.ToTensor()]),
preprocessing: object = None,
log_transform=False,
illumination_known=False,
patch_width_ratio: float = 1. / 10,
patch_height_ratio: float = 1. / 10) -> object:
super().__init__(images_path,
gt_path,
df,
datatype,
transforms,
preprocessing,
log_transform,
illumination_known=illumination_known)
self.patch_width_ratio = patch_width_ratio
self.patch_height_ratio = patch_height_ratio
def __init__(
self,
images_path:
str = 'C:\\Users\\Donik\\Dropbox\\Donik\\fax\\10_semestar\\Diplomski\\CubeDataset\\data\\Cube+\\',
gt_path:
str = 'C:\\Users\\Donik\\Dropbox\\Donik\\fax\\10_semestar\\Diplomski\\CubeDataset\\data\\Cube+\\cube+_gt.txt',
df: object = None,
datatype: object = 'train',
transforms: object = albu.Compose(
[albu.HorizontalFlip(), AT.ToTensor()]),
preprocessing: object = None,
log_transform=False,
illumination_known=False) -> object:
self.df = df
self.datatype = datatype
self.transforms = transforms
self.preprocessing = preprocessing
self.images_path = images_path
self.gt_path = gt_path
self.log_transform = log_transform
self.illumination_known = illumination_known
if datatype == 'valid':
self.image_names = list(range(1650, 1708))
else:
self.image_names = list(range(1, 1650))
self.gts = np.loadtxt(gt_path)
def __init__(self,
data_folder: str,
df: pd.DataFrame,
im_ids: np.array,
masks_folder: str = None,
transforms=albu.Compose(
[albu.HorizontalFlip(),
AT.ToTensor()]),
preprocessing=None,
mask_shape=(320, 640)):
"""
Attributes
data_folder (str): path to the image directory
df (pd.DataFrame): dataframe with the labels
im_ids (np.ndarray): of image names.
masks_folder (str): path to the masks directory
assumes `use_resized_dataset == True`
transforms (albumentations.augmentation): transforms to apply
before preprocessing. Defaults to HFlip and ToTensor
preprocessing: ops to perform after transforms, such as
z-score standardization. Defaults to None.
mask_shape (tuple): <- mask shape (numpy format, not cv2)
"""
self.df = df
self.data_folder = data_folder
self.masks_folder = masks_folder
if isinstance(masks_folder, str):
self.use_resized_dataset = True
print(f"Using resized masks in {masks_folder}...")
else:
self.use_resized_dataset = False
self.img_ids = im_ids
self.transforms = transforms
self.preprocessing = preprocessing
self.mask_shape = mask_shape
def __init__(self,
data_folder: str,
df: pd.DataFrame,
im_ids: np.array,
masks_folder: str = None,
transforms=albu.Compose(
[albu.HorizontalFlip(),
AT.ToTensor()]),
preprocessing=None,
mask_shape=(320, 640)):
"""
Attributes
data_folder (str): path to the image directory
df (pd.DataFrame): dataframe with the labels
im_ids (np.ndarray): of image names.
masks_folder (str): path to the masks directory
assumes `use_resized_dataset == True`
transforms (albumentations.augmentation): transforms to apply
before preprocessing. Defaults to HFlip and ToTensor
preprocessing: ops to perform after transforms, such as
z-score standardization. Defaults to None.
mask_shape (tuple): <- mask shape (numpy format, not cv2)
"""
df["hasMask"] = ~df["EncodedPixels"].isna()
super().__init__(data_folder=data_folder,
df=df,
im_ids=im_ids,
masks_folder=masks_folder,
transforms=transforms,
preprocessing=preprocessing,
mask_shape=mask_shape)
def data_loader_mask():
"""
Converting the images for PILImage to tensor,
so they can be accepted as the input to the network
:return :
"""
print("Loading Dataset")
default_transform = albu.Compose(
[PadDifferentlyIfNeeded(512, 512, mask_value=0),
AT.ToTensor()])
transform = albu.Compose([
albu.RandomRotate90(1.0),
albu.HorizontalFlip(0.5),
PadDifferentlyIfNeeded(512, 512, mask_value=0),
AT.ToTensor()
])
testset_gt = ImageDataset(root=TEST_ENHANCED_IMG_DIR,
transform=default_transform)
trainset_2_gt = ImageDataset(root=ENHANCED2_IMG_DIR, transform=transform)
testset_inp = ImageDataset(root=TEST_INPUT_IMG_DIR,
transform=default_transform)
trainset_1_inp = ImageDataset(root=INPUT_IMG_DIR, transform=transform)
train_loader_cross = torch.utils.data.DataLoader(
ConcatDataset(trainset_1_inp, trainset_2_gt),
num_workers=NUM_WORKERS,
batch_size=BATCH_SIZE *
GPUS_NUM, # Enlarge batch_size by a factor of len(device_ids)
shuffle=True,
)
test_loader = torch.utils.data.DataLoader(
ConcatDataset(testset_inp, testset_gt),
num_workers=NUM_WORKERS,
batch_size=BATCH_SIZE *
GPUS_NUM, # Enlarge batch_size by a factor of len(device_ids)
shuffle=False)
print("Finished loading dataset")
return train_loader_cross, test_loader
def augmentation(image_size, train=True):
max_crop = image_size // 5
if train:
data_transform = A.Compose([
A.Resize(image_size, image_size),
A.Compose([
A.OneOf([
A.RandomRain(p=0.1),
A.GaussNoise(mean=15),
A.GaussianBlur(blur_limit=10, p=0.4),
A.MotionBlur(p=0.2)
]),
A.OneOf([
A.RGBShift(p=1.0,
r_shift_limit=(-10, 10),
g_shift_limit=(-10, 10),
b_shift_limit=(-10, 10)),
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.1, p=1),
A.HueSaturationValue(hue_shift_limit=20, p=1),
],
p=0.6),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
]),
A.OneOf([A.IAAPerspective(p=0.3),
A.ElasticTransform(p=0.1)]),
A.OneOf([
A.Rotate(limit=25, p=0.6),
A.IAAAffine(
scale=0.9,
translate_px=15,
rotate=25,
shear=0.2,
)
],
p=1),
A.Cutout(num_holes=1,
max_h_size=max_crop,
max_w_size=max_crop,
p=0.2)
],
p=1),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
AT.ToTensor()
])
else:
data_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((image_size, image_size)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
return data_transform
def get_valid_augmentation():
# for valid
valid_transform = [
albu.Resize(height=configs.input_size, width=configs.input_size),
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
p=1),
AT.ToTensor(),
]
return albu.Compose(valid_transform)
def main(model_state_path):
# parameters setting
params = {'batch_size': 16, 'shuffle': False, 'num_workers': 1}
class_num = 2
# tensorboard setting
writer = SummaryWriter('runs/pcam_experiment_1')
# device setting
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# print(torch.cuda.current_device())
print(device)
# define transform
# transform = transforms.Compose([
# transforms.ToPILImage(),
# transforms.Resize(224),
# transforms.ToTensor(),
# transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225]),
# ])
transform = albumentations.Compose([
albumentations.Resize(224, 224),
albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
AT.ToTensor()
])
# load test data
testset = Pcam('data/camelyonpatch_level_2_split_test_x.h5', 'data/camelyonpatch_level_2_split_test_y.h5', transform)
testloader = data.DataLoader(testset, **params)
# load model
model = models.resnet50(pretrained=False)
fc_in_feature = model.fc.in_features
model.fc = nn.Sequential(
nn.Dropout(p=0.6),
nn.Linear(fc_in_feature, 512, bias=True),
nn.SELU(),
nn.Dropout(p=0.8),
nn.Linear(512, class_num, bias=True),
)
model.load_state_dict(torch.load(model_state_path))
model.to(device)
# define loss function
criterion = nn.CrossEntropyLoss()
# clock setting
start = time.time()
# test
test(model, testloader, criterion, device, writer, 0, False)
# testset.close()
print('Total Time: {}'.format(time.time()-start))
def __init__(self, df: pd.DataFrame = None, datatype: str = 'train', img_ids: np.array = None,
transforms=albu.Compose([albu.HorizontalFlip(), AT.ToTensor()]),
preprocessing=None, path=None):
self.df = df
if datatype != 'test':
self.data_folder = f"{path}/train_images"
else:
self.data_folder = f"{path}/test_images"
self.img_ids = img_ids
self.transforms = transforms
self.preprocessing = preprocessing
def __init__(self, split):
self.split = split
self.aug = albumentations.Compose([
albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
AT.ToTensor()
])
if self.split == 'train':
self.aug = albumentations.Compose([
albumentations.HorizontalFlip(),
albumentations.RandomBrightness(),
albumentations.ShiftScaleRotate(rotate_limit=15,
scale_limit=0.10),
albumentations.HueSaturationValue(),
albumentations.Cutout(1, 4, 4, 0.5),
albumentations.GaussNoise(),
albumentations.ElasticTransform(),
albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
AT.ToTensor()
])
def __init__(self, path: str = './data', folder: str = 'dataset_crf/lab', special_folder: str = '',
df: object = None, datatype: object = 'train', dataset='crf',
img_ids: object = None,
transforms: object = albu.Compose([albu.HorizontalFlip(), AT.ToTensor()]),
preprocessing: object = None,
use_mask: bool = False, use_corrected: bool = False,
patch_width_ratio: float = 1. / 10, patch_height_ratio: float = 1. / 10,
log_transform=False) -> object:
super(MIPatchedDataset, self).__init__(path, folder, special_folder, df, datatype, dataset, img_ids, transforms,
preprocessing, use_mask, use_corrected, log_transform)
self.patch_width_ratio = patch_width_ratio
self.patch_height_ratio = patch_height_ratio
def get_training_augmentation():
# for train
train_transform = [
albu.Resize(height=configs.input_size, width=configs.input_size),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
p=1),
AT.ToTensor(),
]
return albu.Compose(train_transform)
def __init__(self, files, labels, normalization, size, augmentation=None):
if isinstance(size, list):
size = tuple(size)
self.size = size
self.files = files
self.labels = labels
pipeline = []
if augmentation is not None:
pipeline.append(augmentation)
pipeline.append(albumentations.Resize(*size))
pipeline.append(albumtorch.ToTensor())
self.pipeline = albumentations.Compose(pipeline)
self.normalization = normalization
def train_transforms(self, before_norm=None, after_norm=None):
transforms_list = []
if before_norm:
transforms_list = before_norm
if (self.normalize):
transforms_list.append(A.Normalize(self.mean, self.stdev))
if after_norm:
transforms_list.extend(after_norm)
transforms_list.append(AP.ToTensor())
self.transforms = A.Compose(transforms_list)
def __init__(self,
transforms=albu.Compose(
[albu.HorizontalFlip(),
AT.ToTensor()]),
preprocessing=None,
k_folds=1):
patch_loader = valid_PatchLoader(n_kfold=k_folds, seed=42)
df = patch_loader.get_all_patches()
self.len = df.shape[0]
self.slide_path = df['slide_path']
self.mask_path = df['mask_path']
self.transforms = transforms
self.preprocessing = preprocessing
def __init__(self, model_name="mobilenet_v2", device="cpu"):
"""
MRI Pulse Sequence classification object.
The implementation is built from *torchvision*.
For using pretrained weights, initialize the classifier object by using:
`PulseSequenceClassifier().from_pretrained()`
The classifier supports both instance level (with `predict_instance` method)
and study level (with `predict_study` method).
:param model_name: str, default="mobilenet_v2"
Load model structure from `torchvision`, default="mobilenet_v2".
Currently supported models are: "mobilenet_v2".
:param device: str, default="cpu"
Move model and data to a specific device, default="cpu".
Change `device` to `cuda` in case of GPU inference.
"""
self.device = torch.device(device)
self.model_name = model_name
supported_models = list(model_urls.keys())
if model_name not in supported_models:
raise NotImplementedError('Currently supported models are', list(model_urls.keys()))
self.label_dict = dict([
(0, "FLAIR"),
(1, "T1C"),
(2, "T2"),
(3, "ADC"),
(4, "DWI"),
(5, "TOF"),
(6, "OTHER"),
])
self.model = create_model(self.model_name, pretrained=False, n_classes=len(self.label_dict.keys()))
self.model = self.model.to(self.device)
# self.model = nn.DataParallel(self.model)
self.model = WrappedModel(self.model)
self.transform = A.Compose([
A.Resize(256, 256),
A.Normalize(),
AT.ToTensor()
])
def __init__(self,
df,
datatype,
img_ids,
transforms=albu.Compose(
[albu.HorizontalFlip(),
AT.ToTensor()]),
preprocessing=None,
folder='../input/'):
self.df = df
if datatype != 'test':
self.data_folder = f"{folder}train_images"
else:
self.data_folder = f"{folder}test_images"
self.img_ids = img_ids
self.transforms = transforms
self.preprocessing = preprocessing
def predict(image_path):
word_to_idx = pickle.load(open('model/word_to_idx.pickle', 'rb'))
idx_to_word = pickle.load(open('model/idx_to_word.pickle', 'rb'))
model = ImageCaptioningModel.EncoderDecoder(
embedding_dims=CONFIG.embedding_dims,
vocab_size=len(word_to_idx),
hidden_dims=CONFIG.hidden_dims,
num_layers=CONFIG.num_layer,
bidirectional=CONFIG.bidirectional,
dropout=CONFIG.dropout)
model.load_state_dict(torch.load('model/Image_Captioning.bin'))
model.eval()
mean = (0.5, 0.5, 0.5)
std = (0.5, 0.5, 0.5)
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
transform = alb.Compose([
alb.Normalize(mean, std, always_apply=True),
alb.Resize(224, 224, always_apply=True),
AT.ToTensor()
])
image = np.array(Image.open(image_path).convert('RGB'))
image = transform(image=image)['image']
image = image[None, :]
sentence = []
with torch.no_grad():
x = model.encoder(image).unsqueeze(1)
state = None
for _ in range(max_len):
x, state = model.decoder.rnn(x, state)
predict = model.decoder.fc(x.squeeze(0))
word = torch.softmax(predict, dim=-1)
word = predict.argmax(1)
prediction = idx_to_word.get(word.item())
if prediction == '<EOS>':
break
sentence.append(prediction)
x = model.decoder.embedding(word.unsqueeze(1))
sentence = ' '.join(sentence)
print(sentence)
def get_transforms(phase, mean, std, list_transforms=None):
if not list_transforms:
list_transforms = []
if phase == 'train':
list_transforms.extend([
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.RandomBrightnessContrast(p=0.1,
brightness_limit=0.1,
contrast_limit=0.1)
])
list_transforms.extend(
[albu.Normalize(mean=mean, std=std),
albu_pytorch.ToTensor()])
list_transforms = albu.Compose(list_transforms)
return list_transforms
def stong_aug():
# strong aug for train
train_transform = [
albu.Resize(height=configs.input_size, width=configs.input_size),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.RandomRotate90(p=0.5),
albu.OneOf([
albu.CenterCrop(
p=0.5, height=configs.input_size, width=configs.input_size),
albu.ElasticTransform(
p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=1, distort_limit=1, shift_limit=0.5),
],
p=0.8),
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
p=1),
AT.ToTensor(),
]
return albu.Compose(train_transform)
def __init__(self,
data_folder: str,
df: pd.DataFrame,
im_ids: np.array,
transforms=albu.Compose(
[albu.HorizontalFlip(),
AT.ToTensor()]),
preprocessing=None):
"""
Attributes
data_folder (str): path to the image directory
df (pd.DataFrame): dataframe with the labels
im_ids (np.ndarray): of image names.
transforms (albumentations.augmentation): transforms to apply
before preprocessing. Defaults to HFlip and ToTensor
preprocessing: ops to perform after transforms, such as
z-score standardization. Defaults to None.
"""
df["hasMask"] = ~df["EncodedPixels"].isna()
self.df = df
self.data_folder = data_folder
self.img_ids = im_ids
self.transforms = transforms
self.preprocessing = preprocessing
def __init__(self, images_path: str = './data/dataset_hdr/HDR/cs/chroma/data/Nikon_D700/HDR_MATLAB_3x3/',
gt_path: str = './data/dataset_hdr/real_illum/real_illum',
df: object = None, datatype: object = 'train',
transforms: object = albu.Compose([albu.HorizontalFlip(), AT.ToTensor()]),
preprocessing: object = None,
log_transform=False, illumination_known=False) -> object:
self.df = df
self.datatype = datatype
self.transforms = transforms
self.preprocessing = preprocessing
self.images_path = images_path
self.gt_path = gt_path
self.log_transform = log_transform
self.illumination_known = illumination_known
all_images = os.listdir(self.images_path)
self.gt_names = os.listdir(self.gt_path)
self.gt_names = list(map(lambda x: x[:-4], self.gt_names))
self.gt_names = list(filter(lambda x: x[:-11] + '.hdr' in all_images, self.gt_names))
self.image_names = list(map(lambda x: x[:-11] + '.hdr', self.gt_names))
if datatype == 'train':
self.image_names = self.image_names[0:-20]
else:
self.image_names = self.image_names[-19:]
def load(train_augmentation=[],
test_augmentation=[],
mode='default_test_aug',
mean=(0.5, 0.5, 0.5),
stdev=(0.5, 0.5, 0.5),
gpu_batch_size=128):
import numpy as np
import albumentations as A
channel_means = mean # r,g,b channels
channel_stdevs = stdev
if mode == 'default_train_aug' or mode == 'default_aug':
train_transform = AlbumentationTransforms([
A.Normalize(mean=channel_means, std=channel_stdevs),
AP.ToTensor()
])
else:
train_augmentation.extend([AP.ToTensor()])
train_transform = AlbumentationTransforms(train_augmentation)
# Test Phase transformations
if mode == 'default_test_aug' or mode == 'default_aug':
test_transform = AlbumentationTransforms([
A.Normalize(mean=channel_means, std=channel_stdevs),
AP.ToTensor()
])
else:
test_augmentation.extend([AP.ToTensor()])
test_transform = AlbumentationTransforms(test_augmentation)
#Get the Train and Test Set
trainset = torchvision.datasets.CIFAR10(root='./data',
train=True,
download=True,
transform=train_transform)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=True,
transform=test_transform)
SEED = 1
# CUDA?
cuda = torch.cuda.is_available()
print("CUDA Available?", cuda)
# For reproducibility
torch.manual_seed(SEED)
if cuda:
torch.cuda.manual_seed(SEED)
# dataloader arguments - something you'll fetch these from cmdprmt
dataloader_args = dict(shuffle=True,
batch_size=gpu_batch_size,
num_workers=4,
pin_memory=True) if cuda else dict(shuffle=True,
batch_size=64)
trainloader = torch.utils.data.DataLoader(trainset, **dataloader_args)
testloader = torch.utils.data.DataLoader(testset, **dataloader_args)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
return classes, trainloader, testloader
def __init__(self, transforms_list=[]):
transforms_list.append(AP.ToTensor())
self.transforms = A.Compose(transforms_list)
def __init__(self, transforms_list=[]):
transforms_list = []
transforms_list.append(A.Normalize(mean=0.5,std=0.5))
transforms_list.append(AP.ToTensor())
self.transforms = A.Compose(transforms_list)
def main(batch_size, lr, seed, save_model, log_interval):
# params setting
params = {'batch_size': batch_size, 'shuffle': True, 'num_workers': 1}
class_num = 2
epoch_num = 11
# cudnn setting
cudnn.benchmark = True
# tensorboard setting
writer = SummaryWriter('runs/pcam_experiment_1')
# random seed setting
seed_setting(seed)
# device setting
device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")
# print(torch.cuda.current_device())
print(device)
# define transforms
# train_transforms = transforms.Compose([
# transforms.ToPILImage(),
# transforms.Resize(224),
# transforms.RandomHorizontalFlip(),
# transforms.RandomVerticalFlip(),
# transforms.ToTensor(),
# transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225]),
# ])
# valid_transforms = transforms.Compose([
# transforms.ToPILImage(),
# transforms.Resize(224),
# transforms.ToTensor(),
# transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225]),
# ])
train_transforms = albumentations.Compose([
albumentations.Resize(224, 224),
albumentations.RandomRotate90(p=0.5),
albumentations.Transpose(p=0.5),
albumentations.Flip(p=0.5),
albumentations.OneOf([
albumentations.CLAHE(clip_limit=2),
albumentations.IAASharpen(),
albumentations.IAAEmboss(),
albumentations.RandomBrightness(),
albumentations.RandomContrast(),
albumentations.JpegCompression(),
albumentations.Blur(),
albumentations.GaussNoise()
],
p=0.5),
albumentations.HueSaturationValue(p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.15,
scale_limit=0.15,
rotate_limit=45,
p=0.5),
albumentations.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
AT.ToTensor()
])
valid_transforms = albumentations.Compose([
albumentations.Resize(224, 224),
albumentations.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
AT.ToTensor()
])
# load training set
trainset = Pcam('data/camelyonpatch_level_2_split_train_x.h5',
'data/camelyonpatch_level_2_split_train_y.h5',
train_transforms)
trainloader = data.DataLoader(trainset, **params)
# load validation set
validset = Pcam('data/camelyonpatch_level_2_split_valid_x.h5',
'data/camelyonpatch_level_2_split_valid_y.h5',
valid_transforms)
validloader = data.DataLoader(validset, **params)
# load pretrained model
model = models.resnet50(pretrained=True)
print(model)
# freeze op
# for param in model.parameters():
# param.requires_grad = False
fc_in_feature = model.fc.in_features
model.fc = nn.Sequential(
nn.Dropout(p=0.6),
nn.Linear(fc_in_feature, 512, bias=True),
nn.SELU(),
nn.Dropout(p=0.8),
nn.Linear(512, class_num, bias=True),
)
model.to(device)
# define loss function and optimizer
criterion = nn.CrossEntropyLoss()
# setting optimizer
ignored_params = list(map(id, model.fc.parameters()))
base_params = filter(lambda p: id(p) not in ignored_params,
model.parameters())
optimizer = torch.optim.Adam([{
'params': base_params,
'lr': 2e-4
}, {
'params': model.fc.parameters(),
'lr': 4e-4
}],
weight_decay=1e-4)
# optimizer = optim.Adam(model.fc.parameters(), lr=lr, weight_decay=1e-4)
# lr_scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=5)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)
# lr_scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)
# lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.01, steps_per_epoch=1, epochs=16)
# clock setting
start = time.time()
# train + valid
for epoch in range(1, epoch_num + 1):
lr_scheduler.step()
print('learning rate: {}'.format(
optimizer.state_dict()['param_groups'][0]['lr']))
train(model, trainloader, criterion, optimizer, epoch, log_interval,
device, writer)
# trainset.close()
test(model, validloader, criterion, device, writer, epoch, True)
print('finish testing')
# validset.close()
if save_model:
torch.save(model.state_dict(),
'./checkpoints/epoch{}.pth'.format(epoch))
print('finish saving epoch{}'.format(epoch))
print('Finish Training, Total Time: {}'.format(time.time() - start))
def albumentations_transforms(data_map,
data_stats,
do_img_aug=False,
im_size=64):
transforms_list_map = {}
transforms_map = {}
for dname in data_map.keys():
transforms_list_map[dname] = []
# Resize
size = (im_size, im_size)
for k, v in transforms_list_map.items():
v.append(
A.Resize(height=size[0],
width=size[0],
interpolation=cv2.INTER_LANCZOS4,
always_apply=True))
# Use data aug only for train data
if do_img_aug:
# RGB shift and Hue Saturation value
for k, v in transforms_list_map.items():
if k not in ("bg", "fg_bg"):
continue
v.append(
A.OneOf([
A.RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5)
],
p=0.5))
# GaussNoise
for k, v in transforms_list_map.items():
if k not in ("bg", "fg_bg"):
continue
v.append(A.GaussNoise(p=0.5))
# Random horizontal flipping
if random.random() > 0.5:
for k, v in transforms_list_map.items():
v.append(A.HorizontalFlip(always_apply=True))
# Random vertical flipping
if random.random() > 0.7:
for k, v in transforms_list_map.items():
v.append(A.VerticalFlip(always_apply=True))
# Random rotate
if random.random() > 0.3:
angle = random.uniform(-15, 15)
for k, v in transforms_list_map.items():
v.append(
A.Rotate(limit=(angle, angle),
interpolation=cv2.INTER_LANCZOS4,
always_apply=True))
# Coarse dropout
for k, v in transforms_list_map.items():
if k not in ("bg", "fg_bg"):
continue
v.append(
A.CoarseDropout(max_holes=2,
fill_value=0,
max_height=size[0] // 3,
max_width=size[1] // 4,
p=0.5))
# fill_value=data_stats[k]["mean"]*255.0
# for k, v in transforms_list_map.items():
# v.append(
# A.Normalize(
# mean=data_stats[k]["mean"],
# std=data_stats[k]["std"],
# max_pixel_value=255.0,
# always_apply=True
# )
# )
for k, v in transforms_list_map.items():
v.append(AP.ToTensor())
for k, v in transforms_list_map.items():
np_img = np.array(data_map[k])
if np_img.ndim == 2:
np_img = np_img[:, :, np.newaxis]
transforms_map[k] = A.Compose(v, p=1.0)(image=np_img)["image"]
# transforms_map["fg_bg_mask"] = torch.gt(transforms_map["fg_bg_mask"], 0.8).float()
return transforms_map
def __init__(self, normalize=None):
super(ToTensor, self).__init__(always_apply=True, p=1)
self.alb_totensor = alb_pytorch.ToTensor()
self.normalize = normalize