def qforward(): qnet = torch.load('./data_quan/cifar10_qun4_best.pt') stats = load_stats('./data_quan/stats_table4.json') #print(qnet) #print(stats) batch_size = 128 transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.24703, 0.24349, 0.26159))]) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,shuffle=False, num_workers=4) #classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # load model model = copy.deepcopy(qnet) num_bits = 4 val_record = {'min':{}, 'max':{}} scale_factors_record = {} final_accuracys = {} corrects = 0 total = len(testloader.dataset) model = model.cuda() model.eval() with torch.no_grad(): for n_scale in range(1, 16): corrects = 0 print("with n_scale : {}".format(n_scale)) with tqdm(total=total, ascii=True) as tbar: for images, labels in testloader: images, labels = images.cuda(), labels.cuda() outputs, weights_record, bias_record, scale_factors_record = bit_conv_forward(images, model, num_bits, n_scale, val_record, scale_factors_record, stats) model.conv1.weight.data = weights_record[0] model.conv2.weight.data = weights_record[1] model.conv3.weight.data = weights_record[2] model.conv4.weight.data = weights_record[3] model.conv5.weight.data = weights_record[4] model.conv6.weight.data = weights_record[5] model.conv7.weight.data = weights_record[6] model.conv8.weight.data = weights_record[7] model.conv9.weight.data = weights_record[8] model.conv10.weight.data = weights_record[9] model.conv11.weight.data = weights_record[10] model.conv12.weight.data = weights_record[11] model.classifier.weight.data = weights_record[12] model.conv1.bias.data = bias_record[0] model.conv2.bias.data = bias_record[1] model.conv3.bias.data = bias_record[2] model.conv4.bias.data = bias_record[3] model.conv5.bias.data = bias_record[4] model.conv6.bias.data = bias_record[5] model.conv7.bias.data = bias_record[6] model.conv8.bias.data = bias_record[7] model.conv9.bias.data = bias_record[8] model.conv10.bias.data = bias_record[9] model.conv11.bias.data = bias_record[10] model.conv12.bias.data = bias_record[11] model.classifier.bias.data = bias_record[12] _, predicted = torch.max(outputs, 1) c = (predicted == labels).sum() corrects += c tbar.update(labels.size(0)) acc = (100.*corrects/total) print("test accuracy: {}/{} = {}%\n".format(corrects, total, acc)) final_accuracys[str(n_scale)] = acc return final_accuracys, scale_factors_record
def create_dataloader(loader_type, args): """ Create a data loader according to the parameters """ kwargs = { 'num_workers': args.num_loader_workers, 'pin_memory': True } if args.cuda else {} if args.dataset_type == DatasetType.NYU: if loader_type == LoaderMode.VAL: print("===> Creating validation data loader...") needed_cam_ids = np.append(args.output_cam_ids_test, args.needed_cam_ids_test) needed_cam_ids_synth = [] num_samples_val = min( int(round(args.max_val_train_ratio * args.num_labeled_samples)), args.max_num_samples_val) ids_val = np.arange(args.id_start_val, args.id_end_val + 1) ids_val = args.rng.permutation(ids_val) ids_val = ids_val[:num_samples_val] loader = torch.utils.data.DataLoader( NyuHandPoseMultiViewDataset( args.nyu_data_basepath, train=False, cropSize=args.in_crop_size, doJitterCom=args.do_jitter_com_test, sigmaCom=args.sigma_com, doAddWhiteNoise=args.do_add_white_noise_test, sigmaNoise=args.sigma_noise, transform=transforms.ToTensor(), useCache=args.use_pickled_cache, cacheDir=args.nyu_data_basepath_pickled, annoType=args.anno_type, neededCamIdsReal=needed_cam_ids, neededCamIdsSynth=needed_cam_ids_synth, randomSeed=args.seed, cropSize3D=args.crop_size_3d_tuple, args_data=args), batch_size=args.batch_size, sampler=smpl.SubsetRandomSampler(ids_val), **kwargs) print("Using {} samples for validation".format(len(ids_val))) elif loader_type == LoaderMode.TEST: print("===> Creating test data loader...") needed_cam_ids_synth = [] loader = torch.utils.data.DataLoader(NyuHandPoseMultiViewDataset( args.nyu_data_basepath, train=False, cropSize=args.in_crop_size, doJitterCom=args.do_jitter_com_test, sigmaCom=args.sigma_com, doAddWhiteNoise=args.do_add_white_noise_test, sigmaNoise=args.sigma_noise, transform=transforms.ToTensor(), useCache=args.use_pickled_cache, cacheDir=args.nyu_data_basepath_pickled, annoType=args.anno_type, neededCamIdsReal=args.needed_cam_ids_test, neededCamIdsSynth=needed_cam_ids_synth, randomSeed=args.seed, cropSize3D=args.crop_size_3d_tuple, args_data=args), batch_size=args.batch_size, **kwargs) print("Using {} samples for test".format(len(loader.sampler))) else: raise UserWarning("LoaderMode implemented.") else: raise UserWarning("DatasetType not implemented.") return loader
def create_loader_preview(loader_type, args_data, do_use_gpu, num_loader_workers, min_samp_prob_label, batch_size, cam_ids_real, cam_ids_synth, seed, id_range=[], ids_train_permuted=[]): # Sanity check if not loader_type == LoaderMode.TRAIN: print("Required loader-type {} not implemented.".format(loader_type)) raise UserWarning( "requested loader generation currently only implemented for TRAINING data loaders" ) kwargs = { 'num_workers': num_loader_workers, 'pin_memory': True } if do_use_gpu else {} if args_data.dataset_type == DatasetType.NYU: if len(id_range) == 0: id_range = [args_data.id_start_train, args_data.id_end_train + 1] # Set up sample IDs to sample from ids_train = np.arange(*id_range) if len(ids_train_permuted) == 0: ids_train_permuted = args_data.rng.permutation(ids_train) ids_train_labeled = ids_train_permuted[:args_data.num_labeled_samples] ids_train_unlabeled = ids_train_permuted[args_data. num_labeled_samples:] # Ensure a minimum sampling probability for labeled samples ratio_labeled = len(ids_train_labeled) / float(len(ids_train)) prob_labeled = max(min_samp_prob_label, ratio_labeled) prob_unlabeled = 1.0 - prob_labeled # Set up distribution/weights to sample from (considering un-/labeled samples) scale_weights = float( len(ids_train)) # value to which weights will sum up sample_weight_labeled = prob_labeled * scale_weights / float( len(ids_train_labeled)) sample_weight_unlabeled = prob_unlabeled * scale_weights \ / float(len(ids_train_unlabeled)) \ if len(ids_train_unlabeled) > 0 else 0.0 sampling_weights = np.zeros((args_data.num_all_samples_train)) sampling_weights[ids_train_labeled] = sample_weight_labeled sampling_weights[ids_train_unlabeled] = sample_weight_unlabeled num_samples_used_for_train = np.count_nonzero(sampling_weights) loader = torch.utils.data.DataLoader( NyuHandPoseMultiViewDataset( args_data.nyu_data_basepath, train=True, cropSize=args_data.in_crop_size, doJitterCom=args_data.do_jitter_com, sigmaCom=args_data.sigma_com, doAddWhiteNoise=args_data.do_add_white_noise, sigmaNoise=args_data.sigma_noise, unlabeledSampleIds=ids_train_unlabeled, transform=transforms.ToTensor(), useCache=args_data.use_pickled_cache, cacheDir=args_data.nyu_data_basepath_pickled, annoType=args_data.anno_type, neededCamIdsReal=cam_ids_real, neededCamIdsSynth=cam_ids_synth, randomSeed=seed, cropSize3D=args_data.crop_size_3d_tuple, args_data=args_data), batch_size=batch_size, sampler=smpl.WeightedRandomSampler( sampling_weights, num_samples=num_samples_used_for_train, replacement=True), **kwargs) print( "Using {} samples for training".format(num_samples_used_for_train)) if sample_weight_labeled > 0.: print(" {} labeled".format(len(ids_train_labeled))) if sample_weight_unlabeled > 0.: print(" {} unlabeled".format(len(ids_train_unlabeled))) return loader
if img_path['articleType'] not in self.label_map: self.label_map[img_path['articleType']] = i i += 1 if img_path['articleType'] not in self.class_distribution: self.class_distribution[img_path['articleType']] = 1 else: self.class_distribution[img_path['articleType']] += 1 print("Found {} images in {} for provided csv file.".format(len(self.data), data_dir)) print("Total classes: {}".format(len(self.label_map))) # print(self.label_map) # for testing purpose if __name__ == "__main__": data_loader = FashionDataset("D:\\Projects\\Datasets\\fashion-product-images", "top20classes_set.csv", transform=transforms.Compose([transforms.Resize((224,224)), transforms.ToTensor()])) i = 0 print(len(data_loader)) dataset_loader = torch.utils.data.DataLoader(dataset=data_loader, batch_size=16, shuffle=True) print(len(dataset_loader)) # print(list(range(len(data_loader)))) print(data_loader[0][1]) for img, label in data_loader: d = transforms.ToPILImage()(img) i += 1 if i == 10: print("Label: ", label) # d.show() # print(img.size()) # break
if __name__ == '__main__': if args.channels == 3: normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) elif args.channels == 1: normalize = transforms.Normalize(mean=[0.5], std=[0.5]) # create model avg_pool_size = (args.avg_pooling_height, args.avg_pooling_width) if args.simple_resnet: model = resnet18(num_classes=args.num_classes, channels=args.channels, avg_pooling_size=avg_pool_size) else: model = densenet121(num_classes=args.num_classes, channels=args.channels, avg_pooling_size=avg_pool_size) train_transforms = transforms.Compose([transforms.ToTensor(), normalize]) val_transforms = transforms.Compose([transforms.ToTensor(), normalize]) # start main loop main(args, model, pil_loader, pil_loader, normalize, validate_model=validate_model, train_transforms=train_transforms, val_transforms=val_transforms)
def main(): # specify device and choose gpu if it's available device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print('Using device:', device) lookup = dict() reverselookup = dict() count = 0 for j in os.listdir('./data/leapGestRecog/00/'): if not j.startswith('.'): # If running this code locally, this is to # ensure you aren't reading in hidden folders lookup[j] = count reverselookup[count] = j count = count + 1 print(lookup) classes = (lookup.keys()) x_data = [] label_data = [] imagecount = 0 # total Image count for i in range(0, 10): # Loop over the ten top-level folders for j in os.listdir('./data/leapGestRecog/0' + str(i) + '/'): if not j.startswith('.'): # Again avoid hidden folders count = 0 # To tally images of a given gesture # loop over the images # read in and convert to greyscale for k in os.listdir('./data/leapGestRecog/0' + str(i) + '/' + j + '/'): img = Image.open('./data/leapGestRecog/0' + str(i) + '/' + j + '/' + k).convert('L') img = img.resize((320, 120)) arr = np.array(img) x_data.append(arr) count = count + 1 y_values = np.full((count, 1), lookup[j]) label_data.append(y_values) imagecount = imagecount + count x_data = np.array(x_data, dtype='float32') label_data = np.array(label_data) label_data = label_data.reshape(imagecount, 1) # Reshape to be the correct size # check the shape of train data print("Total Data shape",x_data.shape) print("Total labels shape",label_data) # divide the data into train, validation and test x_train, x_valid_test, y_train, y_valid_test = train_test_split(x_data, label_data, test_size=0.3) x_validate, x_test, y_validate, y_test = train_test_split(x_valid_test, y_valid_test, test_size=0.5) # check the shape of train data print("Train Data shape=",x_train.shape) print("Train Labels shape=",y_train.shape) # check the shape of validation data print("Validation data shape=",x_validate.shape) print("Validation labels shape=",y_validate.shape) # check the shape of test data print("Test data shape=",x_test.shape) print("Test data label=",y_test.shape) batch_size_list = [64] results = {} resultsDF = [] f1DF = [] for BATCH_SIZE in batch_size_list: # specify the transformation transform = transforms.Compose( [transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))]) # perform the pre-processing on train data data_train = DatasetProcessing(x_train, y_train, transform) # load the train data train_loader = torch.utils.data.DataLoader(data_train, batch_size=BATCH_SIZE, shuffle=True, num_workers=4) # specify the transformation transform = transforms.Compose( [transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))]) data_validate = DatasetProcessing(x_validate, y_validate, transform) validate_loader = torch.utils.data.DataLoader(data_validate, batch_size=BATCH_SIZE, shuffle=True, num_workers=4) # specify the transformation transform = transforms.Compose( [transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))]) data_test = DatasetProcessing(x_test, y_test, transform) test_loader = torch.utils.data.DataLoader(data_test, batch_size=BATCH_SIZE, shuffle=True, num_workers=4) # specify the number of epochs and learning rate learning_rate_list = [0.001] optimizer_functions_list = ['Adam'] for LEARNING_RATE in learning_rate_list: for OPTIMIZER in optimizer_functions_list: # create instance of model model = CNN().to(device) criterion = nn.CrossEntropyLoss() if OPTIMIZER == 'SGD': optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE) elif OPTIMIZER == 'ASGD': optimizer = torch.optim.ASGD(model.parameters(), lr=LEARNING_RATE) elif OPTIMIZER == 'Adam': optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE) elif OPTIMIZER == 'Adagrad': optimizer = torch.optim.Adagrad(model.parameters(), lr=LEARNING_RATE) elif OPTIMIZER == 'Adadelta': optimizer = torch.optim.Adadelta(model.parameters(), lr=LEARNING_RATE) elif OPTIMIZER == 'RMSProp': optimizer = torch.optim.RMSprop(model.parameters(), lr=LEARNING_RATE) number_epochs_list = [2] for NUM_EPOCHS in number_epochs_list: training_loss = [] validation_loss = [] mean_training_loss = [] mean_validation_loss = [] for epoch in range(1, NUM_EPOCHS + 1): start = timeit.default_timer() train_loss = train(model, device, train_loader, optimizer, criterion, epoch) stop = timeit.default_timer() val_loss = validate(model, device, validate_loader, criterion, epoch) training_loss = training_loss + train_loss validation_loss = validation_loss + val_loss mean_training_loss = mean_training_loss + [np.mean(train_loss)] mean_validation_loss = mean_validation_loss + [np.mean(val_loss)] accuracy, testing_loss, cm, cm1 = test(model, device, test_loader, criterion, epoch) fig1 = plt.figure(figsize=(12, 8)) plt.plot(training_loss) plt.plot(validation_loss) plt.xlabel("batch samples", fontsize=20) plt.ylabel("loss", fontsize=20) plt.legend(['training loss', 'validation loss'], loc='upper right', fontsize=20) plt.title("batch-wise training and validation loss for batch size=" + str(BATCH_SIZE) + ", lr=" + str(LEARNING_RATE) + ", optimizer=" + str(OPTIMIZER) + ", num_epochs=" + str(NUM_EPOCHS), fontsize=15) # plt.show() fig1.savefig("batchwise_training_validation_loss_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) + "_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png") fig2 = plt.figure(figsize=(12, 8)) plt.plot(mean_training_loss) plt.plot(mean_validation_loss) plt.xlabel("epochs", fontsize=20) plt.ylabel("mean loss", fontsize=20) plt.legend(['mean training loss', 'mean validation loss'], loc='upper right', fontsize=20) # plt.show() plt.title("epoch-wise mean training and validation loss for batch size=" + str(BATCH_SIZE) + ", lr=" + str(LEARNING_RATE) + ", optimizer=" + str(OPTIMIZER) + ", num_epochs=" + str(NUM_EPOCHS), fontsize=15) fig2.savefig( "epochwise_mean_training_validation_loss_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) + "_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png") fig3 = plt.figure(figsize=(12, 8)) plt.plot(training_loss) plt.xlabel("batch samples", fontsize=20) plt.ylabel("loss", fontsize=20) plt.legend(['testing loss'], loc='upper right', fontsize=20) plt.title("testing loss for batch size=" + str(BATCH_SIZE) + ", lr=" + str(LEARNING_RATE) + ", optimizer=" + str(OPTIMIZER) + ", num_epochs=" + str(NUM_EPOCHS), fontsize=15) # plt.show() fig3.savefig("testing_loss_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) + "_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png") fig4, ax = plot_confusion_matrix(conf_mat=cm) #plt.show() print(type(cm1.F1)) print("f1",cm1.F1) fig4.savefig("confusion_matrix_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) + "_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png") results[(BATCH_SIZE, LEARNING_RATE, OPTIMIZER, NUM_EPOCHS)] = ( round(stop - start, 2), round(accuracy, 2)) print(results) pdf = matplotlib.backends.backend_pdf.PdfPages("output.pdf") for fig in range(1, plt.gcf().number + 1): ## will open an empty extra figure pdf.savefig(fig) pdf.close() df = pd.DataFrame(list(results.items())) df_parameters = pd.DataFrame(df.iloc[:, 0].tolist(), columns=['batch_size', 'learning_rate', 'optimizer_method', 'num_epochs']) df_obs = pd.DataFrame(df.iloc[:, 1].tolist(), columns=['time', 'accuracy']) df_final = pd.concat([df_parameters, df_obs], axis=1) df_final.to_csv("df_final.csv") df_f1 = pd.DataFrame(list(cm1.F1.items()),columns=['labels', 'f1_score']) resultsDF.append(df_final) f1DF.append(df_f1) df_results = pd.concat(resultsDF) df_results = df_results.drop_duplicates(keep='first', inplace=False) df_results.to_csv("results.csv") df_f1_results = pd.concat(f1DF) df_f1_results.to_csv("f1_score_results.csv")
torch.manual_seed(42) USE_CUDA = torch.cuda.is_available() DEVICE = torch.device("cuda" if USE_CUDA else "cpu") EPOCHS = 40 BATCH_SIZE = 64 # ## 데이터셋 불러오기 train_loader = torch.utils.data.DataLoader(datasets.MNIST( './.data', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))])), batch_size=BATCH_SIZE, shuffle=True) test_loader = torch.utils.data.DataLoader(datasets.MNIST( './.data', train=False, transform=transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))])), batch_size=BATCH_SIZE, shuffle=True) # ## 뉴럴넷으로 Fashion MNIST 학습하기
def __init__(self, config, args_data): self.root_dir = config.root_dir self.batch_size = config.batch_size self.load_epoch = config.load_epoch self.epoch_max = config.epoch_max self.phase = config.phase self.gpu_id = config.gpu_id self.used_device = torch.device("cuda:{}".format(self.gpu_id)) self.dataset = config.dataset self.test_id = config.test_id self.model_save = config.model_save self.G_type = config.G_type self.view = config.view self.input_size = config.input_size self.joint_num = config.joint_num self.G_lr = config.G_lr self.G_step_size = config.G_step_size self.G_opt_type = config.G_opt_type self.scheduler_type = config.scheduler_type # warm-up self.lr_lambda = lambda epoch: (0.33**max( 0, 2 - epoch // 2)) if epoch < 4 else np.exp(-0.04 * epoch) self.data_rt = self.root_dir + "/" + self.dataset if self.model_save == '': self.model_save = self.G_type + '_' + 'G' + str( self.G_opt_type) + str( self.G_lr) + "_" + self.scheduler_type + 'batch' + str( self.batch_size) self.model_dir = './model/' + self.dataset + '/' + self.model_save self.cur_epochs = self.load_epoch if not os.path.exists(self.model_dir): os.mkdir(self.model_dir) if not os.path.exists(self.model_dir + '/img'): os.mkdir(self.model_dir + '/img') # use GPU self.cuda = torch.cuda.is_available() gpu_num = 1 torch.cuda.set_device(self.gpu_id) cudnn.benchmark = True # set network if 'basic' in self.G_type: self.G = resnet18(pretrained=False, num_classes=3 * self.joint_num) elif 'resnet_mur' in self.G_type: self.G = resnet50(num_classes=self.joint_num * 3) self.G.apply(weights_init_resnet) if gpu_num > 1: self.G = nn.DataParallel(self.G).cuda() else: self.G = self.G.cuda() # load data logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%Y/%m/%d %H:%M:%S', filename=os.path.join(self.model_dir, 'train.log'), level=logging.INFO) logging.info('======================================================') # init loader if self.phase == 'train': if self.dataset == 'nyu': self.trainData = NyuHandPoseDataset( args_data.nyu_data_basepath, train=True, cropSize=args_data.in_crop_size, doJitterCom=args_data.do_jitter_com, sigmaCom=args_data.sigma_com, doAddWhiteNoise=args_data.do_add_white_noise, sigmaNoise=args_data.sigma_noise, unlabeledSampleIds=None, transform=transforms.ToTensor(), useCache=args_data.use_pickled_cache, cacheDir=args_data.nyu_data_basepath_pickled, annoType=args_data.anno_type, camIdsReal=[1], camIdsSynth=[], cropSize3D=args_data.crop_size_3d_tuple, args_data=args_data) self.testData = NyuHandPoseDataset( args_data.nyu_data_basepath, train=False, cropSize=args_data.in_crop_size, doJitterCom=args_data.do_jitter_com, sigmaCom=args_data.sigma_com, doAddWhiteNoise=args_data.do_add_white_noise, sigmaNoise=args_data.sigma_noise, unlabeledSampleIds=None, transform=transforms.ToTensor(), useCache=args_data.use_pickled_cache, cacheDir=args_data.nyu_data_basepath_pickled, annoType=args_data.anno_type, camIdsReal=[1], camIdsSynth=[], cropSize3D=args_data.crop_size_3d_tuple, args_data=args_data) self.trainLoader = DataLoader(self.trainData, batch_size=self.batch_size, shuffle=True, num_workers=8) self.testLoader = DataLoader(self.testData, batch_size=self.batch_size, shuffle=False, num_workers=8) else: if self.dataset == 'nyu': self.testData = NyuHandPoseDataset( args_data.nyu_data_basepath, train=False, cropSize=args_data.in_crop_size, doJitterCom=args_data.do_jitter_com, sigmaCom=args_data.sigma_com, doAddWhiteNoise=args_data.do_add_white_noise, sigmaNoise=args_data.sigma_noise, unlabeledSampleIds=None, transform=transforms.ToTensor(), useCache=args_data.use_pickled_cache, cacheDir=args_data.nyu_data_basepath_pickled, annoType=args_data.anno_type, camIdsReal=[1], camIdsSynth=[], cropSize3D=args_data.crop_size_3d_tuple, args_data=args_data) self.testLoader = DataLoader(self.testData, batch_size=self.batch_size, shuffle=False, num_workers=8) if self.G_opt_type == 'sgd': self.G_opt = optim.SGD(self.G.parameters(), lr=self.G_lr, momentum=0.9, weight_decay=1e-4) elif self.G_opt_type == 'adam': self.G_opt = optim.Adam(self.G.parameters(), lr=self.G_lr) elif self.G_opt_type == 'rmsprop': self.G_opt = optim.RMSprop(self.G.parameters(), lr=self.G_lr) if self.scheduler_type == 'step': self.G_scheduler = lr_scheduler.StepLR(self.G_opt, step_size=self.G_step_size, gamma=0.1) elif self.scheduler_type == 'SGDR': self.G_scheduler = optim.lr_scheduler.CosineAnnealingLR( self.G_opt, int(float(len(self.trainData)) / self.batch_size)) elif self.scheduler_type == 'warm-up': self.G_scheduler = optim.lr_scheduler.LambdaLR( self.G_opt, lr_lambda=self.lr_lambda) # load model if self.load_epoch != 0: self.G.load_state_dict( torch.load(os.path.join(self.model_dir + '/latest_G' + str(self.load_epoch) + '.pth'), map_location=lambda storage, loc: storage)) self.loss_list_name = [] self.loss_list = [] self.error_list = []
#%% import torchvision from torchvision.datasets import MNIST from torch.utils.data import DataLoader import torchvision.transforms as transforms import torch import torch.nn as nn import matplotlib.pyplot as plt import MnistCNN # %% #download MNIST DATA train_set = MNIST('./', train=True, transform=transforms.Compose([transforms.ToTensor()]),download=True) test_set = MNIST('./', train=False, transform=transforms.Compose([transforms.ToTensor()]),download=True) # %% #display a sample plt.imshow(train_set[0][0].squeeze(), cmap='gray') # %% #load data with batch size 100 train_loader = DataLoader(train_set, batch_size=100) test_loader = DataLoader(test_set, batch_size=100) # %% #setting of MNISTCNN model = MnistCNN.MnistCNN() error = nn.CrossEntropyLoss() learning_rate = 0.001 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) iterations_list = []
def reset(self): self.val = 0 self.avg = 0 self.numerator = 0 self.denominator = 0 def update(self, val, n=1): self.val = val self.numerator += val self.denominator += n self.avg = float(self.numerator) / float(self.denominator) if __name__ == '__main__': # Mean and std used to normalize cifar10. transform_train = transforms.Compose([transforms.ToTensor()]) train_dir = './data/' trainset = datasets.ImageFolder(train_dir, transform=transform_train) #trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform_train) mean, std = get_mean_and_std(trainset) print(mean) # output: (0.4914, 0.4822, 0.4465) print(std) # output: (0.2023, 0.1994, 0.2010) #city_function: #tensor([0.0047, 0.0054, 0.0062]) #tensor([0.0018, 0.0016, 0.0014]) # Mean and std used to normalize cifar100. transform_train = transforms.Compose([transforms.ToTensor()]) trainset = torchvision.datasets.CIFAR100(root='./data', train=True, download=False, transform=transform_train)
discriminator = Discriminator() if cuda: generator.cuda() discriminator.cuda() adversarial_loss.cuda() # Configure data loader os.makedirs("../../data/mnist", exist_ok=True) dataloader = torch.utils.data.DataLoader( datasets.MNIST( "../../data/mnist", train=True, download=True, transform=transforms.Compose( [transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])] ), ), batch_size=opt.batch_size, shuffle=True, ) # Optimizers optimizer_G = torch.optim.Adam( generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) optimizer_D = torch.optim.Adam( discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
def train(args): np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) kwargs = {'num_workers': 0, 'pin_memory': False} transform = transforms.Compose([ transforms.Resize(( args.image_size, args.image_size)), transforms.ToTensor(), transforms.Lambda(lambda x: x.mul(255))]) train_dataset = dataset.CustomImageDataset( args.dataset, transform=transform, img_size=args.image_size) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, **kwargs) transformer = TransformerNet(args.pad_type) transformer = transformer.train() optimizer = torch.optim.Adam(transformer.parameters(), args.lr) mse_loss = torch.nn.MSELoss() #print(transformer) vgg = Vgg16() vgg.load_state_dict(torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight"))) vgg.eval() transformer = transformer.cuda() vgg = vgg.cuda() style = utils.tensor_load_resize(args.style_image, args.style_size) style = style.unsqueeze(0) print("=> Style image size: " + str(style.size())) #(1, H, W, C) style = utils.preprocess_batch(style).cuda() utils.tensor_save_bgrimage(style[0].detach(), os.path.join(args.save_model_dir, 'train_style.jpg'), True) style = utils.subtract_imagenet_mean_batch(style) features_style = vgg(style) gram_style = [utils.gram_matrix(y).detach() for y in features_style] for e in range(args.epochs): train_loader.dataset.reset() agg_content_loss = 0. agg_style_loss = 0. iters = 0 for batch_id, (x, _) in enumerate(train_loader): if x.size(0) != args.batch_size: print("=> Skip incomplete batch") continue iters += 1 optimizer.zero_grad() x = utils.preprocess_batch(x).cuda() y = transformer(x) if (batch_id + 1) % 1000 == 0: idx = (batch_id + 1) // 1000 utils.tensor_save_bgrimage(y.data[0], os.path.join(args.save_model_dir, "out_%d.png" % idx), True) utils.tensor_save_bgrimage(x.data[0], os.path.join(args.save_model_dir, "in_%d.png" % idx), True) xc = x.detach() y = utils.subtract_imagenet_mean_batch(y) xc = utils.subtract_imagenet_mean_batch(xc) features_y = vgg(y) features_xc = vgg(center_crop(xc, y.size(2), y.size(3))) #content target f_xc_c = features_xc[2].detach() # content f_c = features_y[2] content_loss = args.content_weight * mse_loss(f_c, f_xc_c) style_loss = 0. for m in range(len(features_y)): gram_s = gram_style[m] gram_y = utils.gram_matrix(features_y[m]) batch_style_loss = 0 for n in range(gram_y.shape[0]): batch_style_loss += args.style_weight * mse_loss(gram_y[n], gram_s[0]) style_loss += batch_style_loss / gram_y.shape[0] total_loss = content_loss + style_loss total_loss.backward() optimizer.step() agg_content_loss += content_loss.data agg_style_loss += style_loss.data mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format( time.ctime(), e + 1, batch_id + 1, len(train_loader), agg_content_loss / iters, agg_style_loss / iters, (agg_content_loss + agg_style_loss) / iters ) print(mesg) agg_content_loss = agg_style_loss = 0.0 iters = 0 # save model save_model_filename = "epoch_" + str(e) + "_" + str(args.content_weight) + "_" + str(args.style_weight) + ".model" save_model_path = os.path.join(args.save_model_dir, save_model_filename) torch.save(transformer.state_dict(), save_model_path) print("\nDone, trained model saved at", save_model_path)
def main(): global args, best_prec1 args = parser.parse_args() 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)) if args.arch.startswith('mobilenetv1'): model = MobileNetV1() elif args.arch.startswith('mobilenetv2'): model = MobileNetV2() else: model = models.__dict__[args.arch]() print(model) if not args.distributed: 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() else: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) # 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) if args.evaluate: if os.path.isfile(args.evaluate): print("=> loading model '{}'".format(args.evaluate)) model.load_state_dict(torch.load(args.evaluate)) else: print("=> no model found at '{}'".format(args.evaluate)) # 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'] 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 prec1 = validate(val_loader, model, criterion) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint({ 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer' : optimizer.state_dict(), }, is_best)
def __init__(self, root_dir, set, tencrops=False, SemRGB=False): """ Initialize the dataset. Read scene categories, get number of classes, create filename and ground-truth labels lists, create ImAug and PyTorch transformations :param root_dir: Root directory to the dataset :param set: Dataset set: Training or Validation """ # Extract main path and set (Train or Val). self.image_dir = root_dir self.set = set # Set boolean variable of ten crops for validation self.TenCrop = tencrops self.SemRGB = SemRGB if SemRGB: self.RGB = "_RGB" else: self.RGB = "" # Decode dataset scene categories self.classes = list() class_file_name = os.path.join(root_dir, "categories_places365.txt") with open(class_file_name) as class_file: for line in class_file: line = line.split()[0] split_indices = [i for i, letter in enumerate(line) if letter == '/'] # Check if there a class with a subclass inside (outdoor, indoor) if len(split_indices) > 2: line = line[:split_indices[2]] + '-' + line[split_indices[2]+1:] self.classes.append(line[split_indices[1] + 1:]) # Get number of classes self.nclasses = self.classes.__len__() # Create list for filenames and scene ground-truth labels self.filenames = list() self.labels = list() self.labelsindex = list() self.auxiliarnames = list() filenames_file = os.path.join(root_dir, (set + ".txt")) # Fill filenames list and ground-truth labels list with open(filenames_file) as class_file: for line in class_file: # if random.random() > 0.6 or (self.set is "val"): split_indices = [i for i, letter in enumerate(line) if letter == '/'] # Obtain name and label name = line[split_indices[1] + 1:-1] label = line[split_indices[0] + 1: split_indices[1]] self.filenames.append(name) self.labels.append(label) self.labelsindex.append(self.classes.index(label)) str2 = "\n" indx2 = line.find(str2) self.auxiliarnames.append(line[0:indx2]) # Control Statements for data loading assert len(self.filenames) == len(self.labels) # ----------------------------- # # ImAug Transformations # # ----------------------------- # # Transformations for train set self.seq = iaa.Sequential([ # Small gaussian blur with random sigma between 0 and 0.5. iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0, 0.5))), # Strengthen or weaken the contrast in each image. iaa.ContrastNormalization((0.75, 1.5)), # Add gaussian noise. iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), # Make some images brighter and some darker. iaa.Multiply((0.8, 1.2), per_channel=0.2), ], random_order=True) # apply augmenters in random order self.seq_sem = iaa.Sequential([ iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels ], random_order=True) # ----------------------------- # # Pytorch Transformations # # ----------------------------- # self.mean = [0.485, 0.456, 0.406] self.STD = [0.229, 0.224, 0.225] self.outputSize = 224 # Train Set Transformation self.train_transforms_img = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(self.mean, self.STD) ]) self.train_transforms_scores = transforms.ToTensor() if not SemRGB: self.train_transforms_sem = transforms.Lambda( lambda sem: torch.unsqueeze(torch.from_numpy(np.asarray(sem) + 1).long(), 0)) else: self.train_transforms_sem = transforms.Lambda( lambda sem: torch.from_numpy(np.asarray(sem) + 1).long().permute(2, 0, 1)) # Transformations for validation set if not self.TenCrop: self.val_transforms_img = transforms.Compose([ transforms.CenterCrop(self.outputSize), transforms.ToTensor(), transforms.Normalize(self.mean, self.STD) ]) if not SemRGB: self.val_transforms_sem = transforms.Compose([ transforms.CenterCrop(self.outputSize), transforms.Lambda(lambda sem: torch.unsqueeze(torch.from_numpy(np.asarray(sem) + 1).long(), 0)) ]) self.val_transforms_scores = transforms.Compose([ transforms.CenterCrop(self.outputSize), transforms.ToTensor(), ]) else: self.val_transforms_sem = transforms.Compose([ transforms.CenterCrop(self.outputSize), transforms.Lambda(lambda sem: torch.from_numpy(np.asarray(sem) + 1).long().permute(2, 0, 1)) ]) self.val_transforms_scores = transforms.Compose([ transforms.CenterCrop(self.outputSize), transforms.ToTensor(), ]) else: self.val_transforms_img = transforms.Compose([ transforms.TenCrop(self.outputSize), transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), transforms.Lambda( lambda crops: torch.stack([transforms.Normalize(self.mean, self.STD)(crop) for crop in crops])), ]) if not SemRGB: self.val_transforms_sem = transforms.Compose([ transforms.TenCrop(self.outputSize), transforms.Lambda(lambda crops: torch.stack( [torch.unsqueeze(torch.from_numpy(np.asarray(crop) + 1).long(), 0) for crop in crops])) ]) self.val_transforms_scores = transforms.Compose([ transforms.TenCrop(self.outputSize), transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), ]) else: self.val_transforms_sem = transforms.Compose([ transforms.TenCrop(self.outputSize), transforms.Lambda(lambda crops: torch.stack( [torch.from_numpy(np.asarray(crop) + 1).long().permute(2, 0, 1) for crop in crops])), ]) self.val_transforms_scores = transforms.Compose([ transforms.TenCrop(self.outputSize), transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), ])
import torch import os import cv2 from torchvision import transforms class IconsDataset(torch.utils.data.Dataset): def __init__(self, root_dir, transform=None, imread_mode=cv2.IMREAD_COLOR): self.root_dir = root_dir self.transform = transform self.filenames = os.listdir(root_dir) self.mode = imread_mode def __len__(self): return len(self.filenames) def __getitem__(self, idx): filename = os.path.join(self.root_dir, self.filenames[idx]) image = cv2.imread(filename, self.mode) if self.transform: image = self.transform(image) return image basic_img_transform = transforms.Compose([transforms.ToTensor()])
def demo(data, save, depth=100, growth_rate=12, efficient=True, valid_size=5000, n_epochs=300, batch_size=64, seed=None): """ A demo to show off training of efficient DenseNets. Trains and evaluates a DenseNet-BC on CIFAR-10. Args: data (str) - path to directory where data should be loaded from/downloaded (default $DATA_DIR) save (str) - path to save the model to (default /tmp) depth (int) - depth of the network (number of convolution layers) (default 40) growth_rate (int) - number of features added per DenseNet layer (default 12) efficient (bool) - use the memory efficient implementation? (default True) valid_size (int) - size of validation set n_epochs (int) - number of epochs for training (default 300) batch_size (int) - size of minibatch (default 256) seed (int) - manually set the random seed (default None) """ # Get densenet configuration if (depth - 4) % 3: raise Exception('Invalid depth') block_config = [(depth - 4) // 6 for _ in range(3)] # Data transforms mean = [0.5071, 0.4867, 0.4408] stdv = [0.2675, 0.2565, 0.2761] train_transforms = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=mean, std=stdv), ]) test_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=mean, std=stdv), ]) # Datasets train_set = datasets.CIFAR10(data, train=True, transform=train_transforms, download=True) test_set = datasets.CIFAR10(data, train=False, transform=test_transforms, download=False) # Models model = DenseNet( growth_rate=growth_rate, block_config=block_config, num_classes=10, small_inputs=True, efficient=efficient, ) print(model) # Make save directory if not os.path.exists(save): os.makedirs(save) if not os.path.isdir(save): raise Exception('%s is not a dir' % save) # Train the model train(model=model, train_set=train_set, test_set=test_set, save=save, valid_size=valid_size, n_epochs=n_epochs, batch_size=batch_size, seed=seed) print('Done!')
tcg = torch.nn.DataParallel(tcg, device_ids=[0, 1, 2, 3, 4, 5, 6, 7]).cuda() log_format = '%(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format) fh = logging.FileHandler(os.path.join(log_dir, 'log.txt')) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) train_transforms = transforms.Compose([ transforms.Resize((256, 256)), # smaller edge to 128 transforms.RandomCrop(224), #transforms.RandomHorizontalFlip(0.5), transforms.ToTensor() ]) color_jitter = transforms.ColorJitter(brightness=0.8, contrast=0.8, saturation=0.8, hue=0.2) color_jitter = transforms.RandomApply([color_jitter], p=0.8) #train_dataset = UCF101VCOPDataset_color('data/ucf101', args.cl, args.it, args.tl, True, train_transforms,color_jitter_=color_jitter) train_dataset = K400VCOPDataset_train('data/K400', args.cl, args.it, args.tl, True, train_transforms) val_dataset = K400VCOPDataset_val('data/K400', args.cl, args.it, args.tl, True, train_transforms) # split val for 800 videos #train_dataset, val_dataset = random_split(train_dataset,(len(train_dataset)-800, 800)) logging.info('TRAIN video number: {}, VAL video number: {}.'.format( len(train_dataset), len(val_dataset)))
def main(): cut_list = [1, 2, 3] for i in range(len(cut_list)): if i < 2: continue for j in range(cut_list[i] * cut_list[i]): if j < 7: continue args.best_test_precision = 0 args.best_epoch = 0 checkpoint_save_dir = '/home/njuciairs/rainkeeper/Projects/PycharmProjects/Multi-granularity-integrations3/checkpoint0/' + str( cut_list[i] * cut_list[i]) + '_' + str(j) if not os.path.exists(checkpoint_save_dir): os.makedirs(checkpoint_save_dir) terminal_log_file = os.path.join(checkpoint_save_dir, 'terminal_log.txt') terminal_file = open(terminal_log_file, 'a') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) trainset = ImageDataset(image_dir=os.path.join( args.dataset_path, 'train_image', str(cut_list[i] * cut_list[i]) + '_' + str(j)), transform=transforms.Compose([ transforms.ToTensor(), normalize, ]), train=True) train_loader = torch.utils.data.DataLoader( trainset, shuffle=True, batch_size=args.batch_size, num_workers=args.workers) valset = ImageDataset(image_dir=os.path.join( args.dataset_path, 'test_image', str(cut_list[i] * cut_list[i]) + '_' + str(j)), transform=transforms.Compose([ transforms.ToTensor(), normalize, ]), train=False) val_loader = torch.utils.data.DataLoader( valset, shuffle=False, batch_size=args.batch_size, num_workers=args.workers) args.device = torch.device( args.gpu_id if torch.cuda.is_available() else "cpu") torch.cuda.manual_seed(args.seed) model = vggnet(load_weights=True) model.to(args.device) criterion = nn.CrossEntropyLoss().to(args.device) optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.pre: if os.path.isfile(args.pre): print("=> loading checkpoint '{}'".format(args.pre)) checkpoint = torch.load(args.pre) args.start_epoch = checkpoint['epoch'] args.best_test_precision = checkpoint[ 'best_test_precision'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.pre, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.pre)) for epoch in range(args.start_epoch, args.start_epoch + args.epochs): train_precision = train(train_loader, model, criterion, optimizer, epoch, terminal_file) test_correct, test_total = validate(val_loader, model, criterion, terminal_file) test_precision = float(test_correct) / test_total is_best = test_precision > args.best_test_precision if is_best: args.best_test_precision = test_precision args.best_epoch = epoch print( 'Epoch:%d, test correct:%d, test total:%d, test precsion:%.6f, current_best_test_acc:%.6f, current_best_acc_epoch:%d' % (epoch, test_correct, test_total, test_precision, args.best_test_precision, args.best_epoch)) print( 'Epoch:%d, test correct:%d, test total:%d, test precsion:%.6f, current_best_test_acc:%.6f, current_best_acc_epoch:%d' % (epoch, test_correct, test_total, test_precision, args.best_test_precision, args.best_epoch), file=terminal_file) if is_best: save_checkpoint( { 'epoch': epoch + 1, 'arch': args.pre, 'state_dict': model.state_dict(), 'best_test_precision': args.best_test_precision, 'optimizer': optimizer.state_dict() }, checkpoint_save_dir, epoch) if train_precision > 0.98: print('best_test_precision:%.6f' % args.best_test_precision) print('best_test_precision:%.6f' % args.best_test_precision, file=terminal_file) break
from torchsummary import summary # device configuration device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # hyper parameters EPOCHS = 20 batch_size = 64 learning_rate = 0.001 classes = 10 # Image preprocessing modules transform = transforms.Compose([ transforms.Pad(4), transforms.RandomHorizontalFlip(), transforms.RandomCrop(32), transforms.ToTensor(), ]) # cifar10 32*32*3 train_dataset = torchvision.datasets.CIFAR10(root='./cifar10_data', train=True, transform=transform, download=True) test_dataset = torchvision.datasets.CIFAR10(root='./cifar10_data', train=False, transform=transforms.ToTensor()) trainloader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) testloader = torch.utils.data.DataLoader(dataset=test_dataset,
def load_image(path, gpu=False): img = Image.open(path) img_tensor: torch.Tensor = transforms.ToTensor()(img) if gpu: img_tensor = img_tensor.cuda() return img_tensor.reshape(1, *img_tensor.shape)