mean = torch.mean(img_tensor)
img_tensor -= mean
if self.use_std:
img_var = torch.var(img_tensor)
else:
img_var = torch.sum(torch.pow(img_tensor, 2.0))
normalizer = np.sqrt(self.sqrt_bias + img_var) / self.scale
normalizer = 1.0 if normalizer < self.min_divisor else normalizer
return img_tensor / normalizer
train_data_transform = [
RandomCrop(size=32, padding=4),
RandomHorizontalFlip(p=0.5),
RandomVerticalFlip(p=0.5),
ColorJitter(hue=0.1, brightness=0.1),
ToTensor(),
# https://github.com/lisa-lab/pylearn2/blob/master/pylearn2/scripts/datasets/make_cifar10_gcn_whitened.py#L19
GlobalContrastNormalize(scale=55.0)
]
val_data_transform = [
RandomHorizontalFlip(p=0.5),
RandomVerticalFlip(p=0.5),
ToTensor(),
# https://github.com/lisa-lab/pylearn2/blob/master/pylearn2/scripts/datasets/make_cifar10_gcn_whitened.py#L58
GlobalContrastNormalize(scale=55.0)
]
test_data_transform = val_data_transform
def run(max_epochs=100):
transform = Compose([
# Resize every image to a 224x244 square
Resize((224, 224)),
RandomCrop(224, 8, padding_mode="edge"),
RandomHorizontalFlip(),
RandomVerticalFlip(),
# Convert to a tensor that PyTorch can work with
ToTensor()
])
# Images are located at at {dataset_path}/{class_name}/{objid}.jpg
dataset_train = ImageFolder(TRAINING_PATH, transform)
dataset_val = ImageFolder(TRAINING_PATH, transform)
# Make sure that the class names are identical
assert dataset_train.classes == dataset_val.classes
model = models.resnet18(pretrained=True)
# get the number of features that are input to the fully connected layer
num_ftrs = model.fc.in_features
# reset the fully connect layer
model.fc = nn.Linear(num_ftrs, len(dataset_train.classes))
# Transfer model to GPU
model = model.cuda()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
loader_train = torch.utils.data.DataLoader(dataset_train,
batch_size=128,
sampler=StratifiedSampler(
dataset_train.targets),
num_workers=4)
loader_val = torch.utils.data.DataLoader(dataset_val,
batch_size=128,
num_workers=4,
shuffle=True)
trainer = create_supervised_trainer(model,
optimizer,
F.cross_entropy,
device="cuda")
train_evaluator = create_supervised_evaluator(model,
metrics={
'accuracy': Accuracy(),
'nll':
Loss(F.cross_entropy)
},
device="cuda")
val_evaluator = create_supervised_evaluator(model,
metrics={
'accuracy': Accuracy(),
'nll':
Loss(F.cross_entropy)
},
device="cuda")
desc = "ITERATION - loss: {:.2f}"
log_interval = 1
pbar = tqdm(initial=0,
leave=False,
total=len(loader_train),
desc=desc.format(0))
@trainer.on(Events.ITERATION_COMPLETED)
def log_training_loss(engine):
iter = (engine.state.iteration - 1) % len(loader_train) + 1
if iter % log_interval == 0:
pbar.desc = desc.format(engine.state.output)
pbar.update(log_interval)
# Display training metrics after each epoch
@trainer.on(Events.EPOCH_COMPLETED)
def log_training_results(engine):
pbar.refresh()
print("Evaluating...")
train_evaluator.run(loader_train)
metrics = train_evaluator.state.metrics
avg_accuracy = metrics['accuracy']
avg_nll = metrics['nll']
tqdm.write(
"Training Results - Epoch: {} Avg accuracy: {:.2f} Avg loss: {:.2f}"
.format(engine.state.epoch, avg_accuracy, avg_nll))
# Display validation metrics after each epoch
@trainer.on(Events.EPOCH_COMPLETED)
def log_validation_results(engine):
val_evaluator.run(loader_val)
metrics = val_evaluator.state.metrics
avg_accuracy = metrics['accuracy']
avg_nll = metrics['nll']
tqdm.write(
"Validation Results - Epoch: {} Avg accuracy: {:.2f} Avg loss: {:.2f}"
.format(engine.state.epoch, avg_accuracy, avg_nll))
pbar.n = pbar.last_print_n = 0
def score_function(engine):
val_loss = engine.state.metrics['nll']
return -val_loss
handler = EarlyStopping(patience=10,
score_function=score_function,
trainer=trainer)
val_evaluator.add_event_handler(Events.COMPLETED, handler)
handler = ModelCheckpoint('models',
'myprefix',
create_dir=True,
n_saved=20,
score_function=score_function,
score_name="val_loss",
save_as_state_dict=False)
val_evaluator.add_event_handler(Events.EPOCH_COMPLETED, handler,
{'model': model})
trainer.run(loader_train, max_epochs=max_epochs)
pbar.close()
def build_data(self):
cfg = self.cfg
batch_sz = cfg.solver.batch_sz
num_workers = cfg.data.num_workers
# download and unzip data
if cfg.data.uri.startswith('s3://') or cfg.data.uri.startswith('/'):
data_uri = cfg.data.uri
else:
data_uri = join(cfg.base_uri, cfg.data.uri)
data_dirs = []
zip_uris = [data_uri] if data_uri.endswith('.zip') else list_paths(
data_uri, 'zip')
for zip_ind, zip_uri in enumerate(zip_uris):
zip_path = get_local_path(zip_uri, self.data_cache_dir)
if not isfile(zip_path):
zip_path = download_if_needed(zip_uri, self.data_cache_dir)
with zipfile.ZipFile(zip_path, 'r') as zipf:
data_dir = join(self.tmp_dir, 'data', str(zip_ind))
data_dirs.append(data_dir)
zipf.extractall(data_dir)
# build datasets -- one per zip file and then merge them into a single dataset
train_ds = []
valid_ds = []
test_ds = []
for data_dir in data_dirs:
train_dir = join(data_dir, 'train')
valid_dir = join(data_dir, 'valid')
transform = Compose(
[Resize((cfg.data.img_sz, cfg.data.img_sz)),
ToTensor()])
aug_transform = Compose([
RandomHorizontalFlip(),
RandomVerticalFlip(),
ColorJitter(0.1, 0.1, 0.1, 0.1),
Resize((cfg.data.img_sz, cfg.data.img_sz)),
ToTensor()
])
if isdir(train_dir):
if cfg.overfit_mode:
train_ds.append(
ImageRegressionDataset(
train_dir,
cfg.data.class_names,
transform=transform))
else:
train_ds.append(
ImageRegressionDataset(
train_dir,
cfg.data.class_names,
transform=aug_transform))
if isdir(valid_dir):
valid_ds.append(
ImageRegressionDataset(
valid_dir, cfg.data.class_names, transform=transform))
test_ds.append(
ImageRegressionDataset(
valid_dir, cfg.data.class_names, transform=transform))
train_ds, valid_ds, test_ds = \
ConcatDataset(train_ds), ConcatDataset(valid_ds), ConcatDataset(test_ds)
if cfg.overfit_mode:
train_ds = Subset(train_ds, range(batch_sz))
valid_ds = train_ds
test_ds = train_ds
elif cfg.test_mode:
train_ds = Subset(train_ds, range(batch_sz))
valid_ds = Subset(valid_ds, range(batch_sz))
test_ds = Subset(test_ds, range(batch_sz))
train_dl = DataLoader(
train_ds,
shuffle=True,
batch_size=batch_sz,
num_workers=num_workers,
pin_memory=True)
valid_dl = DataLoader(
valid_ds,
shuffle=True,
batch_size=batch_sz,
num_workers=num_workers,
pin_memory=True)
test_dl = DataLoader(
test_ds,
shuffle=True,
batch_size=batch_sz,
num_workers=num_workers,
pin_memory=True)
self.train_ds, self.valid_ds, self.test_ds = (train_ds, valid_ds,
test_ds)
self.train_dl, self.valid_dl, self.test_dl = (train_dl, valid_dl,
test_dl)
def __init__(self, p: float = 1.0):
super().__init__(p=p)
self.flip_v = RandomVerticalFlip(1.0)
from numpy import array, asarray
from numpy.random import randint, uniform
from PIL import Image
from torchvision.transforms import RandomHorizontalFlip, RandomVerticalFlip, Resize
from torchvision.transforms.functional import crop
HORIZONTAL_FLIP = RandomHorizontalFlip(1.0)
VERTICAL_FLIP = RandomVerticalFlip(1.0)
class LocRandomHorizontalFlip:
"""Random horizontal flip.
Represents random horizontal flip which transforms an image and a bounding box.
"""
def __init__(self, p: float = 0.5):
"""Initializes a random horizontal flip.
Parameters
----------
p : float
Probability with which transformation is applied.
"""
self.p = p
def __call__(self, img: Image, bounding_box: array) -> tuple:
"""Applies random horizontal flip on an image and a bounding box.
Parameters
----------
img : Image
def main(argv):
TRAIN, NOISE_TYPES, IMAGE_SIZE, FRAME_SIZE, OVERLAY_SIZE, LATENT_CLEAN_SIZE, BATCH_SIZE, EPOCHS, TEST = arguments_parsing(argv)
if TRAIN:
print('model training with parameters:\n'+
'noise types = {}\n'.format(NOISE_TYPES)+
'image size = {}\n'.format(IMAGE_SIZE)+
'frame size = {}\n'.format(FRAME_SIZE)+
'overlay size = {}\n'.format(OVERLAY_SIZE)+
'latent clean size = {}\n'.format(LATENT_CLEAN_SIZE)+
'batch size = {}\n'.format(BATCH_SIZE)+
'number of epochs = {}\n'.format(EPOCHS))
# dataset table creating
make_dataset_table(PATH_TO_DATA, NOISE_TYPES, PATH_TO_DATASET_TABLE)
train_test_split(PATH_TO_DATASET_TABLE, test_size=0.2)
# dataset and dataloader creating
torch.manual_seed(0)
transforms = [Compose([RandomHorizontalFlip(p=1.0), ToTensor()]),
Compose([RandomVerticalFlip(p=1.0), ToTensor()]),
Compose([ColorJitter(brightness=(0.9, 2.0), contrast=(0.9, 2.0)), ToTensor()])]
train_dataset = []
for transform in transforms:
dataset = DenoisingDataset(dataset=pd.read_csv(PATH_TO_DATASET_TABLE),
image_size=IMAGE_SIZE,
frame_size=FRAME_SIZE,
overlay_size=OVERLAY_SIZE,
phase='train',
transform=transform)
train_dataset = ConcatDataset([train_dataset, dataset])
train_loader = DataLoader(dataset=train_dataset,
batch_size=BATCH_SIZE,
shuffle=True, # can be set to True only for train loader
num_workers=0)
# model training
model = AE(1, LATENT_CLEAN_SIZE)
loss = SSIMLoss()
latent_loss = MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1.0e-3)
model = train_model(model, train_loader,
loss, latent_loss,
optimizer,
epochs=EPOCHS,
device=DEVICE)
# model saving
path_to_model = './model' + '_{}'.format('_'.join([str(elem) for elem in NOISE_TYPES])) + '.pth'
torch.save(model, path_to_model)
if TEST:
# model loading
path_to_model = './model' + '_{}'.format('_'.join([str(elem) for elem in NOISE_TYPES])) + '.pth'
print('{} testing...\n'.format(os.path.basename(path_to_model)))
model = torch.load(path_to_model)
dataset=pd.read_csv(PATH_TO_DATASET_TABLE)
test_dataset = dataset[dataset['phase']=='test']
# model testing and results saving
loss = SSIMLoss()
latent_loss = MSELoss()
print('{} evaluation on test images'.format(os.path.basename(path_to_model)))
test_evaluation(model, test_dataset,
loss, latent_loss,
device=DEVICE)
print()
path_to_results = PATH_TO_RESULTS + '_{}'.format('_'.join([str(elem) for elem in NOISE_TYPES]))
if not os.path.exists(path_to_results):
os.makedirs(path_to_results)
print('{} running and results saving'.format(os.path.basename(path_to_model)))
test_model(model, test_dataset, path_to_results)
print('process completed: OK')
def Rand_Flip2(im):
transform = transforms.Compose([
RandomVerticalFlip(),
])
return transform(im)
augmentation = [
aug for aug, valid in zip(self.augmentation, aug_bins)
if bool(valid)
]
aug_compose = Compose(augmentation)
input_img = self._load_input_image(input_fpath)
input_img = aug_compose(input_img)
input_img = self.input_resize(input_img)
input_img = self.input_transform(input_img)
target_img = None
if target_fpath is not None:
target_img = self._load_target_image(target_fpath)
target_img = aug_compose(target_img)
target_img = self.target_resize(target_img)
target_img = self.target_transform(target_img)
fname = os.path.basename(input_fpath).split(".")[0]
return input_img, target_img, fname
if __name__ == "__main__":
fpath = "/Users/vribeiro/Documents/isic/train.txt"
augmetation = [RandomHorizontalFlip(p=1.0), RandomVerticalFlip(p=1.0)]
dataset = SegANDataset(fpath, augmetation)
for input_img, target_img, fname in dataset:
print(input_img.size(), target_img.size())
# Required config param
config_class = BasicTrainConfig
# Optional config param
seed = 12345
# Optional config param
device = 'cuda'
batch_size = 128
num_workers = 8
train_data_augs = Compose([
RandomHorizontalFlip(),
RandomVerticalFlip(),
ColorJitter(),
ToTensor(),
Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
val_data_augs = Compose(
[ToTensor(),
Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])
# Required config param
train_dataloader = get_basic_dataloader("train",
batch_size,
num_workers,
device=device,
data_augs=train_data_augs)
