def get_transform_2(train):
transforms = []
# converts the image, a PIL image, into a PyTorch Tensor
transforms.append(T.ToTensor())
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
return T.Compose(transforms)
def get_transform(train, p=0.5):
transforms = []
transforms.append(ToTensor(
)) # one of ToTensor()'s function is converts [0, 255] to [0, 1]
if train:
transforms.append(RandomHorizontalFlip(p))
return Compose(transforms)
def get_transform(train):
transforms = []
transforms.append(T.ToTensor())
# transforms.append(T.Normalize(mean=(0.485, 0.456, 0.406),std=(0.229, 0.224, 0.225)))
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
return T.Compose(transforms)
def generate_dataset(in_dir, out_dir, ann_ext, **kwargs):
"""
Generates a single-beat dataset based on a folder containing WFDB records.
"""
transforms = []
if kwargs['transform_lpf']:
transforms.append(ecgbc.dataset.transforms.LowPassFilterWFDB())
if kwargs['transform_sma']:
transforms.append(ecgbc.dataset.transforms.SubtractMovingAverageWFDB())
wfdb_dataset = ecgbc.dataset.wfdb_dataset.WFDBDataset(
root_path=in_dir,
recname_pattern=kwargs['rec_pattern'],
transform=torchvision.transforms.Compose(transforms))
generator = ecgbc.dataset.wfdb_single_beat.Generator(
wfdb_dataset,
in_ann_ext=ann_ext,
out_ann_ext=f'ecg{ann_ext}',
calculate_rr_features=True,
filter_rri=kwargs['filter_rri'],
aami_compatible=kwargs['aami'])
generator.write(out_dir)
dataset = ecgbc.dataset.wfdb_single_beat.SingleBeatDataset(out_dir)
print(dataset)
def get_transform(train):
transforms = []
transforms.append(T.ToTensor())
# transforms.append(T.Normalize(mean=(0.3520, 0.3520, 0.3520),std=(0.2930, 0.2930, 0.2930)))
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
return T.Compose(transforms)
def get_transform(train):
transforms = []
# converts the image, a PIL image, into a PyTorch Tensor
transforms.append(T.ToTensor())
if train:
# during training, randomly flip the training images
# and ground-truth for data augmentation
transforms.append(T.RandomHorizontalFlip(0.5))
return T.Compose(transforms)
def get_transform(train=True):
transforms = []
transforms.append(T.ToTensor())
if train:
# transforms.append(T.Occlude((0, 1.0)))
pass
else:
# transforms.append(T.Occlude((0.4, 0.8)))
transforms.append(T.ToPILImage())
return T.Compose(transforms)
def get_transform(cfg):
transforms = []
for t in cfg:
name, params = list(t.items())[0]
if params is None:
params = {}
t = getattr_mods([
torchvision.transforms,
horch.transforms,
], name)(**params)
transforms.append(t)
return Compose(transforms)
def __call__(self, img):
transforms = []
noise = np.random.choice([1, 2])
noise = 2
if noise == 1:
transforms.append(
Lambda(lambda img: self.camera_noise(img, self.sigma)))
else:
transforms.append(
Lambda(lambda img: self.gaussian_noise(img, self.sigma)))
transform = torchvision.transforms.Compose(transforms)
return transform(img)
def get_params(brightness, contrast, saturation, hue):
"""Get a randomized transform to be applied on image.
Arguments are same as that of __init__.
Returns:
Transform which randomly adjusts brightness, contrast and
saturation in a random order.
"""
transforms = []
if brightness > 0:
brightness_factor = random.uniform(max(0, 1 - brightness), 1 + brightness)
transforms.append(Lambda(lambda img: F.adjust_brightness(img, brightness_factor)))
if contrast > 0:
contrast_factor = random.uniform(max(0, 1 - contrast), 1 + contrast)
transforms.append(Lambda(lambda img: F.adjust_contrast(img, contrast_factor)))
if saturation > 0:
saturation_factor = random.uniform(max(0, 1 - saturation), 1 + saturation)
transforms.append(Lambda(lambda img: F.adjust_saturation(img, saturation_factor)))
if hue > 0:
hue_factor = random.uniform(-hue, hue)
transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor)))
random.shuffle(transforms)
transform = Compose(transforms)
return transform
def get_params(brightness, contrast, saturation, hue):
"""Get a randomized transform to be applied on image.
Arguments are same as that of __init__.
Returns:
Transform which randomly adjusts brightness, contrast and
saturation in a random order.
"""
transforms = []
if brightness is not None:
brightness_factor = random.uniform(brightness[0], brightness[1])
transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_brightness(img, brightness_factor)))
if contrast is not None:
contrast_factor = random.uniform(contrast[0], contrast[1])
transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_contrast(img, contrast_factor)))
if saturation is not None:
saturation_factor = random.uniform(saturation[0], saturation[1])
transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_saturation(img, saturation_factor)))
if hue is not None:
hue_factor = random.uniform(hue[0], hue[1])
transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_hue(img, hue_factor)))
random.shuffle(transforms)
transform = torchvision.transforms.Compose(transforms)
return transform
def get_transform(train):
base_size = 520
crop_size = 480
min_size = int((0.5 if train else 1.0) * base_size)
max_size = int((2.0 if train else 1.0) * base_size)
transforms = []
transforms.append(T.RandomResize(min_size, max_size))
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomCrop(crop_size))
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
def __init__(self, opts, phase='train', input_dim=3):
self.dataroot = opts.dataroot
images = os.listdir(os.path.join(self.dataroot, phase))
self.img_A = [os.path.join(self.dataroot, phase, x) for x in images]
self.size = len(self.img_A)
self.input_dim = input_dim
self.img_B = [os.path.join(self.dataroot, phase, x) for x in images]
self.pair = opts.pair
if self.pair == 'False':
random.shuffle(self.img_B)
# setup image transformation
transforms = [
Resize((opts.crop_size, opts.crop_size * 2), Image.BICUBIC)
]
#transforms.append(CenterCrop(opts.crop_size))
transforms.append(ToTensor())
transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
self.transforms = Compose(transforms)
print('edge2shoes: %d images' % (self.size))
return
def create_transforms(self):
transforms = []
# clipping to remove outliers (if any)
# clip_intensity = Lambda(VolumeDataset.clip_image, types_to_apply=[torchio.INTENSITY])
# transforms.append(clip_intensity)
rescale = RescaleIntensity((-1, 1), percentiles=(0.5, 99.5))
# normalize with mu = 0 and sigma = 1/3 to have data in -1...1 almost
# ZNormalization()
transforms.append(rescale)
# transforms = [rescale]
# # As RandomAffine is faster then RandomElasticDeformation, we choose to
# # apply RandomAffine 80% of the times and RandomElasticDeformation the rest
# # Also, there is a 25% chance that none of them will be applied
# if self.opt.isTrain:
# spatial = OneOf(
# {RandomAffine(translation=5): 0.8, RandomElasticDeformation(): 0.2},
# p=0.75,
# )
# transforms += [RandomFlip(axes=(0, 2), p=0.8), spatial]
self.ratio = self.min_size / np.max(self.input_size)
transforms.append(Resample(self.ratio))
transforms.append(CropOrPad(self.input_size))
transform = Compose(transforms)
return transform
def __init__(self, opts):
self.dataroot = opts.dataroot
# A
images_A = os.listdir(os.path.join(self.dataroot, opts.phase + 'A'))
self.A = [
os.path.join(self.dataroot, opts.phase + 'A', x) for x in images_A
]
# B
images_B = os.listdir(os.path.join(self.dataroot, opts.phase + 'B'))
self.B = [
os.path.join(self.dataroot, opts.phase + 'B', x) for x in images_B
]
self.A_size = len(self.A)
self.B_size = len(self.B)
self.dataset_size = max(self.A_size, self.B_size)
self.input_dim_A = opts.input_dim_a
self.input_dim_B = opts.input_dim_b
# setup image transformation
transforms = [
Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)
]
if opts.phase == 'train':
transforms.append(RandomCrop(opts.crop_size))
else:
transforms.append(CenterCrop(opts.crop_size))
if not opts.no_flip:
transforms.append(RandomHorizontalFlip())
transforms.append(ToTensor())
transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
# transforms.append(Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
self.transforms = Compose(transforms)
print('A: %d, B: %d images' % (self.A_size, self.B_size))
return
def get_transform(settings):
transform = []
if not settings.isToTensor:
transforms.append(T.ToTensor())
if not settings.isRandomHorizontalFlip:
if not settings.mRandomHorizontalFlip:
transforms.append(
T.RandomHorizontalFlip(settings.mRandomHorizontalFlip))
else:
transforms.append(T.RandomHorizontalFlip(0.5))
def __init__(self, brightness=0.4, contrast=0.4, saturation=0.4):
transforms = []
if brightness != 0:
transforms.append(Brightness(brightness))
if contrast != 0:
transforms.append(Contrast(contrast))
if saturation != 0:
transforms.append(Saturation(saturation))
RandomOrder.__init__(self, transforms)
def get_transform(train):
transforms = []
# converts the image, a PIL image, into a PyTorch Tensor
transforms.append(T.ToTensor())
if train:
# during training, randomly flip the training images
# and ground-truth for data augmentation
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
def __call__(self, img):
transforms = []
noise = np.random.choice([1, 2 , 3])
dispersion = random.uniform(self.sigmas [0], self.sigmas[1])
if noise == 1:
transforms.append(Lambda(lambda img: self.camera_noise(img, dispersion)))
elif noise == 2:
transforms.append(Lambda(lambda img: self.perlin_noise(img, dispersion)))
transforms.append(Lambda(lambda img: self.luma_noise(img, dispersion)))
random.shuffle(transforms)
else:
transforms.append(Lambda(lambda img: self.gaussian_noise(img, dispersion)))
random.shuffle(transforms)
transform = torchvision.transforms.Compose(transforms)
return transform(img)
def get_params(brightness, contrast, saturation, hue):
transforms = []
if brightness is not None:
brightness_factor = random.uniform(brightness[0], brightness[1])
transforms.append(
Lambda(
lambda img: F.adjust_brightness(img, brightness_factor)))
if contrast is not None:
contrast_factor = random.uniform(contrast[0], contrast[1])
transforms.append(
Lambda(lambda img: F.adjust_contrast(img, contrast_factor)))
if saturation is not None:
saturation_factor = random.uniform(saturation[0], saturation[1])
transforms.append(
Lambda(
lambda img: F.adjust_saturation(img, saturation_factor)))
if hue is not None:
hue_factor = random.uniform(hue[0], hue[1])
transforms.append(
Lambda(lambda img: F.adjust_hue(img, hue_factor)))
random.shuffle(transforms)
transform = Compose(transforms)
return transform
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms
from torch.autograd import Variable
from torch.utils.data import dataloader
from dense import FCDenseNet103
from coburn.data import loader, preprocess, postprocess
SIZE = 256 # images will be resized to SIZE x SIZE before being fed into the network
# create tranform for input data
transforms = []
resize_transform = preprocess.UniformResize(SIZE, SIZE)
transforms.append(resize_transform)
# convert the time series into an image with one channel
variance_transform = preprocess.Variance()
transforms.append(variance_transform)
# convert the input to a torch Tensor
transforms.append(preprocess.ToArray())
transforms.append(torchvision.transforms.ToTensor())
# compose the transforms
data_transform = torchvision.transforms.Compose(transforms)
def train(input, epochs=200, learning_rate=1e-4):
dataset = loader.load('train', base_dir=input)
def init_biobank_age_dataloader(opt, shuffle_test=False):
"""
Initialize both datasets and dataloaders
image_size = [128, 160, 128]
:param opt: options
:param shuffle_test: whether to shuffle test data
:return: dataloader
"""
if (not opt.aug_rician_noise == None) or (not opt.aug_bspline_deformation
== None) or (not opt.resize_image
== None):
transforms = []
else:
transforms = None
if opt.resize_image:
transforms.append(ResizeImage(image_size=opt.resize_size))
if opt.aug_rician_noise:
transforms.append(RicianNoise(noise_level=opt.aug_rician_noise))
if opt.aug_bspline_deformation:
transforms.append(
ElasticDeformationsBspline(
num_controlpoints=opt.aug_bspline_deformation[0],
sigma=opt.aug_bspline_deformation[1]))
if opt.aug_rician_noise or opt.aug_bspline_deformation or opt.resize_image:
transforms = torchvision.transforms.Compose(transforms)
healthy_train = BiobankRegAgeDataset(image_path=opt.dataroot + '_data',
label_path=opt.label_path,
class_bins=opt.age_range_0,
class_label=0,
get_id=opt.get_id,
transform=transforms)
anomaly_train = BiobankRegAgeDataset(image_path=opt.dataroot + '_data',
label_path=opt.label_path,
class_bins=opt.age_range_1,
class_label=1,
get_id=opt.get_id,
transform=transforms)
healthy_dataloader_train, healthy_dataloader_val, healthy_dataloader_test = train_val_test_split(
healthy_train,
val_split=0.05,
test_split=0.05,
random_seed=opt.random_seed)
anomaly_dataloader_train, anomaly_dataloader_val, anomaly_dataloader_test = train_val_test_split(
anomaly_train,
val_split=0.05,
test_split=0.05,
random_seed=opt.random_seed)
print('Train data length: ',
len(healthy_dataloader_train), 'Val data length: ',
len(healthy_dataloader_val), 'Test data length: ',
len(healthy_dataloader_test))
print('Train data length: ',
len(anomaly_dataloader_train), 'Val data length: ',
len(anomaly_dataloader_val), 'Test data length: ',
len(anomaly_dataloader_test))
healthy_dataloader_train = torch.utils.data.DataLoader(
healthy_dataloader_train, batch_size=opt.batch_size // 2, shuffle=True)
anomaly_dataloader_train = torch.utils.data.DataLoader(
anomaly_dataloader_train, batch_size=opt.batch_size // 2, shuffle=True)
healthy_dataloader_val = torch.utils.data.DataLoader(
healthy_dataloader_val, batch_size=opt.batch_size // 2, shuffle=True)
anomaly_dataloader_val = torch.utils.data.DataLoader(
anomaly_dataloader_val, batch_size=opt.batch_size // 2, shuffle=True)
healthy_dataloader_test = torch.utils.data.DataLoader(
healthy_dataloader_test,
batch_size=opt.batch_size // 2,
shuffle=shuffle_test)
anomaly_dataloader_test = torch.utils.data.DataLoader(
anomaly_dataloader_test,
batch_size=opt.batch_size // 2,
shuffle=shuffle_test)
return healthy_dataloader_train, healthy_dataloader_val, healthy_dataloader_test, anomaly_dataloader_train, anomaly_dataloader_val, anomaly_dataloader_test
def get_transform():
transforms = []
transforms.append(ToTensor())
return Compose(transforms)
def get_transform(train):
transforms = []
transforms.append(T.ToTensor())
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
return T.Compose(transforms)
def get_transform():
transforms = []
# converts the image, a PIL image, into a PyTorch Tensor
transforms.append(T.ToTensor2())
return T.Compose(transforms)
def get_transform(train):
transforms = []
transforms.append(T.ToTensor())
return T.Compose(transforms)
def openSet_experiments(mode, args):
# parser = argparse.ArgumentParser()
# parser.add_argument("--mode",type=str)
if mode == 'openSet-train':
# datasets = args.splitType[1:]
# print(datasets)
datasetAll, labelsAll, numFramesAll, transforms = [], [], [], []
for dt in args.dataset:
print(dt)
x, y, num, tr = base_dataset(dt)
datasetAll += x
labelsAll += y
numFramesAll += num
transforms.append(tr)
combined = list(zip(datasetAll, labelsAll, numFramesAll))
random.shuffle(combined)
datasetAll[:], labelsAll[:], numFramesAll[:] = zip(*combined)
train_dataset = ViolenceDataset(
dataset=datasetAll,
labels=labelsAll,
numFrames=numFramesAll,
spatial_transform=transforms[0]['train'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen)
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batchSize,
shuffle=True,
num_workers=args.numWorkers)
dataloaders = {'train': train_dataloader}
model, _ = initialize_model(
model_name=args.modelType,
num_classes=2,
freezeConvLayers=args.freezeConvLayers,
numDiPerVideos=args.numDynamicImagesPerVideo,
joinType=args.joinType,
use_pretrained=True)
model.to(DEVICE)
params_to_update = verifiParametersToTrain(model,
args.freezeConvLayers,
printLayers=True)
# print(params_to_update)
optimizer = optim.SGD(params_to_update, lr=0.001, momentum=0.9)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer,
step_size=7,
gamma=0.1)
criterion = nn.CrossEntropyLoss()
fold = 0
checkpoint_path = None
config = None
if args.saveCheckpoint:
config = {
'dataset': args.dataset,
'model': args.modelType,
'numEpochs': args.numEpochs,
'freezeConvLayers': args.freezeConvLayers,
'numDynamicImages': args.numDynamicImagesPerVideo,
'segmentLength': args.videoSegmentLength,
'frameSkip': args.frameSkip,
'skipInitialFrames': args.skipInitialFrames,
'overlap': args.overlapping,
'joinType': args.joinType,
'log_dir': None,
'useKeyframes': args.useKeyframes,
'windowLen': args.windowLen
}
ss = ""
for (key, val) in config.items():
if key != 'log_dir':
ss = ss + "_{!s}={!r}".format(key, val)
ss = ss.replace("\'", "")
# print(ss)
checkpoint_path = os.path.join(
constants.PATH_RESULTS, 'OPENSET', 'checkpoints',
'DYN_Stream-{}-fold={}'.format(ss, fold))
phases = ['train']
model, best_acc, val_loss_min, best_epoch = train_model(
model,
dataloaders,
criterion,
optimizer,
num_epochs=args.numEpochs,
patience=args.patience,
fold=fold,
path=checkpoint_path,
model_config=config,
phases=phases,
metric_to_track='train-loss')
elif mode == 'openSet-test':
## Load model
checkpoint = torch.load(args.modelPath, map_location=DEVICE)
model = checkpoint['model_config']['model']
numDynamicImages = checkpoint['model_config']['numDynamicImages']
joinType = checkpoint['model_config']['joinType']
freezeConvLayers = checkpoint['model_config']['freezeConvLayers']
videoSegmentLength = checkpoint['model_config']['segmentLength']
overlapping = checkpoint['model_config']['overlap']
frameSkip = checkpoint['model_config']['frameSkip']
skipInitialFrames = checkpoint['model_config']['skipInitialFrames']
useKeyframes = checkpoint['model_config']['useKeyframes']
windowLen = checkpoint['model_config']['windowLen']
model_, _ = initialize_model(model_name=model,
num_classes=2,
freezeConvLayers=freezeConvLayers,
numDiPerVideos=numDynamicImages,
joinType=joinType,
use_pretrained=True)
model_.to(DEVICE)
# print(model_)
if DEVICE == 'cuda:0':
model_.load_state_dict(checkpoint['model_state_dict'],
strict=False)
else:
model_.load_state_dict(checkpoint['model_state_dict'])
datasetAll, labelsAll, numFramesAll, transforms = base_dataset(
args.testDataset)
test_dataset = ViolenceDataset(
dataset=datasetAll,
labels=labelsAll,
numFrames=numFramesAll,
spatial_transform=transforms['val'],
numDynamicImagesPerVideo=numDynamicImages,
videoSegmentLength=videoSegmentLength,
positionSegment=None,
overlaping=overlapping,
frame_skip=frameSkip,
skipInitialFrames=skipInitialFrames,
ppType=None,
useKeyframes=useKeyframes,
windowLen=windowLen)
test_dataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=8,
shuffle=True,
num_workers=4)
test_model(model_, test_dataloader)
