def _make_dataset(self,
image_path,
train_path,
batch_size,
val_path=None,
num_workers=6):
train_trans = [
CropResize(self.size),
Normalization([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
]
train_trans = Compose(train_trans)
train_data = MaskData(image_path, train_path, (self.size, self.size),
train_trans)
self.train_loader = DataLoader(train_data,
batch_size,
True,
num_workers=num_workers,
pin_memory=True)
if val_path:
val_trans = [
CropResize(self.size),
Normalization([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
]
val_trans = Compose(val_trans)
val_data = MaskData(image_path, val_path, (self.size, self.size),
val_trans)
self.val_loader = DataLoader(val_data,
batch_size,
num_workers=num_workers,
pin_memory=True)
else:
self.val_loader = None
def get_dataset(dataset):
if dataset == 'imagenet':
transform_train = Compose([
RandomResizedCrop(C.get()['target_size'] + 32,
scale=(0.9, 1.0),
interpolation=PIL.Image.BICUBIC),
])
transform_test = Compose([
Resize(C.get()['target_size'] + 32,
interpolation=PIL.Image.BICUBIC)
])
trainset = ImageNet(root=imagenet_path,
split='train',
transform=transform_train)
testset1 = ImageNet(root=imagenet_path,
split='val',
transform=transform_train)
testset2 = ImageNet(root=imagenet_path,
split='val',
transform=transform_test)
trainset.num_class = testset1.num_class = testset2.num_class = 1000
trainset.targets = [lb for _, lb in trainset.samples]
else:
raise ValueError(dataset)
return trainset, testset1, testset2
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(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
def retrieve_image_tensor(image_path):
transform = Compose([Resize((256, 256)), Normalize(mean=[0.5], std=[0.5])])
pil_img = Image.open(image_path)
tensor_image = torchvision.transforms.ToTensor()(pil_img)
return transform(tensor_image)
def retrieve_inference_dataloader(dataframe, batch_size=4):
transform = Compose([Resize((256, 256)), Normalize(mean=[0.5], std=[0.5])])
dataset = MoleculesDatasetInference(dataframe, transform)
dataloader = DataLoader(dataset,
batch_size=batch_size,
num_workers=0,
pin_memory=True,
shuffle=False)
return dataloader
def __init__(self,
image_root,
image_name,
mean=[119.71304156, 119.71304156, 119.71304156],
std=[27.5233033, 27.5233033, 27.5233033]):
self.root = image_root
self.file = []
self.transform = Compose([ToTensor()])
#Normalize(mean,std)
for name in image_name:
img_file = os.path.join(self.root, name)
self.file.append({'img': img_file, 'name': name})
def __init__(self, image_dir):
super(DataSetFromFolderForPix2Pix, self).__init__()
self.photo_path = join(image_dir, "A")
self.sketch_path = join(image_dir, "B")
self.image_filenames = [
x for x in listdir(self.photo_path) if is_image_file(x)
]
transform_list = [
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
self.transform = Compose(transform_list)
def __init__(self, dataset_root="./dataset",
train_batch_size=8, val_batch_size=8, num_workers=0):
super().__init__()
self.dataset_root = dataset_root
self.train_batch_size = train_batch_size
self.val_batch_size = val_batch_size
self.num_workers = num_workers
self.transform = Compose([
ToTensor(),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
def get_labels_tf(args, labels, returns_categorical=False):
"""
Get the transformations to apply to the label(s) in order to convert them to real values.
If returns_categorical == True:
Returns a tuple (tf, is_categorical) where tf == [__callable__] and is_categorical is a bool indicating
if the label is categorical or not (assuming there is 1 label only)
else
Returns a a list tf where tf == [__callable__]
"""
if labels is None or (isinstance(labels, list) and len(labels)==0):
if returns_categorical:
return (None, None)
return None
if not isinstance(labels, list):
labels = [labels]
assert (not returns_categorical) or len(labels) == 1, "Only one label must be passed"
df = pd.concat([pd.read_csv(p, sep=',') for m in args.modalities for p in args.metadata_path[m]],
ignore_index=True, sort=False)
known_labels = {'age': [LabelMapping(), False],
'sex': [LabelMapping(), True],
'site': [
LabelMapping() if args.preproc == "vision" else\
LabelMapping(**{site: indice for (indice, site) in enumerate(sorted(set(df['site'])))}),
True],
'diagnosis': [LabelMapping() if args.preproc == "vision" else\
LabelMapping(**CONFIG['db'][args.db]["dx_labels_mapping"]), True],
'digit': [LabelMapping(), True],
'mnist_digit': [LabelMapping(), True],
'stl10_class': [LabelMapping(), True],
'participant_id': [Compose([lambda x: str(x), LabelMapping(**(get_json_obj(
os.path.join(ROOT_DATA, "unique_participant_id_mapping.json"))))]), True]
}
assert set(labels) <= set(known_labels.keys()), \
"Unknown label(s), chose from {}".format(set(known_labels.keys()))
if len(labels) == 1:
labels_transforms = [known_labels[labels[0]][0]]
else:
labels_transforms = [lambda in_labels: [known_labels[labels[i]][0](l) for i, l in enumerate(in_labels)]]
if returns_categorical:
is_categorical = known_labels[labels[0]][1]
return (labels_transforms, is_categorical)
return labels_transforms
def evaluate_on_imagenet(model: NFNet,
dataset_dir: Path,
batch_size=50,
device='cuda:0'):
transforms = Compose([
#Pad32CenterCrop(model.test_imsize),
ToTensor(),
Resize((model.test_imsize, model.test_imsize), PIL.Image.BICUBIC),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
print(f"Starting evaluation from {dataset_dir}")
dataset = get_dataset(dataset_dir, transforms=transforms)
dataloader = DataLoader(
dataset=dataset,
batch_size=batch_size, # F0: 120, F1: 100, F2: 80
shuffle=False,
pin_memory=False,
num_workers=8)
print(f"Validation set contains {len(dataset)} images.")
model.to(device)
model.eval()
processed_imgs = 0
correct_labels = 0
for step, data in enumerate(dataloader):
with torch.no_grad():
inputs = data[0].to(device)
targets = data[1].to(device)
output = model(inputs).type(torch.float32)
processed_imgs += targets.size(0)
_, predicted = torch.max(output, 1)
correct_labels += (predicted == targets).sum().item()
batch_padding = int(math.log10(len(dataloader.dataset)) + 1)
print(
f"\rProcessing {processed_imgs:{batch_padding}d}/{len(dataloader.dataset)}. Accuracy: {100.0*correct_labels/processed_imgs:6.4f}",
sep=' ',
end='',
flush=True)
print(
f"\nFinished eval. Accuracy: {100.0*correct_labels/processed_imgs:6.4f}"
)
def retrieve_evaluate_dataloader(dataframe, vocab: Vocabulary, batch_size=8, shuffle=False, sequence_length=None):
pad_idx = vocab.stoi['<PAD>']
transform = Compose([
Resize((256,256)),
Normalize(mean=[0.5], std=[0.5])
])
dataset = MoleculesDataset(dataframe, vocab, transform)
dataloader = DataLoader(
dataset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=0,
pin_memory=True,
collate_fn=CapsCollate(pad_idx=pad_idx,batch_first=True, sequence_length=sequence_length)
)
return dataloader
def retrieve_train_dataloader(dataframe, vocab: Vocabulary, batch_size=8, shuffle=True, sequence_length=None):
pad_idx = vocab.stoi['<PAD>']
transform = Compose([
# RandomVerticalFlip(),
# RandomHorizontalFlip(),
# RandomRotation(180),
Resize((256,256)),
Normalize(mean=[0.5], std=[0.5]),
])
dataset = MoleculesDataset(dataframe, vocab, transform)
dataloader = DataLoader(
dataset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=0,
pin_memory=True,
collate_fn=CapsCollate(pad_idx=pad_idx,batch_first=True, sequence_length=sequence_length)
)
return dataloader
def to_image(det):
size = 512
val_trans = [Normalization([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]
val_trans = Compose(val_trans)
for i in range(5, 200):
path = f"D:/temp_data/mask/test/{i}.jpg "
print(path)
image = cv2.imread(path)
image = cv2.resize(image, (size, size))
bboxes = det.predict(image.copy(), size, (0.2, 0.2))
for cid, bbox in bboxes[0].items():
cls = "mask" if cid == 1 else "face"
for b in bbox:
prob = b[-1]
b = b[:4].astype(int)
cv2.rectangle(image, (b[0], b[1]), (b[2], b[3]), colors[cid].tolist(), 1, cv2.LINE_AA)
cv2.putText(image, "{}:{}".format(cls, int(prob*100)), (b[0], b[1]), cv2.FONT_ITALIC, 1, colors[cid].tolist(), 2)
cv2.imshow("image", image)
cv2.waitKey()
from sklearn.decomposition import PCA
from sklearn.metrics import classification_report
duration = 2000
freq = 440
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
data_path = './COVID19_dataset'
metadata = './metadata.csv'
PATH = './'
model = resnet18(pretrained=True).to(device)
model.load_state_dict(
torch.load('./CBAM_model_pkls/CBAM(freezemore)_model_epoch_48.pkl'))
train_aug = Compose([Resize((224, 224)), ToTensor()])
val_aug = Compose([Resize((224, 224)), ToTensor()])
BS = 1
Train_features = []
Train_classes = []
Test_features = []
Test_classes = []
trainset = XRayDataSet(os.path.join(data_path, 'train'),
metadata,
transforms=train_aug)
testset = XRayDataSet(os.path.join(data_path, 'test'),
metadata,
transforms=val_aug)
trainloader = DataLoader(trainset, batch_size=BS, shuffle=True, num_workers=0)
testloader = DataLoader(testset, batch_size=BS, shuffle=True, num_workers=0)
import PIL
from PIL import Image
import torch
import torch.nn as nn
from torch.nn.utils.rnn import pad_sequence
from torchvision.transforms.transforms import Compose, Normalize, Resize, ToTensor, RandomHorizontalFlip, RandomCrop
# IO
transform = Compose([
#RandomHorizontalFlip(),
Resize((256,256), PIL.Image.BICUBIC),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def get_train_file_path(image_ids):
# print(image_id)
# return "../input/bms-molecular-translation/train/{}/{}/{}/{}.png".format(
# image_id[0], image_id[1], image_id[2], image_id
# )
return [
"./input/train/{}/{}/{}/{}.png".format(
image_id[0], image_id[1], image_id[2], image_id)
for image_id in image_ids
]
def get_test_file_path(image_ids):
return [
"./input/test/{}/{}/{}/{}.png".format(
"vbm": np.load(os.path.join(root, "mask_open-bhb_vbm.npy")),
"quasi_raw":
np.load(os.path.join(root, "mask_open-bhb_quasi_raw.npy"))
}
elif args.mask == "reduced":
m = nibabel.load(
"/neurospin/tmp/psy_sbox/all_studies/derivatives/arrays/mni_cerebrum-gm-mask_1.5mm.nii.gz"
)
m = (m.get_fdata() != 0)
masks = {"vbm": m, "quasi_raw": m}
area_masks = get_brain_area_masks(
(121, 145, 121),
brain_atlas[0],
brain_atlas[1],
transforms=(Compose([Crop(
(121, 128, 121)), Padding([128, 128, 128])]) if args.dl else None))
input_transforms = None
if args.dl:
input_transforms = Compose([
Crop((1, 121, 128, 121)),
Padding([1, 128, 128, 128], mode='constant'),
Normalize()
])
test = DataLoader(OpenBHB(root,
preproc=preproc,
scheme="train_val_test",
split="test",
target=pb,
transforms=input_transforms),
batch_size=16,
def train(config: dict) -> None:
if config['device'].startswith('cuda'):
if torch.cuda.is_available():
print(
f"Using CUDA{torch.version.cuda} with cuDNN{torch.backends.cudnn.version()}"
)
else:
raise ValueError(
"You specified to use cuda device, but cuda is not available.")
if config['pretrained'] is not None:
model = pretrained_nfnet(path=config['pretrained'],
stochdepth_rate=config['stochdepth_rate'],
alpha=config['alpha'],
activation=config['activation'])
else:
model = NFNet(num_classes=config['num_classes'],
variant=config['variant'],
stochdepth_rate=config['stochdepth_rate'],
alpha=config['alpha'],
se_ratio=config['se_ratio'],
activation=config['activation'])
transforms = Compose([
RandomHorizontalFlip(),
Resize((model.train_imsize, model.train_imsize), PIL.Image.BICUBIC),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
device = config['device']
dataset = get_dataset(path=config['dataset'], transforms=transforms)
if config['overfit']:
dataset = Subset(dataset, [i * 50 for i in range(0, 1000)])
dataloader = DataLoader(dataset=dataset,
batch_size=config['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
pin_memory=config['pin_memory'])
if config['scale_lr']:
learning_rate = config['learning_rate'] * config['batch_size'] / 256
else:
learning_rate = config['learning_rate']
if not config['do_clip']:
config['clipping'] = None
if config['use_fp16']:
model.half()
model.to(device) # "memory_format=torch.channels_last" TBD
optimizer = SGD_AGC(
# The optimizer needs all parameter names
# to filter them by hand later
named_params=model.named_parameters(),
lr=learning_rate,
momentum=config['momentum'],
clipping=config['clipping'],
weight_decay=config['weight_decay'],
nesterov=config['nesterov'])
# Find desired parameters and exclude them
# from weight decay and clipping
for group in optimizer.param_groups:
name = group['name']
if model.exclude_from_weight_decay(name):
group['weight_decay'] = 0
if model.exclude_from_clipping(name):
group['clipping'] = None
criterion = nn.CrossEntropyLoss()
runs_dir = Path('runs')
run_index = 0
while (runs_dir / ('run' + str(run_index))).exists():
run_index += 1
runs_dir = runs_dir / ('run' + str(run_index))
runs_dir.mkdir(exist_ok=False, parents=True)
checkpoints_dir = runs_dir / 'checkpoints'
checkpoints_dir.mkdir()
writer = SummaryWriter(str(runs_dir))
scaler = amp.GradScaler()
for epoch in range(config['epochs']):
model.train()
running_loss = 0.0
processed_imgs = 0
correct_labels = 0
epoch_time = time.time()
for step, data in enumerate(dataloader):
inputs = data[0].half().to(
device) if config['use_fp16'] else data[0].to(device)
targets = data[1].to(device)
optimizer.zero_grad()
with amp.autocast(enabled=config['amp']):
output = model(inputs)
loss = criterion(output, targets)
# Gradient scaling
# https://www.youtube.com/watch?v=OqCrNkjN_PM
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
running_loss += loss.item()
processed_imgs += targets.size(0)
_, predicted = torch.max(output, 1)
correct_labels += (predicted == targets).sum().item()
epoch_padding = int(math.log10(config['epochs']) + 1)
batch_padding = int(math.log10(len(dataloader.dataset)) + 1)
print(
f"\rEpoch {epoch+1:0{epoch_padding}d}/{config['epochs']}"
f"\tImg {processed_imgs:{batch_padding}d}/{len(dataloader.dataset)}"
f"\tLoss {running_loss / (step+1):6.4f}"
f"\tAcc {100.0*correct_labels/processed_imgs:5.3f}%\t",
sep=' ',
end='',
flush=True)
elapsed = time.time() - epoch_time
print(
f"({elapsed:.3f}s, {elapsed/len(dataloader):.3}s/step, {elapsed/len(dataset):.3}s/img)"
)
global_step = epoch * len(dataloader) + step
writer.add_scalar('training/loss', running_loss / (step + 1),
global_step)
writer.add_scalar('training/accuracy',
100.0 * correct_labels / processed_imgs, global_step)
#if not config['overfit']:
if epoch % 10 == 0 and epoch != 0:
cp_path = checkpoints_dir / ("checkpoint_epoch" + str(epoch + 1) +
".pth")
torch.save(
{
'epoch': epoch,
'model': model.state_dict(),
'optim': optimizer.state_dict(),
'loss': loss
}, str(cp_path))
print(f"Saved checkpoint to {str(cp_path)}")
# Read csv (video_name, label)
df = pd.read_json(args.json_file, orient='records')
total_videos = int(df['video_name'].count())
# Add video index column (to be utilized by json)
df['video_idx'] = range(total_videos)
# Compute the sequence length (no. of frames) for each video (row)
df['video_length'] = df['video_name'].apply(lambda x: _count_frames(x, args.frames_dir))
# Image Mean & Std-Dev for Normalization
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
dataset = VideoFramesDataset(args.frames_dir, df, Compose([Resize((224, 224)), ToTensor(), Normalize(mean, std)]))
# dataset = VideoFramesDataset(args.frames_dir, df, Compose([Resize((224, 224)), ToTensor()])) # for sanity check
# Compute the max sequence length, needed for embedding array - [N, F, D]
max_video_len = compute_max_frames_len(args.frames_dir)
total_frames = dataset.__len__()
print('Total Videos: {} | Total Frames: {} | Max Video length: {}'.
format(total_videos, total_frames, max_video_len))
dataloader = DataLoader(dataset, args.batch_size, num_workers=args.num_workers)
# Load model
model, emb_dim = load_cnn(args.model)
model.to(device)
# print("caption_vec SOS: ", (e-s))
# s = time()
caption_vec += self.vocab.numericalize(row["InChI"])
# e = time()
# print("caption_vec InChI: ", (e-s))
# s = time()
caption_vec += [self.vocab.stoi["<EOS>"]]
# e = time()
# print("caption_vec EOS: ", (e-s))
return (self.transform(tensorImage), torch.as_tensor(caption_vec))
transform = Compose([
#RandomHorizontalFlip(),
Resize((256, 256)),
#ToTensor(),
Normalize(mean=[0.5], std=[0.5]),
])
dataset = MoleculesDataset("data.csv", transform)
pad_idx = dataset.vocab.stoi["<PAD>"]
class CapsCollate:
"""
Collate to apply the padding to the captions with dataloader
"""
def __init__(self, pad_idx, batch_first=False):
self.pad_idx = pad_idx
self.batch_first = batch_first
from utils.load_data import XRayDataSet
from torch.utils.data import DataLoader
from collections.abc import Iterable
from torchvision import datasets, models, transforms
from torchvision.transforms.transforms import Compose, Resize, RandomRotation, RandomHorizontalFlip, RandomVerticalFlip, ToTensor
from tensorboardX import SummaryWriter
data_path = './COVID19_dataset'
metadata = './metadata.csv'
PATH = 'X:/covid19/CBAM_model_pkls'
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)
train_aug = Compose([Resize((224, 224)),
RandomRotation(180),
RandomHorizontalFlip(),
RandomVerticalFlip(),
ToTensor()
])
val_aug = Compose([Resize((224, 224)),
ToTensor()
])
BS = 24
pre_epoch = 0
EPOCH = 50
writer = SummaryWriter(comment = 'Linear')
trainset = XRayDataSet(os.path.join(data_path, 'train'), metadata, transforms = train_aug)
testset = XRayDataSet(os.path.join(data_path, 'test'), metadata, transforms = val_aug)
trainloader = DataLoader(trainset, batch_size = BS, shuffle = True, num_workers = 0)
model.load_state_dict(state_dict)
# backbone
features = list([model.conv1, model.conv2, model.conv3, model.conv4, ])
classifier = list([model.conv5, model.ave_pool])
features = nn.Sequential(*features)
classifier = nn.Sequential(*classifier)
return features, classifier
if __name__ == "__main__":
"""train a model with CIFAR10"""
train_transform = Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616))])
test_transform = Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616))])
classes = ['plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
# # train process
# cifar10_data = CIFAR10(root='../data/samples/cifar10', train=True, download=True, transform=train_transform)
# data_loader = torch.utils.data.DataLoader(cifar10_data,
# batch_size=128,
# shuffle=True)
losses = []
accuracies = []
n_epochs = 100
learning_rate = 0.1
lr_decay = 5 # every 10 epochs, the learning rate is divided by 10
batch_size = 4
use_cuda = False # use True to switch to GPU
mydata = load_dataset()
device = torch.device("cuda" if use_cuda else "cpu")
model = GymnModel().to(device)
print('The model has {0} parameters'.format(
sum([len(i.reshape(-1)) for i in model.parameters()])))
data_transformers = Compose([ToTensor()])
train_loader, test_loader = getDataLoaders(mydata,
batch_size,
data_transformers,
test_ratio=0.1)
print('Number of train examples: {0}, number of test examles: {1}'.format(
len(train_loader.dataset), len(test_loader.dataset)))
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
lr_scheduler = StepLR(optimizer, step_size=1, gamma=0.96)
best_acc = 0
for epoch in range(1, n_epochs + 1):
tic = time.time()
epoch_loss = train(model, device, train_loader, optimizer, epoch)
print('Training loss for epoch {0} is {1:.5f}. LR={2}'.format(
def build_data_manager(args, **kwargs):
labels = args.labels or []
add_to_input = None
data_augmentation = BaseTrainer.get_data_augmentations(args.da, mode=args.preproc)
self_supervision = args.self_supervision
input_transforms = kwargs.get('input_transforms')
output_transforms = None
patch_size = None
input_size = None
projection_labels = None
if args.preproc != "vision":
projection_labels = {
'diagnosis': ['control', 'FEP', 'schizophrenia', 'bipolar disorder', 'psychotic bipolar disorder',
'AD', 'MCI']
}
# Set the preprocessing step with an exception for GAN and Genesis Model
if input_transforms is None:
input_transforms = BaseTrainer.get_input_transforms(args)
# Gets a specific BHB/OpenBHB DataManager for this dataset
if args.db in ["open_bhb", "bhb"]:
scheme = "cv" if args.cv else "train_val_test"
preproc = "vbm" if args.preproc == "cat12" else "quasi_raw"
mask = np.load(os.path.join(ROOT_DATA, "mask_open-bhb_%s.npy"%preproc))
_manager_cls = OpenBHBDataManager if args.db == "open_bhb" else BHBDataManager
manager = _manager_cls(ROOT_DATA, preproc,
scheme=scheme, labels=labels,
sampler=args.sampler,
batch_size=args.batch_size,
input_transforms=Compose(input_transforms),
residualize=args.residualize,
mask=mask,
number_of_folds=args.nb_folds,
N_train_max=args.N_train_max,
device=('cuda' if args.cuda else 'cpu'),
num_workers=args.num_cpu_workers,
pin_memory=args.pin_mem,
drop_last=args.drop_last)
return manager
# Set the basic mapping between a label and an integer
labels_transforms = BaseTrainer.get_labels_tf(args, labels)
(strat_label_transforms, is_categorical) = BaseTrainer.get_labels_tf(args, args.stratify_label,
returns_categorical=True)
# Get the right Dataset class according to the modalities and model
dataset_cls = BaseTrainer.get_dataset(args)
# Selects only given modalities
if isinstance(args.metadata_path, dict):
args.metadata_path = {m: args.metadata_path[m]
for m in (set(args.modalities) & set(args.metadata_path.keys()))}
if isinstance(args.input_path, dict):
args.input_path = {m: args.input_path[m]
for m in (set(args.modalities) & set(args.input_path.keys()))}
# Get intersection of unique keys for vision datasets
unique_df_keys = UNIQUE_DF_KEY[args.preproc]
keys_to_keep = KEYS_TO_KEEP[args.preproc]
if args.preproc == "vision":
assert set(args.modalities) <= (set(unique_df_keys.keys()) & set(keys_to_keep.keys()))
unique_keys = None
for mod in args.modalities:
if unique_keys is None:
unique_keys = set(unique_df_keys[mod])
unique_keys &= set(unique_df_keys[mod])
unique_df_keys = list(unique_keys)
logger.info("Unique keys for multi-modality merging: {}".format(unique_df_keys))
stratif = CONFIG['db'][args.db]
manager = DataManager(copy.deepcopy(args.input_path), copy.deepcopy(args.metadata_path),
mmap_mode=args.mmap_mode,
batch_size=args.batch_size,
number_of_folds=args.nb_folds,
add_to_input=add_to_input,
add_input=args.add_input,
labels=labels or None,
sampler=args.sampler,
projection_labels=projection_labels,
custom_stratification=stratif,
categorical_strat_label=is_categorical,
stratify_label=args.stratify_label,
N_train_max=args.N_train_max,
input_transforms=input_transforms,
stratify_label_transforms=strat_label_transforms,
labels_transforms=labels_transforms,
data_augmentation=data_augmentation,
self_supervision=self_supervision,
output_transforms=output_transforms,
patch_size=patch_size,
input_size=input_size,
pin_memory=args.pin_mem,
drop_last=args.drop_last,
dataset=dataset_cls,
unique_df_keys=unique_df_keys,
keys_to_keep=keys_to_keep,
no_missing_mod=args.no_missing_mod,
device=('cuda' if args.cuda else 'cpu'),
num_workers=args.num_cpu_workers)
return manager
def get_transform(self):
tfms = []
tfms.append(ToTensor())
return Compose(tfms)
EndlessCLSimDataset,
)
from pathlib import Path
from typing import List, Union, Optional, Any
from torchvision.transforms import ToTensor
from torchvision.transforms.transforms import Compose
from avalanche.benchmarks.classic.classic_benchmarks_utils import (
check_vision_benchmark,
)
from avalanche.benchmarks.datasets import default_dataset_location
from avalanche.benchmarks.generators import dataset_benchmark
from avalanche.benchmarks.utils import AvalancheDataset
_default_transform = Compose([ToTensor()])
_scenario_names = ["Classes", "Illumination", "Weather"]
def EndlessCLSim(
*,
scenario: str = _scenario_names[0],
patch_size: int = 64,
sequence_order: Optional[List[int]] = None,
task_order: Optional[List[int]] = None,
train_transform: Optional[Any] = _default_transform,
eval_transform: Optional[Any] = _default_transform,
dataset_root: Union[str, Path] = None,
semseg=False
):
def randaugment(self, n, m):
sampled_ops = np.random.choice(RAND_AUGMENT_NAMES, n)
return [(op, m) for op in sampled_ops]
def step_magnitude_controller(self, value):
self.magnitude_controller = value
if __name__ == '__main__':
pc = AugmentPolicyTransform([[('Solarize', 0.66, 0.34),
('Equalize', 0.56, 0.61)],
[('Equalize', 0.43, 0.06),
('AutoContrast', 0.66, 0.08)],
[('Color', 0.72, 0.47),
('Contrast', 0.88, 0.86)],
[('Brightness', 0.84, 0.71),
('Color', 0.31, 0.74)],
[('Rotate', 0.68, 0.26),
('TranslateX', 0.38, 0.88)]])
cp = Compose([
pc,
Normalize((0, 0, 0), (0, 0, 0)),
])
inp = (np.random.rand(4, 4, 3) * 255).astype(np.uint8)
for i in range(10):
print(np.asarray(pc(inp)))
print(cp(inp))
def get_transforms():
# transform = Compose([random_rotation, ToPILImage(), RandomCrop(46), Resize((48,48)),
# RandomHorizontalFlip(0.5), ToTensor()])
transform = Compose([ToPILImage(), RandomHorizontalFlip(0.5), ToTensor()])
return transform
def get_transform(self):
tfms = []
tfms.append(ToTensor())
#tfms.append(Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]))
return Compose(tfms)
