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)