from torchvision import transforms from PIL import Image IMG_SIZE = 1024 preprocess = transforms.Compose([ transforms.Scale(IMG_SIZE, interpolation=Image.ANTIALIAS), transforms.CenterCrop(IMG_SIZE), transforms.ToTensor() ])
from torchvision.datasets import ImageFolder import csv import os import re import numpy as np import pandas as pd from os import getcwd from os.path import join from PIL import Image import torch.utils.data as data from torchvision import transforms transform = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor() ]) class MuraDataset(data.Dataset): _patient_re = re.compile(r'patient(\d+)') _study_re = re.compile(r'study(\d+)') _image_re = re.compile(r'image(\d+)') _study_type_re = re.compile(r'XR_(\w+)') def __init__(self, csv_f, transform=transform, download=False): self.df = pd.read_csv(csv_f, names=['img', 'label'], header=None) self.imgs = self.df.img.values.tolist() self.labels = self.df.label.values.tolist() # following datasets/folder.py's weird convention here... self.samples = [tuple(x) for x in self.df.values]
import torchvision import torchvision.transforms as transforms import matplotlib.pyplot as plt EPOCH = 15 #数据集训练几遍 BATCH_SIZE = 50 #一批数据的个数 LR = 0.001 #加载数据集 path1 = "../dataSet/train" #归一化,使颜色值从0-255变为0-1之间 train_data = torchvision.datasets.ImageFolder( path1, transform=transforms.Compose([ transforms.Resize((100, 100)), transforms.CenterCrop(100), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) #生成训练器 train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) #加载测试集 path2 = "../dataSet/test" test_data = torchvision.datasets.ImageFolder( path2,
def main_worker(gpu, ngpus_per_node, args): progress = ProgressMeter(args) info = '' for arg in vars(args): info += arg+': '+str(getattr(args, arg))+'\n' progress.write(info) global best_acc1 args.gpu = gpu # suppress printing if not master if args.multiprocessing_distributed and args.gpu != 0: def print_pass(*args): pass builtins.print = print_pass if args.gpu is not None: progress.write("Use GPU: {} for training".format(args.gpu)) if args.distributed: if args.dist_url == "env://" and args.rank == -1: args.rank = int(os.environ["RANK"]) if args.multiprocessing_distributed: # For multiprocessing distributed training, rank needs to be the # global rank among all the processes args.rank = args.rank * ngpus_per_node + gpu dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size, rank=args.rank) # create model progress.write("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch]() # freeze all layers but the last fc #for name, param in model.named_parameters(): # if name not in ['fc.weight', 'fc.bias']: # param.requires_grad = False # init the fc layer model.fc.weight.data.normal_(mean=0.0, std=0.01) model.fc.bias.data.zero_() if args.syncbn: model = apex.parallel.convert_syncbn_model(model) # load from pre-trained, before DistributedDataParallel constructor if args.pretrained: if os.path.isfile(args.pretrained): progress.write("=> loading checkpoint '{}'".format(args.pretrained)) checkpoint = torch.load(args.pretrained, map_location="cpu") # rename pre-trained keys state_dict = checkpoint['state_dict'] for k in list(state_dict.keys()): # retain only encoder_q up to before the embedding layer if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'): # remove prefix state_dict[k[len("module.encoder_q."):]] = state_dict[k] elif k.startswith('module.encoder') and not k.startswith('module.encoder.fc'): # remove prefix state_dict[k[len("module.encoder."):]] = state_dict[k] # delete renamed or unused k del state_dict[k] args.start_epoch = 0 msg = model.load_state_dict(state_dict, strict=False) print(msg) assert set(msg.missing_keys) == {"fc.weight", "fc.bias"} progress.write("=> loaded pre-trained model '{}'".format(args.pretrained)) else: progress.write("=> no checkpoint found at '{}'".format(args.pretrained)) assert False if args.distributed: # For multiprocessing distributed, DistributedDataParallel constructor # should always set the single device scope, otherwise, # DistributedDataParallel will use all available devices. if args.gpu is not None: torch.cuda.set_device(args.gpu) model.cuda(args.gpu) # When using a single GPU per process and per # DistributedDataParallel, we need to divide the batch size # ourselves based on the total number of GPUs we have args.batch_size = int(args.batch_size / ngpus_per_node) args.workers = int((args.workers + ngpus_per_node - 1) / ngpus_per_node) model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu]) else: model.cuda() # DistributedDataParallel will divide and allocate batch_size to all # available GPUs if device_ids are not set model = torch.nn.parallel.DistributedDataParallel(model) elif args.gpu is not None: torch.cuda.set_device(args.gpu) model = model.cuda(args.gpu) else: # DataParallel will divide and allocate batch_size to all available GPUs if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda(args.gpu) # optimize only the linear classifier parameters = list(filter(lambda p: p.requires_grad, model.parameters())) #assert len(parameters) == 2 # fc.weight, fc.bias # for semi: set diff lr for fc and backbone trunk_parameters = [] head_parameters = [] for name, param in model.named_parameters(): if 'fc' in name: head_parameters.append(param) else: trunk_parameters.append(param) optimizer = torch.optim.SGD( [{'params': trunk_parameters}, {'params': head_parameters, 'lr': args.lr_last_layer}], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, ) # optimizer = torch.optim.SGD(parameters, args.lr, # momentum=args.momentum, # weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): progress.write("=> loading checkpoint '{}'".format(args.resume)) if args.gpu is None: checkpoint = torch.load(args.resume) else: # Map model to be loaded to specified single gpu. loc = 'cuda:{}'.format(args.gpu) checkpoint = torch.load(args.resume, map_location=loc) args.start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] if args.gpu is not None: # best_acc1 may be from a checkpoint from a different GPU best_acc1 = best_acc1.to(args.gpu) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) progress.write("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: progess.write("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code traindir = os.path.join(args.data, 'train') valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) #subset_file = urllib.request.urlopen("https://raw.githubusercontent.com/google-research/simclr/master/imagenet_subsets/" + str(args.labels_perc) + "percent.txt") #list_imgs = [li.decode("utf-8").split('\n')[0] for li in subset_file] subset_file = open('imagenet_subset/'+args.labels_perc+'percent.txt', 'r') list_imgs = [li.split('\n')[0] for li in subset_file] train_dataset.samples = [( os.path.join(traindir, li.split('_')[0], li), train_dataset.class_to_idx[li.split('_')[0]] ) for li in list_imgs] if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler, drop_last=True) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, args) return st_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) adjust_learning_rate(optimizer, epoch, args) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on validation set if (epoch+1) % 2 == 0: acc1 = validate(val_loader, model, criterion, args) # remember best acc@1 and save checkpoint is_best = acc1 > best_acc1 best_acc1 = max(acc1, best_acc1) if not args.multiprocessing_distributed or (args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): save_checkpoint(args, { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer' : optimizer.state_dict(), }, is_best) #if epoch == args.start_epoch: # sanity_check(args, model.state_dict(), args.pretrained) progress.write('Best: '+str(best_acc1)) info = 'Time: ' + format_time(time.time()-st_time) + '\n'\ 'Eta: ' + format_time((time.time()-st_time)/(epoch+1)*(args.epochs-epoch-1)) progress.write(info)
from torchvision import transforms, datasets import torchvision from torchvision.utils import save_image, make_grid from PIL import Image import os from modules import VectorQuantizedVAE, to_scalar from vqvae import generate_samples DEVICE = "cuda:1" data_folder = "/shared/kgcoe-research/mil/ImageNet/" #data_folder = "./data/face/" im_transform = transforms.Compose([ \ transforms.CenterCrop(128), \ transforms.ToTensor()]) #test_dataset = datasets.ImageFolder(root=data_folder, transform=im_transform) test_dataset = datasets.ImageFolder(root=os.path.join(data_folder, "val"), transform=im_transform) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=8, shuffle=False) def get_recons(loader, hidden_size=256): model = VectorQuantizedVAE(3, hidden_size, 512).to(DEVICE)
def main(checkpoint=None): global epoch # Data augmentation and normalization for training # Just normalization for validation data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } data_dir = 'data' image_datasets = { x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'val'] } dataloaders = { x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=0) for x in ['train', 'val'] } dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} class_names = image_datasets['train'].classes model_ft = models.resnet18(pretrained=True) num_ftrs = model_ft.fc.in_features # Here the size of each output sample is set to 2. # Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)). model_ft.fc = nn.Linear(num_ftrs, 2) if checkpoint is None: model_ft = model_ft.to(device) criterion = nn.CrossEntropyLoss() # Observe that all parameters are being optimized optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) # Decay LR by a factor of 0.1 every 7 epochs exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) else: model_state_dict, criterion, optimizer_ft, exp_lr_scheduler, epoch = utils.load_model( checkpoint) model_ft.load_state_dict(model_state_dict) model_ft = model_ft.to(device) try: model_ft = train_model(dataloaders, dataset_sizes, model_ft, criterion, optimizer_ft, exp_lr_scheduler, start_epoch=epoch, end_epoch=10) saveToBento = input("Save model to Bento ML (yes/no): ") if saveToBento.lower() == "yes": # Add it to BentoML bento_svc = AntOrBeeClassifier() bento_svc.pack('model', model_ft) # Save your Bento Service saved_path = bento_svc.save() print('Bento Service saved in ', saved_path) #Copy Bento Service to git dir git_dir = "/home/project/AntOrBeeClassifier/my-a-or-b/" cmd = 'cp -r ' + saved_path + '/. ' + git_dir os.system(cmd) except KeyboardInterrupt: pass finally: utils.save_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler, epoch)
def build_imagenet(model_state_dict, optimizer_state_dict, **kwargs): valid_ratio = kwargs.pop('valid_ratio', None) valid_num = kwargs.pop('valid_num', None) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1), transforms.ToTensor(), normalize, ]) valid_transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ]) if args.zip_file: logging.info('Loading data from zip file') traindir = os.path.join(args.data, 'train.zip') if args.lazy_load: data = utils.ZipDataset(traindir) else: logging.info('Loading data into memory') data = utils.InMemoryZipDataset(traindir, num_workers=args.num_workers) else: logging.info('Loading data from directory') traindir = os.path.join(args.data, 'train') if args.lazy_load: data = dset.ImageFolder(traindir) else: logging.info('Loading data into memory') data = utils.InMemoryDataset(traindir, num_workers=args.num_workers) num_data = len(data) indices = list(range(num_data)) np.random.shuffle(indices) if valid_ratio is not None: split = int(np.floor(1 - valid_ratio * num_data)) train_indices = sorted(indices[:split]) valid_indices = sorted(indices[split:]) else: assert valid_num is not None train_indices = sorted(indices[valid_num:]) valid_indices = sorted(indices[:valid_num]) train_data = utils.WrappedDataset(data, train_indices, train_transform) valid_data = utils.WrappedDataset(data, valid_indices, valid_transform) logging.info('train set = %d', len(train_data)) logging.info('valid set = %d', len(valid_data)) train_queue = torch.utils.data.DataLoader( train_data, batch_size=args.batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler(train_indices), pin_memory=True, num_workers=args.num_workers, drop_last=False) valid_queue = torch.utils.data.DataLoader( valid_data, batch_size=args.eval_batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler(valid_indices), pin_memory=True, num_workers=args.num_workers, drop_last=False) model = NASNet(args.width_stages, args.n_cell_stages, args.stride_stages, args.dropout) model.init_model(args.model_init) model.set_bn_param(0.1, 0.001) logging.info("param size = %d", utils.count_parameters(model)) if model_state_dict is not None: model.load_state_dict(model_state_dict) if torch.cuda.device_count() > 1: logging.info("Use %d %s", torch.cuda.device_count(), "GPUs !") model = nn.DataParallel(model) model = model.cuda() if args.no_decay_keys: keys = args.no_decay_keys.split('#') net_params = [ model.module.get_parameters(keys, mode='exclude'), model.module.get_parameters(keys, mode='include') ] optimizer = torch.optim.SGD( [ { 'params': net_params[0], 'weight_decay': args.weight_decay }, { 'params': net_params[1], 'weight_decay': 0 }, ], args.lr, momentum=0.9, nesterov=True, ) else: optimizer = torch.optim.SGD( model.parameters(), args.lr, momentum=0.9, weight_decay=args.weight_decay, nesterov=True, ) if optimizer_state_dict is not None: optimizer.load_state_dict(optimizer_state_dict) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, args.decay_period, gamma=args.gamma) train_criterion = utils.CrossEntropyLabelSmooth(1000, args.label_smooth).cuda() eval_criterion = nn.CrossEntropyLoss().cuda() return train_queue, valid_queue, model, train_criterion, eval_criterion, optimizer, scheduler
def main(): # ------------ # args # ------------ torch.manual_seed(0) pl.seed_everything(0) parser = argparse.ArgumentParser() parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point') parser.add_argument('--batch-size', type=int, dest='batch_size', default=50, help='mini batch size for training') parser.add_argument('--epoch', type=int, dest='epoch', default=10, help='epoch size for training') parser.add_argument('--learning-rate', type=float, dest='learning_rate', default=0.001, help='learning rate') parser.add_argument('--momentum', type=float, dest='momentum', default=0.9, help='momentum') parser.add_argument('--model-name', type=str, dest='model_name', default='resnet', help='Fine Turning model name') parser.add_argument('--optimizer', type=str, dest='optimizer', default='SGD', help='Optimzers to use for training.') parser.add_argument('--criterion', type=str, dest='criterion', default='cross_entropy', help='Loss Function to use for training.') parser.add_argument('--feature_extract', type=bool, dest='feature_extract', default=True, help='Flag for feature extracting. When False, we finetune the whole model, when True we only update the reshaped layer params') args = parser.parse_args() args.num_workers=8 data_folder = args.data_folder print('training dataset is stored here:', data_folder) input_size = 224 if args.model_name == "inception": input_size = 299 # --------------------------- # Azure Machnie Learning # 1) get Azure ML run context and log hyperparameters # --------------------------- run = Run.get_context() run.log('model_name', args.model_name) run.log('optimizer', args.optimizer) run.log('criterion', args.criterion) run.log('lr', np.float(args.learning_rate)) run.log('momentum', np.float(args.momentum)) # For your tagging # run.tag('description', 'xxx') # ------------ # data # ------------ transform = transforms.Compose([ # Augmentation # transforms.RandomHorizontalFlip(), # transforms.RandomVerticalFlip(), transforms.RandomAffine(degrees=[-10, 10], translate=(0.1, 0.1), scale=(0.5, 1.5)), transforms.RandomRotation(degrees=10), # Resize transforms.Resize(int(input_size * 1.3)), transforms.CenterCrop(input_size), # Tensor transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]) ] ) dataset = torchvision.datasets.ImageFolder(args.data_folder, transform) args.num_classes = len(dataset.classes) n_train = int(len(dataset) * 0.7) n_val = int(len(dataset) * 0.15) n_test = len(dataset) - n_train - n_val train_dataset, val_dataset, test_dataset = torch.utils.data.random_split(dataset, [n_train, n_val, n_test]) train_loader = torch.utils.data.DataLoader(train_dataset, args.batch_size, shuffle=True, drop_last=True, num_workers=args.num_workers) val_loader = torch.utils.data.DataLoader(val_dataset, args.batch_size, num_workers=args.num_workers) test_loader = torch.utils.data.DataLoader(test_dataset, args.batch_size) # Initialize the model for this run model_ft, input_size = initialize_model(args.model_name, args.num_classes, feature_extract=args.feature_extract , use_pretrained=True) model = FineTurningModel(args, model_ft) # GPU Configuration num_gpu = torch.cuda.device_count() print('num_gpu:', num_gpu) accelerator = None if num_gpu > 1: accelerator='ddp' # only for Single Machine # ------------ # training # ------------ trainer = pl.Trainer(max_epochs=args.epoch, gpus=num_gpu, accelerator=accelerator) trainer.fit(model, train_loader, val_loader) # ------------ # Test (Not Validation) # ------------ test_result = trainer.test(test_dataloaders=test_loader) test_result run.log('test_acc', [res["test_acc"] for res in test_result][0]) run.log('test_loss', [res["test_loss"] for res in test_result][0]) run.log('test_acc_epoch', [res["test_acc_epoch"] for res in test_result][0]) run.log('test_loss_epoch', [res["test_loss_epoch"] for res in test_result][0]) # ------------ # save model # ------------ outputdir = './outputs/model' os.makedirs(outputdir, exist_ok=True) torch.save(model.state_dict(), os.path.join(outputdir, 'model.dict')) torch.save(model, os.path.join(outputdir, 'model.pt'))
def train_imagenet(): print('==> Preparing data..') img_dim = get_model_property('img_dim') if FLAGS.fake_data: train_dataset_len = 1200000 # Roughly the size of Imagenet dataset. train_loader = xu.SampleGenerator( data=(torch.zeros(FLAGS.batch_size, 3, img_dim, img_dim), torch.zeros(FLAGS.batch_size, dtype=torch.int64)), sample_count=train_dataset_len // FLAGS.batch_size // xm.xrt_world_size()) test_loader = xu.SampleGenerator( data=(torch.zeros(FLAGS.test_set_batch_size, 3, img_dim, img_dim), torch.zeros(FLAGS.test_set_batch_size, dtype=torch.int64)), sample_count=50000 // FLAGS.batch_size // xm.xrt_world_size()) else: normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = torchvision.datasets.ImageFolder( os.path.join(FLAGS.datadir, 'train'), transforms.Compose([ transforms.RandomResizedCrop(img_dim), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) train_dataset_len = len(train_dataset.imgs) resize_dim = max(img_dim, 256) test_dataset = torchvision.datasets.ImageFolder( os.path.join(FLAGS.datadir, 'val'), # Matches Torchvision's eval transforms except Torchvision uses size # 256 resize for all models both here and in the train loader. Their # version crashes during training on 299x299 images, e.g. inception. transforms.Compose([ transforms.Resize(resize_dim), transforms.CenterCrop(img_dim), transforms.ToTensor(), normalize, ])) train_sampler = None test_sampler = None if xm.xrt_world_size() > 1: train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset, num_replicas=xm.xrt_world_size(), rank=xm.get_ordinal(), shuffle=True) test_sampler = torch.utils.data.distributed.DistributedSampler( test_dataset, num_replicas=xm.xrt_world_size(), rank=xm.get_ordinal(), shuffle=False) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=FLAGS.batch_size, sampler=train_sampler, drop_last=FLAGS.drop_last, shuffle=False if train_sampler else True, num_workers=FLAGS.num_workers) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=FLAGS.test_set_batch_size, sampler=test_sampler, drop_last=FLAGS.drop_last, shuffle=False, num_workers=FLAGS.num_workers) torch.manual_seed(42) devices = (xm.get_xla_supported_devices( max_devices=FLAGS.num_cores) if FLAGS.num_cores != 0 else []) # Pass [] as device_ids to run using the PyTorch/CPU engine. torchvision_model = get_model_property('model_fn') model_parallel = dp.DataParallel(torchvision_model, device_ids=devices) def train_loop_fn(model, loader, device, context): loss_fn = nn.CrossEntropyLoss() optimizer = context.getattr_or( 'optimizer', lambda: optim.SGD(model.parameters(), lr=FLAGS.lr, momentum=FLAGS.momentum, weight_decay=1e-4)) lr_scheduler = context.getattr_or( 'lr_scheduler', lambda: schedulers.wrap_optimizer_with_scheduler( optimizer, scheduler_type=getattr(FLAGS, 'lr_scheduler_type', None), scheduler_divisor=getattr(FLAGS, 'lr_scheduler_divisor', None), scheduler_divide_every_n_epochs=getattr( FLAGS, 'lr_scheduler_divide_every_n_epochs', None), num_steps_per_epoch=num_training_steps_per_epoch, summary_writer=writer if xm.is_master_ordinal() else None)) tracker = xm.RateTracker() model.train() for x, (data, target) in enumerate(loader): optimizer.zero_grad() output = model(data) loss = loss_fn(output, target) loss.backward() xm.optimizer_step(optimizer) tracker.add(FLAGS.batch_size) if x % FLAGS.log_steps == 0: test_utils.print_training_update(device, x, loss.item(), tracker.rate(), tracker.global_rate()) if lr_scheduler: lr_scheduler.step() def test_loop_fn(model, loader, device, context): total_samples = 0 correct = 0 model.eval() for data, target in loader: output = model(data) pred = output.max(1, keepdim=True)[1] correct += pred.eq(target.view_as(pred)).sum().item() total_samples += data.size()[0] accuracy = 100.0 * correct / total_samples test_utils.print_test_update(device, accuracy) return accuracy accuracy = 0.0 writer = test_utils.get_summary_writer(FLAGS.logdir) num_devices = len( xm.xla_replication_devices(devices)) if len(devices) > 1 else 1 num_training_steps_per_epoch = train_dataset_len // (FLAGS.batch_size * num_devices) for epoch in range(1, FLAGS.num_epochs + 1): model_parallel(train_loop_fn, train_loader) accuracies = model_parallel(test_loop_fn, test_loader) accuracy = mean(accuracies) print('Epoch: {}, Mean Accuracy: {:.2f}%'.format(epoch, accuracy)) global_step = (epoch - 1) * num_training_steps_per_epoch test_utils.add_scalar_to_summary(writer, 'Accuracy/test', accuracy, global_step) if FLAGS.metrics_debug: print(met.metrics_report()) test_utils.close_summary_writer(writer) return accuracy
"WARNING: You have a CUDA device, so you should probably run with --cuda" ) if opt.dataset in ['folder']: # folder dataset data_path = '/work/04381/ymarathe/maverick/yearbook/keras_yearbook_less/train' for gender in os.listdir(data_path): datapath = data_path + "/" + gender for year in os.listdir(datapath): buffer = Buffer(25600, 32, 64, 64, 1) dataset = dset.ImageFolder( root=datapath + "/" + year, transform=transforms.Compose([ transforms.Scale(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) assert dataset dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize, shuffle=True, num_workers=int( opt.workers)) ngpu = int(opt.ngpu) nz = int(opt.nz) ngf = int(opt.ngf) ndf = int(opt.ndf)
# Parse arguments & log args = parse_args() logger.update_args(args) # Create output directory if not os.path.exists(args.output_dir): os.mkdir(args.output_dir) os.mkdir(args.output_dir + '/train/') os.mkdir(args.output_dir + '/valid/') else: print('WARNING: Output directory already exists and will be overwriting (if not resuming)') # Create transforms default_transform = transforms.Compose([ transforms.CenterCrop(args.image_size), transforms.Resize(args.image_size), transforms.ToTensor() ]) # Create train dataset train_dataset = dset.ImageFolder(root=args.train_dir, transform=default_transform) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True, drop_last=True) # Create validation dataset valid_dataset = dset.ImageFolder(root=args.valid_dir, transform=default_transform) valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=args.batch_size,
net = ptcv_get_model(model_name, pretrained=True) error, checksum, repo_release_tag, caption, paper, ds, img_size, scale, batch, rem = model_metainfo if (ds != "in1k") or (img_size == 0): continue paper_model_name = caption paper_arxiv_id = paper input_image_size = img_size resize_inv_factor = scale batch_size = batch model_description = "pytorch" + (rem if rem == "" else ", " + rem) assert (not hasattr(net, "in_size")) or (input_image_size == net.in_size[0]) ImageNet.benchmark( model=net, model_description=model_description, paper_model_name=paper_model_name, paper_arxiv_id=paper_arxiv_id, input_transform=transforms.Compose([ transforms.Resize( int(math.ceil(float(input_image_size) / resize_inv_factor))), transforms.CenterCrop(input_image_size), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]), batch_size=batch_size, num_gpu=1, # data_root=os.path.join("..", "imgclsmob_data", "imagenet") ) torch.cuda.empty_cache()
data_dir = 'flowers' train_dir = data_dir + '/train' valid_dir = data_dir + '/valid' test_dir = data_dir + '/test' # In[3]: # TODO: Define your transforms for the training, validation, and testing sets data_transforms = transforms.Compose([transforms.RandomRotation(40), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) data_transforms_valid = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) data_transforms_test = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) # TODO: Load the datasets with ImageFolder image_datasets = datasets.ImageFolder(train_dir, data_transforms) image_datasets_valid = datasets.ImageFolder(valid_dir, data_transforms_valid) image_datasets_test = datasets.ImageFolder(test_dir, data_transforms_test) # TODO: Using the image datasets and the trainforms, define the dataloaders dataloaders = torch.utils.data.DataLoader(image_datasets,batch_size = 64) dataloaders_valid = torch.utils.data.DataLoader(image_datasets_valid,batch_size = 64) dataloaders_test = torch.utils.data.DataLoader(image_datasets_test, batch_size = 64)
def main(): args = parse_args() print(colored("Setting default tensor type to cuda.FloatTensor", "cyan")) torch.multiprocessing.set_start_method('spawn') torch.set_default_tensor_type('torch.cuda.FloatTensor') logger, final_output_dir, tb_log_dir = create_logger( config, args.cfg, 'train') logger.info(pprint.pformat(args)) logger.info(pprint.pformat(config)) # cudnn related setting cudnn.benchmark = config.CUDNN.BENCHMARK cudnn.deterministic = config.CUDNN.DETERMINISTIC cudnn.enabled = config.CUDNN.ENABLED gpus = list(config.GPUS) distributed = len(gpus) > 1 #device = torch.device('cuda:{}'.format(args.local_rank)) model = eval('models.' + config.MODEL.NAME + '.get_contrastive_net')(config).cuda() dump_input = torch.rand(config.TRAIN.BATCH_SIZE_PER_GPU, 3, config.MODEL.IMAGE_SIZE[1], config.MODEL.IMAGE_SIZE[0]).cuda() logger.info(get_model_summary(model, dump_input)) if config.TRAIN.MODEL_FILE: model.load_state_dict(torch.load(config.TRAIN.MODEL_FILE)) logger.info( colored('=> loading model from {}'.format(config.TRAIN.MODEL_FILE), 'red')) #if args.local_rank == 0: # copy model file this_dir = os.path.dirname(__file__) models_dst_dir = os.path.join(final_output_dir, 'models') if os.path.exists(models_dst_dir): shutil.rmtree(models_dst_dir) shutil.copytree(os.path.join(this_dir, '../lib/models'), models_dst_dir) """ if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group( backend="nccl", init_method="env://", ) """ torch.cuda.empty_cache() writer_dict = { 'writer': SummaryWriter(log_dir=tb_log_dir), 'train_global_steps': 0, 'valid_global_steps': 0, } gpus = list(config.GPUS) model = nn.DataParallel(model, device_ids=gpus).cuda() print("Finished constructing encoder!") # define loss function (criterion) and optimizer info_nce = InfoNCE(config.CONTRASTIVE.TAU, config.CONTRASTIVE.NORMALIZE, config.CONTRASTIVE.NUM_SAMPLES) criterion = torch.nn.CrossEntropyLoss() optimizer = get_optimizer(config, model) lr_scheduler = None best_perf = 0.0 best_model = False last_epoch = config.TRAIN.BEGIN_EPOCH if config.TRAIN.RESUME: model_state_file = os.path.join(final_output_dir, 'checkpoint.pth.tar') if os.path.isfile(model_state_file): checkpoint = torch.load(model_state_file) last_epoch = checkpoint['epoch'] best_perf = checkpoint['perf'] model.module.load_state_dict(checkpoint['state_dict']) # Update weight decay if needed checkpoint['optimizer']['param_groups'][0][ 'weight_decay'] = config.TRAIN.WD optimizer.load_state_dict(checkpoint['optimizer']) if 'lr_scheduler' in checkpoint: lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, 1e5, last_epoch=checkpoint['lr_scheduler']['last_epoch']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) logger.info("=> loaded checkpoint (epoch {})".format( checkpoint['epoch'])) best_model = True # Data loading code dataset_name = config.DATASET.DATASET if dataset_name == 'imagenet': # implement imagenet later, this is not supported right now traindir = os.path.join(config.DATASET.ROOT + '/', config.DATASET.TRAIN_SET) valdir = os.path.join(config.DATASET.ROOT + '/', config.DATASET.TEST_SET) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform_train = MultiSample(aug_transform( config.MODEL.IMAGE_SIZE[0], base_transform((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), config.DATASET.AUGMENTATIONS), n=config.CONTRASTIVE.NUM_SAMPLES) transform_valid = transforms.Compose([ transforms.Resize(int(config.MODEL.IMAGE_SIZE[0] / 0.875)), transforms.CenterCrop(config.MODEL.IMAGE_SIZE[0]), base_transform((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) train_dataset = datasets.ImageFolder(traindir, transform_train) valid_dataset = datasets.ImageFolder(valdir, transform_valid) else: # only cifar10 runs right now #assert dataset_name == "cifar10", "Only CIFAR-10 is supported at this phase" #classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # For reference # train transform should build contrastive batch transform_train = MultiSample(aug_transform( 32, base_transform(), config['DATASET']['AUGMENTATIONS']), n=config['CONTRASTIVE']['NUM_SAMPLES']) transform_valid = base_transform() if dataset_name == 'cifar10': train_dataset = datasets.CIFAR10(root=f'{config.DATASET.ROOT}', train=True, download=True, transform=transform_train) valid_dataset = datasets.CIFAR10(root=f'{config.DATASET.ROOT}', train=False, download=True, transform=transform_valid) elif dataset_name == 'cifar100': train_dataset = datasets.CIFAR100(root=f'{config.DATASET.ROOT}', train=True, download=True, transform=transform_train) valid_dataset = datasets.CIFAR100(root=f'{config.DATASET.ROOT}', train=False, download=True, transform=transform_valid) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=config.TRAIN.BATCH_SIZE_PER_GPU * len(gpus), shuffle=True, num_workers=config.WORKERS, pin_memory=True) valid_loader = torch.utils.data.DataLoader( valid_dataset, batch_size=config.TEST.BATCH_SIZE_PER_GPU * len(gpus), shuffle=False, num_workers=config.WORKERS, pin_memory=True) # Learning rate scheduler if lr_scheduler is None: if config.TRAIN.LR_SCHEDULER != 'step': lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, len(train_loader) * config.TRAIN.END_EPOCH, eta_min=1e-6) elif isinstance(config.TRAIN.LR_STEP, list): lr_scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, config.TRAIN.LR_STEP, config.TRAIN.LR_FACTOR, last_epoch - 1) else: lr_scheduler = torch.optim.lr_scheduler.StepLR( optimizer, config.TRAIN.LR_STEP, config.TRAIN.LR_FACTOR, last_epoch - 1) # Training code for epoch in range(last_epoch, config.TRAIN.END_EPOCH): topk = (1, 5) if dataset_name == 'imagenet' else (1, ) if config.TRAIN.LR_SCHEDULER == 'step': lr_scheduler.step() # train for one epoch train(config, train_loader, model, info_nce, criterion, optimizer, lr_scheduler, epoch, final_output_dir, tb_log_dir) torch.cuda.empty_cache() # evaluate on validation set #perf_indicator = validate(config, valid_loader, model, criterion, lr_scheduler, epoch, #final_output_dir, tb_log_dir) torch.cuda.empty_cache() writer_dict['writer'].flush() """ if perf_indicator > best_perf: best_perf = perf_indicator best_model = True else: best_model = False """ best_model = True logger.info('=> saving checkpoint to {}'.format(final_output_dir)) save_checkpoint( { 'epoch': epoch + 1, 'model': config.MODEL.NAME, 'state_dict': model.module.state_dict(), #'perf': perf_indicator, 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), }, best_model, final_output_dir, filename='checkpoint.pth.tar') final_model_state_file = os.path.join(final_output_dir, 'final_state.pth.tar') logger.info( 'saving final model state to {}'.format(final_model_state_file)) torch.save(model.module.state_dict(), final_model_state_file) writer_dict['writer'].close()
normalize = transforms.Normalize(mean=[0.5] * 3, std=[0.25] * 3) if args.in_dataset in ['mnist', 'svhn'] and not args.no_flip: print('Horizontal flip disabled for', args.in_dataset) args.no_flip = True flip_prob = 0 if args.no_flip else 0.5 pad = args.crop // 8 train_transform = transforms.Compose([ transforms.Resize(args.scale), transforms.RandomCrop(args.crop, padding=pad), transforms.RandomHorizontalFlip(flip_prob), transforms.ToTensor(), normalize ]) val_transform = transforms.Compose([ transforms.Resize(args.scale), transforms.CenterCrop(args.crop), transforms.ToTensor(), normalize ]) train_in_dataset, n_class = datasets.__dict__[args.in_dataset]( train=True, transform=train_transform) train_out_dataset, _ = datasets.__dict__[args.out_dataset]( train=True, transform=train_transform) val_in_dataset, _ = datasets.__dict__[args.in_dataset](train=False, transform=val_transform) val_out_dataset, _ = datasets.__dict__[args.out_dataset]( train=False, transform=val_transform) if args.resample: if args.resample == 'random': w = torch.rand(len(train_out_dataset))
def __init__(self, data_path, preprocessor, split, splits={ "train": ["train", "val"], "validation": ["val"], "test": ["test"], }, augment=False, use_segment=False, audio_feature="mfcc", image_feature="image", phone_label="multilingual", ds_method="average", sample_rate=16000, min_class_size=50, debug=False): self.preprocessor = preprocessor self.splits = splits[split] self.data_path = data_path self.use_segment = use_segment self.ds_method = ds_method self.sample_rate = sample_rate self.max_feat_len = 100 self.max_word_len = 100 self.max_phone_num = 50 self.max_segment_num = 5 # XXX self.max_segment_len = 10 self.debug = debug data = [] for sp in self.splits: # Load data paths to audio and visual features examples = load_data_split(data_path, sp, min_class_size=min_class_size, audio_feature=audio_feature, image_feature=image_feature, phone_label=phone_label, debug=debug) data.extend(examples) print("Number of {} audio files = {}".format(split, len(examples))) # Set up transforms self.audio_transforms = [ torchaudio.transforms.MelSpectrogram( sample_rate=sample_rate, win_length=sample_rate * 25 // 1000, n_mels=preprocessor.num_features, hop_length=sample_rate * 10 // 1000, ), torchvision.transforms.Lambda(log_normalize), ] if augment: augmentation = [ torchaudio.transforms.FrequencyMasking(27, iid_masks=True), torchaudio.transforms.FrequencyMasking(27, iid_masks=True), torchaudio.transforms.TimeMasking(100, iid_masks=True), torchaudio.transforms.TimeMasking(100, iid_masks=True), ] self.audio_transforms.extend(augmentation) self.audio_transforms = torchvision.transforms.Compose( self.audio_transforms) self.image_transforms = transforms.Compose([ transforms.Scale(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) # Load each image-caption pairs audio = [example["audio"] for example in data] image = [example["image"] for example in data] boxes = [example["box"] for example in data] text = [example["text"] for example in data] phonemes = [example["phonemes"] for example in data] feat_idxs = [example["box_idx"] for example in data] self.dataset = list(zip(audio, image, text, phonemes, boxes, feat_idxs)) self.image_feature_type = image_feature self.image_feats = np.load( os.path.join(data_path, f"../flickr8k_{image_feature}.npz") ) # XXX np.load(os.path.join(data_path, "flickr8k_res34.npz")) self.image_to_feat = { '_'.join(feat_id.split('_')[:-1]): feat_id for feat_id in self.image_feats } self.audio_feature_type = audio_feature
def main(): global args, best_acc args = parser.parse_args() args.cuda = args.cuda and torch.cuda.is_available() torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) torch.cuda.set_device(0) global plotter plotter = VisdomLinePlotter(env_name=args.name) kwargs = {'num_workers': 20, 'pin_memory': True} if args.cuda else {} print('==>Preparing data...') base_path = "./data/handpose_data/" train_loader = torch.utils.data.DataLoader( SimpleImageLoader( base_path, train=True, transform=transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ColorJitter(0.05, 0.05, 0.05, 0.05), transforms.ToTensor(), Lighting(0.1, _imagenet_pca['eigval'], _imagenet_pca['eigvec']), # transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]) ])), batch_size=args.batch_size, shuffle=True, drop_last=False, **kwargs) test_loader = torch.utils.data.DataLoader( SimpleImageLoader( base_path, False, transform=transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])), batch_size=args.batch_size, drop_last=False, **kwargs) jnet = SimpleRegression() if args.cuda: jnet.cuda() if torch.cuda.device_count() > 1 and args.parallel: jnet = nn.DataParallel(jnet, device_ids=[0, 1]) # dataParallel # This flag allows you to enable the inbuilt cudnn auto-tuner to # find the best algorithm to use for your hardware. cudnn.benchmark = True criterion = torch.nn.MSELoss() optimizer = optim.SGD(jnet.parameters(), lr=args.lr, momentum=args.momentum) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("==> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] jnet.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("==> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("==> no checkpoint found at '{}'".format(args.resume)) for epoch in range(1, args.epochs + 1): # train for one epoch adjust_learning_rate(jnet, optimizer, epoch) train(train_loader, jnet, criterion, optimizer, epoch) # evaluate on validation set acc = test(test_loader, jnet, criterion, epoch) # remember best acc and save checkpoint is_best = acc > best_acc best_acc = max(acc, best_acc) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': jnet.state_dict(), 'best_prec1': best_acc, 'optimizer': optimizer.state_dict(), }, is_best)
import torchvision.transforms as transforms from torchvision.datasets import ImageFolder from torch.utils.data import DataLoader import torch import torch.nn as nn from torch.autograd import Variable from sklearn.metrics import confusion_matrix import matplotlib.pyplot as plt import numpy as np import time import torchvision # https://towardsdatascience.com/a-beginners-tutorial-on-building-an-ai-image-classifier-using-pytorch-6f85cb69cba7 transformations = transforms.Compose([ transforms.Resize(800), transforms.CenterCrop(800), transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) import os base_path = os.getcwd() print("The current working directory is %s" % base_path) train_data = ImageFolder(os.path.join(base_path, 'train_data'), transform=transformations) test_data = ImageFolder(os.path.join(base_path, 'test_data'), transform=transformations) batch_size = 4 train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
# ======================= Data Setings ===================================== dataset_root_train = '/research/prip-gongsixu/datasets/RFW' dataset_root_test = None # input data size image_height = 112 image_width = 112 image_size = (image_height, image_width) # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # preprocessing preprocess_train = transforms.Compose([ \ transforms.CenterCrop(image_size), \ transforms.Resize(image_size), \ # transforms.RandomResizedCrop(image_size, scale=(0.2, 1.)), \ # transforms.RandomApply([ # transforms.ColorJitter(0.4, 0.4, 0.4, 0.1) # not strengthened # ], p=0.8), # transforms.RandomGrayscale(p=0.2), \ # transforms.RandomApply([datasets.loaders.GaussianBlur([.1, 2.])], p=0.5), \ transforms.RandomHorizontalFlip(), \ # transforms.RandomVerticalFlip(), \ # transforms.RandomRotation(10), \ transforms.ToTensor(), \ normalize \ ]) preprocess_test = transforms.Compose([ \
def train(data_dir='flower_data', model=None): train_transforms = transforms.Compose([ transforms.RandomRotation(30), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = train_transforms = transforms.Compose([ transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms) test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms) valid_data = datasets.ImageFolder(data_dir + '/valid', transform=test_transforms) trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True) testloader = torch.utils.data.DataLoader(test_data, batch_size=64) validloader = torch.utils.data.DataLoader(valid_data, batch_size=64) if not model: print("1: vgg16, 2: vgg19") inp = input("Which Model do you want?") if inp == '1': print("VGG16 selected") model = models.vgg16(pretrained=True) for param in model.parameters(): param.requires_grad = False classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(25088, 4096)), ('relu', nn.ReLU()), ('drop1', nn.Dropout(p=0.3)), ('fc2', nn.Linear(4096, 1000)), ('relu2', nn.ReLU()), ('drop2', nn.Dropout(p=0.3)), ('fc3', nn.Linear(1000, 512)), ('relu3', nn.ReLU()), ('drop3', nn.Dropout(p=0.3)), ('fc4', nn.Linear(512, 102)), ('output', nn.LogSoftmax(dim=1))])) model.classifier = classifier elif inp == '2': print("vgg19 selected") model = models.vgg19(pretrained=True) for param in model.parameters(): param.requires_grad = False classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(25088, 4096)), ('relu', nn.ReLU()), ('drop1', nn.Dropout(p=0.3)), ('fc2', nn.Linear(4096, 1000)), ('relu2', nn.ReLU()), ('drop2', nn.Dropout(p=0.3)), ('fc3', nn.Linear(1000, 512)), ('relu3', nn.ReLU()), ('drop3', nn.Dropout(p=0.3)), ('fc4', nn.Linear(512, 102)), ('output', nn.LogSoftmax(dim=1))])) model.classifier = classifier else: exit() criterion = nn.NLLLoss() epochs = int(input("How many Epochs?")) lr = float(input("How much learning rate?")) optimizer = optim.Adam(model.classifier.parameters(), lr) device = input("'cpu' or 'cuda'?") model = model.to(device) device = torch.device(device) steps = 0 print_every = 20 for epoch in range(epochs): running_loss = 0 for inputs, labels in trainloader: steps += 1 inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() log_ps = model.forward(inputs) loss = criterion(log_ps, labels) loss.backward() optimizer.step() running_loss += loss.item() if steps % print_every == 0: test_loss = 0 accuracy = 0 model.eval() with torch.no_grad(): for inputs, labels in validloader: inputs, labels = inputs.to(device), labels.to(device) log_ps = model.forward(inputs) batch_loss = criterion(log_ps, labels) test_loss += batch_loss.item() ps = torch.exp(log_ps) top_p, top_class = ps.topk(1, dim=1) equals = top_class == labels.view(*top_class.shape) accuracy += torch.mean(equals.type( torch.FloatTensor)).item() print(f"Epoch {epoch+1}/{epochs}.. " f"Train loss: {running_loss/print_every:.3f}.. " f"Test loss: {test_loss/len(validloader):.3f}.. " f"Test accuracy: {accuracy/len(validloader):.3f}") running_loss = 0 model.train() print("------------------------") accuracy = 0 total = 0 model.eval() with torch.no_grad(): for inputs, labels in testloader: inputs, labels = inputs.to(device), labels.to(device) log_ps = model.forward(inputs) ps = torch.exp(log_ps) top_p, top_class = ps.topk(1, dim=1) equals = top_class == labels.view(*top_class.shape) accuracy += sum(equals).item() total += len(labels) print("Accuracy is : ", accuracy / total) model.class_to_idx = train_data.class_to_idx checkpoint = { 'model': model, 'state_dict': model.state_dict(), 'class_to_idx': model.class_to_idx } torch.save(checkpoint, 'checkpoint' + str(inp) + '.pth')
from model.efnet import efficientnet from PIL import ImageFile, Image from torchvision import transforms import torch import glob import numpy as np trans = transforms.Compose([ transforms.Resize(280), transforms.CenterCrop(260), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) label_id_name_dict = \ { "0": "其他垃圾/一次性快餐盒", "1": "其他垃圾/污损塑料", "2": "其他垃圾/烟蒂", "3": "其他垃圾/牙签", "4": "其他垃圾/破碎花盆及碟碗", "5": "其他垃圾/竹筷", "6": "厨余垃圾/剩饭剩菜", "7": "厨余垃圾/大骨头", "8": "厨余垃圾/水果果皮", "9": "厨余垃圾/水果果肉", "10": "厨余垃圾/茶叶渣", "11": "厨余垃圾/菜叶菜根", "12": "厨余垃圾/蛋壳", "13": "厨余垃圾/鱼骨", "14": "可回收物/充电宝", "15": "可回收物/包", "16": "可回收物/化妆品瓶",
def main(): global args, best_acc1 args = parser.parse_args() if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) # create model if args.pretrained: print("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True) else: print("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch]() print(model) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda(args.gpu) optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code traindir = os.path.join(args.data, 'train') valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion) return for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) adjust_learning_rate(optimizer, epoch) # train for one epoch train(train_loader, model, criterion, optimizer, epoch) # evaluate on validation set acc1 = validate(val_loader, model, criterion) # remember best acc@1 and save checkpoint is_best = acc1 > best_acc1 best_acc1 = max(acc1, best_acc1) save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer': optimizer.state_dict(), }, is_best)
def main(): global args, best_acc args = parser.parse_args() init_distributed_mode(args) fix_random_seeds(args.seed) logger, training_stats = initialize_exp( args, "epoch", "loss", "prec1", "prec5", "loss_val", "prec1_val", "prec5_val", ) # build data train_data_path = os.path.join(args.data_path, "train") train_dataset = datasets.ImageFolder(train_data_path) # take either 1% or 10% of images subset_file = urllib.request.urlopen( "https://raw.githubusercontent.com/google-research/simclr/master/imagenet_subsets/" + str(args.labels_perc) + "percent.txt") list_imgs = [li.decode("utf-8").split("\n")[0] for li in subset_file] train_dataset.samples = [( os.path.join(train_data_path, li.split("_")[0], li), train_dataset.class_to_idx[li.split("_")[0]], ) for li in list_imgs] val_dataset = datasets.ImageFolder(os.path.join(args.data_path, "val")) tr_normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.228, 0.224, 0.225]) train_dataset.transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), tr_normalize, ]) val_dataset.transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), tr_normalize, ]) sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) train_loader = torch.utils.data.DataLoader( train_dataset, sampler=sampler, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, ) val_loader = torch.utils.data.DataLoader( val_dataset, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, ) logger.info("Building data done with {} images loaded.".format( len(train_dataset))) # build model model = resnet_models.__dict__[args.arch](output_dim=1000) # convert batch norm layers model = nn.SyncBatchNorm.convert_sync_batchnorm(model) # load weights if os.path.isfile(args.pretrained): state_dict = torch.load(args.pretrained, map_location="cuda:" + str(args.gpu_to_work_on)) if "state_dict" in state_dict: state_dict = state_dict["state_dict"] # remove prefixe "module." state_dict = { k.replace("module.", ""): v for k, v in state_dict.items() } for k, v in model.state_dict().items(): if k not in list(state_dict): logger.info( 'key "{}" could not be found in provided state dict'. format(k)) elif state_dict[k].shape != v.shape: logger.info( 'key "{}" is of different shape in model and provided state dict' .format(k)) state_dict[k] = v msg = model.load_state_dict(state_dict, strict=False) logger.info("Load pretrained model with msg: {}".format(msg)) else: logger.info( "No pretrained weights found => training from random weights") # model to gpu model = model.cuda() model = nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu_to_work_on], find_unused_parameters=True) # set optimizer trunk_parameters = [] head_parameters = [] for name, param in model.named_parameters(): if "head" in name: head_parameters.append(param) else: trunk_parameters.append(param) optimizer = torch.optim.SGD( [ { "params": trunk_parameters }, { "params": head_parameters, "lr": args.lr_last_layer }, ], lr=args.lr, momentum=0.9, weight_decay=0, ) # set scheduler scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, args.decay_epochs, gamma=args.gamma) # Optionally resume from a checkpoint to_restore = {"epoch": 0, "best_acc": (0.0, 0.0)} restart_from_checkpoint( os.path.join(args.dump_path, "checkpoint.pth.tar"), run_variables=to_restore, state_dict=model, optimizer=optimizer, scheduler=scheduler, ) start_epoch = to_restore["epoch"] best_acc = to_restore["best_acc"] cudnn.benchmark = True for epoch in range(start_epoch, args.epochs): # train the network for one epoch logger.info("============ Starting epoch %i ... ============" % epoch) # set samplers train_loader.sampler.set_epoch(epoch) scores = train(model, optimizer, train_loader, epoch) scores_val = validate_network(val_loader, model) training_stats.update(scores + scores_val) scheduler.step() # save checkpoint if args.rank == 0: save_dict = { "epoch": epoch + 1, "state_dict": model.state_dict(), "optimizer": optimizer.state_dict(), "scheduler": scheduler.state_dict(), "best_acc": best_acc, } torch.save(save_dict, os.path.join(args.dump_path, "checkpoint.pth.tar")) logger.info("Fine-tuning with {}% of labels completed.\n" "Test accuracies: top-1 {acc1:.1f}, top-5 {acc5:.1f}".format( args.labels_perc, acc1=best_acc[0], acc5=best_acc[1]))
def main_worker(args): global best_acc1 # create model if args.pretrained: print("=> using pre-trained model resnet18 ") model = resnet18(pretrained=True) # no need for update parameter for param in model.parameters(): param.requires_grad = False # update parameter and modify num of classes num_classes = 2 model.fc = nn.Linear(512, num_classes) else: print("=> creating resnet 18 model") model = resnet18() if torch.cuda.is_available(): model = model.cuda() # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) if torch.cuda.is_available(): checkpoint = torch.load(args.resume).cuda() else: # Map model to be loaded to specified single gpu. checkpoint = torch.load(args.resume, map_location="cpu") args.start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] if torch.cuda.is_available(): # best_acc1 may be from a checkpoint from a different GPU best_acc1 = best_acc1.to('cuda:0') model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code traindir = os.path.join(args.data, 'TRAIN') valdir = os.path.join(args.data, 'TEST') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, args) return for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch, args) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on validation set acc1 = validate(val_loader, model, criterion, args) # remember best acc@1 and save checkpoint is_best = acc1 > best_acc1 best_acc1 = max(acc1, best_acc1) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer': optimizer.state_dict(), }, is_best)
from data_helper import UnlabeledDataset, LabeledDataset, LabeledDataset_task2 from helper import collate_fn, draw_filled_box # You shouldn't change the unlabeled_scene_index # The first 106 scenes are unlabeled (80,136 unlabeled images) unlabeled_scene_index = np.arange(106) # The scenes from 106 - 133 are labeled (20,412 labeled images) # You should devide the labeled_scene_index into two subsets (training and validation) labeled_scene_index = np.arange(106, 134) image_folder = 'data' annotation_csv = 'data/annotation.csv' labeled_scene_index = np.arange(106, 134) img_transform = transforms.Compose([ transforms.CenterCrop(256), transforms.ToTensor(), transforms.Normalize(mean=(0.5, ), std=(0.5, )) ]) map_transform = transforms.Compose( [transforms.Resize(256), transforms.ToTensor()]) transform = torchvision.transforms.ToTensor() unlabeled_trainset = UnlabeledDataset(image_folder=image_folder, scene_index=labeled_scene_index, first_dim='sample', transform=img_transform) trainloader = torch.utils.data.DataLoader(unlabeled_trainset, batch_size=16,
ALTURA = 64 DATA_PATH = 'data3' BATCH_SIZE = 2 # novo nz = 100 #latent vector (gen input) era 100 ngf = 64 #feature map gen ndf = 64 #feature map disc beta1 = 0.5 ngpu = 1 dataset = torchvision.datasets.ImageFolder(root=DATA_PATH, transform=transforms.Compose([ transforms.Resize(LARGURA), transforms.CenterCrop(LARGURA), transforms.ToTensor(), transforms.Normalize( (0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) train_loader = torch.utils.data.DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) device = torch.device("cuda:0" if ( torch.cuda.is_available() and ngpu > 0) else "cpu")
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") data_transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # load image img_path = "a.jpg" assert os.path.exists(img_path), "file: '{}' dose not exist.".format( img_path) img = Image.open(img_path) plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) print('input shape is: ', img.shape) # read class_indict json_path = './class_indices.json' assert os.path.exists(json_path), "file: '{}' dose not exist.".format( json_path) json_file = open(json_path, "r") class_indict = json.load(json_file) # create model model = shufflenet_v2_x1_0(num_classes=5).to(device) # load model weights model_weight_path = "./weights/model-29.pth" model.load_state_dict(torch.load(model_weight_path, map_location=device)) model.eval() print('=================================') dummy_input = torch.randn(1, 3, 224, 224).to(device) torch.onnx.export(model, dummy_input, 'shufflenetv2.onnx', dynamic_axes={ 'image': { 0: 'B' }, 'outputs': { 0: 'B' } }, input_names=['image'], output_names=['outputs'], opset_version=9) print('=================================') with torch.no_grad(): # predict class output = torch.squeeze(model(img.to(device))).cpu() predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print_res = "class: {} prob: {:.3}".format( class_indict[str(predict_cla)], predict[predict_cla].numpy()) plt.title(print_res) print(print_res) plt.show()
def main(args: argparse.Namespace): logger = CompleteLogger(args.log, args.phase) if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') cudnn.benchmark = True # Data loading code normalize = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) if args.center_crop: train_transform = T.Compose([ ResizeImage(256), T.CenterCrop(224), T.RandomHorizontalFlip(), T.ToTensor(), normalize ]) else: train_transform = T.Compose([ ResizeImage(256), T.RandomCrop(224), T.RandomHorizontalFlip(), T.ToTensor(), normalize ]) val_transform = T.Compose([ ResizeImage(256), T.CenterCrop(224), T.ToTensor(), normalize ]) dataset = datasets.__dict__[args.data] train_source_dataset = dataset(root=args.root, task=args.source, download=True, transform=train_transform) train_source_loader = DataLoader(train_source_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, drop_last=True) train_target_dataset = dataset(root=args.root, task=args.target, download=True, transform=train_transform) train_target_loader = DataLoader(train_target_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, drop_last=True) val_dataset = dataset(root=args.root, task=args.validation, download=True, transform=val_transform) val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers) if args.data == 'DomainNet': test_dataset = dataset(root=args.root, task=args.target, split='test', download=True, transform=val_transform) test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers) else: test_loader = val_loader train_source_iter = ForeverDataIterator(train_source_loader) train_target_iter = ForeverDataIterator(train_target_loader) # create model print("=> using pre-trained model '{}'".format(args.arch)) backbone = models.__dict__[args.arch](pretrained=True) classifier = ImageClassifier(backbone, train_source_dataset.num_classes, args.num_blocks, bottleneck_dim=args.bottleneck_dim, dropout_p=args.dropout_p).to(device) adaptive_feature_norm = AdaptiveFeatureNorm(args.delta).to(device) # define optimizer # the learning rate is fixed according to origin paper optimizer = SGD(classifier.get_parameters(), args.lr, weight_decay=args.weight_decay) # resume from the best checkpoint if args.phase != 'train': checkpoint = torch.load(logger.get_checkpoint_path('best'), map_location='cpu') classifier.load_state_dict(checkpoint) # analysis the model if args.phase == 'analysis': # extract features from both domains feature_extractor = nn.Sequential(classifier.backbone, classifier.bottleneck).to(device) source_feature = collect_feature(train_source_loader, feature_extractor, device) target_feature = collect_feature(train_target_loader, feature_extractor, device) # plot t-SNE tSNE_filename = osp.join(logger.visualize_directory, 'TSNE.png') tsne.visualize(source_feature, target_feature, tSNE_filename) print("Saving t-SNE to", tSNE_filename) # calculate A-distance, which is a measure for distribution discrepancy A_distance = a_distance.calculate(source_feature, target_feature, device) print("A-distance =", A_distance) return if args.phase == 'test': acc1 = validate(test_loader, classifier, args) print(acc1) return # start training best_acc1 = 0. for epoch in range(args.epochs): # train for one epoch train(train_source_iter, train_target_iter, classifier, adaptive_feature_norm, optimizer, epoch, args) # evaluate on validation set acc1 = validate(val_loader, classifier, args) # remember best acc@1 and save checkpoint torch.save(classifier.state_dict(), logger.get_checkpoint_path('latest')) if acc1 > best_acc1: shutil.copy(logger.get_checkpoint_path('latest'), logger.get_checkpoint_path('best')) best_acc1 = max(acc1, best_acc1) print("best_acc1 = {:3.1f}".format(best_acc1)) # evaluate on test set classifier.load_state_dict(torch.load(logger.get_checkpoint_path('best'))) acc1 = validate(test_loader, classifier, args) print("test_acc1 = {:3.1f}".format(acc1)) logger.close()
# line = fileDescriptor.readline() # # print (line) # if line: # lineItems = line.split() # print(lineItems[0].split('/')[-1]) # print(i) #-------------------- SETTINGS: DATASET BUILDERS trBatchSize = 1 normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) transformList_test_val = [] transformList_test_val.append(transforms.Resize(256)) transformList_test_val.append(transforms.CenterCrop(224)) transformList_test_val.append(transforms.ToTensor()) transformList_test_val.append(normalize) transformSequence_test_val = transforms.Compose(transformList_test_val) datasetTest = DatasetGenerator(pathImageDirectory='../chest-image/images', pathDatasetFile='./dataset/bbox.txt', transform=transformSequence_test_val) dataLoaderTest = DataLoader(dataset=datasetTest, batch_size=trBatchSize, shuffle=False, num_workers=2, pin_memory=True) #---- TEST THE NETWORK
data_transforms = { 'train': transforms.Compose([ transforms.Pad((0, pad_size)), transforms.RandomResizedCrop(299), transforms.RandomHorizontalFlip(), transforms.ToTensor() ]), 'finetune': transforms.Compose([transforms.Pad((0, pad_size)), transforms.Resize((299, 299)), transforms.ToTensor() ]), } else: data_transforms = { 'train': transforms.Compose([ transforms.CenterCrop(crop_size), transforms.RandomResizedCrop(299), transforms.RandomHorizontalFlip(), transforms.ToTensor() ]), 'finetune': transforms.Compose([transforms.CenterCrop(crop_size), transforms.Resize((299, 299)), transforms.ToTensor() ]), } # test_dataset = datasets.ImageFolder(test_data_dir, data_transforms['finetune']) test_dataset = ImageFolderWithPaths(test_data_dir, data_transforms['finetune'])