def load_train_val_data(dir_, weighted_average=False): # print(dir_) train_dir = dir_ + '/train' val_dir = dir_ + '/val' train_transforms = transforms.Compose([ transforms.Resize((128, 128)), transforms.RandomRotation(90), transforms.ToTensor(), transforms.Normalize([0.5832, 0.5695, 0.5371], [0.2093, 0.2163, 0.2292]) ]) val_transforms = transforms.Compose([ transforms.Resize((128, 128)), #transforms.RandomRotation(90), transforms.ToTensor(), transforms.Normalize([0.5832, 0.5695, 0.5371], [0.2093, 0.2163, 0.2292]) ]) train_data = datasets.ImageFolder(train_dir, transform=train_transforms) val_data = datasets.ImageFolder(val_dir, transform=train_transforms) train_data = nc.SafeDataset(train_data) val_data = nc.SafeDataset(val_data) trainloader = data.DataLoader(train_data, batch_size=32, shuffle=True, num_workers=0) if weighted_average: manual_seed(0) val_data_split = data.random_split( val_data, [len(val_data) // 2, (len(val_data) - len(val_data) // 2)]) valloader_1 = data.DataLoader(val_data_split[0], batch_size=32, shuffle=True, num_workers=0) valloader_2 = data.DataLoader(val_data_split[1], batch_size=32, shuffle=True, num_workers=0) return trainloader, valloader_1, valloader_2 else: valloader = data.DataLoader(val_data, batch_size=32, shuffle=True, num_workers=0) return trainloader, valloader
def test_sequential_sampler(self): dataset = data.TensorDataset(torch.arange(0, 10)) dataset = nonechucks.SafeDataset(dataset) dataloader = data.DataLoader( dataset, sampler=nonechucks.SafeSequentialSampler(dataset)) for i_batch, sample_batched in enumerate(dataloader): print("Sample {}: {}".format(i_batch, sample_batched))
def test_first_last_sampler(self): dataset = data.TensorDataset(torch.arange(0, 10)) dataset = nonechucks.SafeDataset(dataset) dataloader = data.DataLoader( dataset, sampler=nonechucks.SafeFirstAndLastSampler(dataset)) for i_batch, sample_batched in enumerate(dataloader): print('Sample {}: {}'.format(i_batch, sample_batched))
def load_dataset(): data_transform = transforms.Compose([ transforms.RandomSizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) path = './HAM_dataset_work' dataset_total1 = torchvision.datasets.ImageFolder(root=path, transform=data_transform) dataset_total = nc.SafeDataset(dataset_total1) train_size = int(0.75 * len(dataset_total)) test_size = len(dataset_total) - train_size train_dataset, test_dataset = torch.utils.data.random_split( dataset_total, [train_size, test_size]) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, num_workers=0, shuffle=True) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, num_workers=0, shuffle=True) return train_loader, test_loader
def test_alright(self): r"""Checks that the dataset is correctly loaded when nothing is wrong""" tensors = [torch.randn(2, 3) for _ in range(DATASET_SIZE)] dataset = nc.SafeDataset(TensorDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size) not_seen = DATASET_SIZE for batch in loader: self.assertEqual(batch.size(0), min(batch_size, not_seen)) not_seen -= batch.size(0)
def test_padding_none(self): tensors = [torch.randn(2 * i + 1, 3) for i in range(DATASET_SIZE)] tensors[5] = None dataset = nc.SafeDataset(DictDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size, collate_fn=self.pad) not_seen = DATASET_SIZE - 1 for batch in loader: self.assertEqual(batch.size(1), min(batch_size, not_seen)) not_seen -= batch.size(1)
def get_dataset(name: str, params: dict, split: float = None, train: bool = True, safe: bool = True) -> Dataset: if name not in datasets: raise ValueError(f"unknown dataset '{name}'") ds = datasets[name](**params) if split is not None: ds = split_dataset(ds, split)[1 if train else 0] if safe: ds = nc.SafeDataset(ds) return ds
def test_padding_alright(self): r"""Pads sequence of different-sizes tensors""" tensors = [torch.randn(2 * i + 1, 3) for i in range(DATASET_SIZE)] dataset = nc.SafeDataset(TensorDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size, collate_fn=pad_sequence) not_seen = DATASET_SIZE for batch in loader: self.assertEqual(batch.size(1), min(batch_size, not_seen)) not_seen -= batch.size(1)
def test_custom_collate_alright(self): r"""Custom collate_fn when whole dataset is valid""" tensors = [torch.randn(2, 3) for _ in range(DATASET_SIZE)] dataset = nc.SafeDataset(TensorDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size, collate_fn=torch.stack) not_seen = DATASET_SIZE for batch in loader: self.assertEqual(batch.size(0), min(batch_size, not_seen)) not_seen -= batch.size(0)
def test_sampler_wrapper(self, mock_len, mock_get_item): def side_effect(idx): return [0, 1, None, 3, 4, 5][idx] mock_get_item.side_effect = side_effect mock_len.return_value = 6 dataset = data.TensorDataset(torch.arange(0, 10)) dataset = nonechucks.SafeDataset(dataset) self.assertEqual(len(dataset), 6) sequential_sampler = data.SequentialSampler(dataset) dataloader = data.DataLoader(dataset, sampler=nonechucks.SafeSampler( dataset, sequential_sampler)) for i_batch, sample_batched in enumerate(dataloader): print('Sample {}: {}'.format(i_batch, sample_batched))
def test_none(self): tensors = [torch.randn(2, 3) for _ in range(DATASET_SIZE)] tensors[5] = None dataset = nc.SafeDataset(DictDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size) not_seen = DATASET_SIZE - 1 for batch in loader: self.assertEqual(batch['idx'].size(0), min(batch_size, not_seen)) self.assertEqual(batch['tensor'].size(0), min(batch_size, not_seen)) not_seen -= batch['idx'].size(0)
def test_alright(self): r"""Elements of the dataset are dicts""" tensors = [torch.randn(2, 3) for _ in range(DATASET_SIZE)] dataset = nc.SafeDataset(DictDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size) not_seen = DATASET_SIZE for batch in loader: self.assertEqual(batch['idx'].size(0), min(batch_size, not_seen)) self.assertEqual(batch['tensor'].size(0), min(batch_size, not_seen)) not_seen -= batch['idx'].size(0)
def test_padding_none_batch_first(self): r"""Same as above with batch first""" tensors = [torch.randn(2 * i + 1, 3) for i in range(DATASET_SIZE)] tensors[5] = None dataset = nc.SafeDataset(TensorDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size, collate_fn=partial(pad_sequence, batch_first=True)) not_seen = DATASET_SIZE - 1 for batch in loader: self.assertEqual(batch.size(0), min(batch_size, not_seen)) not_seen -= batch.size(0)
def create_MUG_dataset(folder, imsize, slice_length, seed, pretrain): np_load_old = np.load # modify the default parameters of np.load np.load_ = lambda *a, **k: np_load_old(*a, allow_pickle=True, **k) npz_file = os.path.join(folder, 'MUG_0-255_OF_112x112_color.npz') file_labels = os.path.join(folder, 'labels.npz') labels = np.load(file_labels)['arr_0'] data = np.load_(npz_file)['arr_0'] imgs_train, imgs_test, labels_train, labels_test = train_test_split( data, labels, test_size=.25, random_state=seed) data_train = [imgs_train, labels_train] data_test = [imgs_test, labels_test] flip_flag = True if pretrain else False dataset_train = nc.SafeDataset( MyMUGDataset(data_train, imsize, slice_length, flip_flag)) dataset_test = nc.SafeDataset( MyMUGDataset(data_test, imsize, slice_length, flip_flag)) print('data train shape', imgs_train.shape) print('data test shape', imgs_test.shape) return dataset_train, dataset_test
def test_custom_collate_none(self): r"""Custom collate_fn when one sample is corrupted""" tensors = [torch.randn(2, 3) for _ in range(DATASET_SIZE)] tensors[5] = None dataset = nc.SafeDataset(TensorDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size, collate_fn=torch.stack) not_seen = DATASET_SIZE - 1 for batch in loader: self.assertEqual(batch.size(0), min(batch_size, not_seen)) not_seen -= batch.size(0)
def test_none(self): r"""Checks that `None`s in the dataset are ignored""" for num_nones in range(1, DATASET_SIZE): tensors = [torch.randn(2, 3) for _ in range(DATASET_SIZE)] for i in random.sample(list(range(DATASET_SIZE)), num_nones): tensors[i] = None dataset = nc.SafeDataset(TensorDataset(tensors)) for batch_size in range(1, DATASET_SIZE): loader = nc.SafeDataLoader(dataset, batch_size=batch_size) not_seen = DATASET_SIZE - num_nones for batch in loader: self.assertEqual(batch.size(0), min(batch_size, not_seen)) not_seen -= batch.size(0)
def _custom_loader(path, mode='train', batch_size=16, shuffle=True, nworkers=4, imsize=(224, 224), randrot=15, scale=0.5, gksize=(35, 35), gdratio=2.0, guse_pad=False, gpad_factor=0.1, aff_thresh=0.1): if mode == 'train': tfrm = trainset_transform(img_size=imsize, resize_size=imsize, randrot_deg=randrot, scale=scale) else: tfrm = validset_transform(resize_size=imsize, scale=scale) dset = CustomDataset(path, mode, transform=tfrm, aff_thresh=aff_thresh, gauss_ksize=gksize, gauss_dratio=gdratio, gauss_use_pad=guse_pad, gauss_pad_factor=gpad_factor) dset = nc.SafeDataset(dset) loader = DataLoader(dset, batch_size=batch_size, shuffle=shuffle, num_workers=nworkers, drop_last=True) return loader
def train(m, optim, dataset): dataloader = torch.utils.data.DataLoader(nonechucks.SafeDataset(dataset), batch_size=16, shuffle=True, num_workers=16) m.train() confusion_matrix = torch.zeros(nb_classes, nb_classes) display = True for img, label in progressbar.progressbar(dataloader): if display: viz.images(img, win="TRAINING_SAMPLES", opts={'title': "Training Samples"}) display = False img = img.cuda() label = label.cuda() optim.zero_grad() y = m(img).squeeze() _, max_indicices = torch.max(y, 1) confusion_matrix[max_indicices, label] += 1 loss = torch.nn.functional.cross_entropy(y, label) trainlm.registerLoss(loss.item() / 16) loss.backward() optim.step() correct = torch.sum(confusion_matrix.diag()).item() total = torch.sum(confusion_matrix).item() viz.heatmap(confusion_matrix, win="ConfusionTrain", opts={ 'title': "CONFUSION TRAIN " + str(correct) + " / " + str(total) + " -- " + str(correct / total * 100) + "%", 'rownames': traindataset.classes, 'columnnames': traindataset.classes })
"""We have over 6000 images in our training set.""" img, label = train_ds[0] print(img.shape, label) len(train_ds) """We use about 20% of the original training set for our validation set, which uses just 1500 images.""" img, label = val_ds[0] print(img.shape, label) len(val_ds) """We use SafeDataset to clean out any images that have broken links/won't work.""" training_set = nc.SafeDataset(train_ds) validation_set = nc.SafeDataset(val_ds) """Likewise we use SafeDataLoader to load in our batch size for training the model (about half the dimensions of our images), and then we load in our validation set as well. We decided to choose a batch size about half the dimensions of our input images, while also doubling its size for the validation set.""" train_dl = nc.SafeDataLoader(training_set, batch_size = 64, shuffle = True) val_dl = nc.SafeDataLoader(validation_set, batch_size = 128, shuffle = False) """Now we create our CNN model called RussianArtClassifier. We create several layers in the model called features that we use by creating nn.Sequential objects. We first use a Conv2d method that creates a set of convolutional filters that use the first argument as the number of input channels, which for us is 3 since we are using color images. The second argument is the number of output channels, which for us is 32 channels, and then the kernel_size argument asks for how large our convolutional filter to be, which for us will be a 3x3 size, and then finally stride which controls how far the kernel moves on the input image (we also have padding but we kept it the same at 1 throughout the CNN). The output of a convolutional layer is given by (W−F+2P)/S+1, where W represents the weights (128x128x3), F is the kernel (3x3), P is pooling, and S is stride. We have 4 convolutional layers with ReLU activation function after each layer along with a batch normalization. The last layer is a max pooling operation, used to reduce the number of parameters to learn and computation needed to be performed, and we have it set up so that we down-sample our data by reducing the effective size of it by a factor of 2. All of the self.features of the convolutional layers are similar to one another, and we also include a drop-out layer to avoid over-fitting the model. We also have a fully connected layer called classifier which also uses ReLU activations. We have it all compiled in the forward function, which takes input argument x (which is the data being passed through the model), and we pass this data to all the convolutional layers and return the output as "out" and we also apply a view function after these layers are done that flattens out the data dimensions. Then the dropout is applied, followed by the fully connected layers, with the final output being returned from the function. It's also fed through a soft max function that converts our single vector of numbers into a vector of probabilities, 1-5 representing each type of art piece that can be chosen by the model. We also included a way to store the results for training loss, validation loss, and the total accuracies of the model, along with a function to get the accuracy by using the torch.max function which returns the index of the maximum value in a sensor, which we used from code we used in a previous homework called Classify Impressionists.""" class RussianArtClassifier(nn.Module): def __init__(self): super(RussianArtClassifier, self).__init__() self.features1 = nn.Sequential( nn.Conv2d(3, 32, kernel_size = 3, stride = 2, padding = 1), nn.ReLU(),
def get_safe_dataset_pair(cls, dataset, **kwargs): """Returns a `SafeDatasetPair` (a tuple of size 2), which contains both the unsafe and safe versions of the dataset. """ return SafeDatasetTest.SafeDatasetPair( dataset, nonechucks.SafeDataset(dataset, **kwargs))
def main(): train = pd.read_csv('../input/train.csv') LABELS = list(train.label.unique()) label_idx = {label: i for i, label in enumerate(LABELS)} train.set_index("fname") train["label_idx"] = train.label.apply(lambda x: label_idx[x]) if DEBUG: train = train[:500] skf = StratifiedKFold(n_splits=config.n_folds) for foldNum, (train_split, val_split) in enumerate(skf.split(train, train.label_idx)): end = time.time() # split the dataset for cross-validation train_set = train.iloc[train_split] train_set = train_set.reset_index(drop=True) val_set = train.iloc[val_split] val_set = val_set.reset_index(drop=True) logging.info("Fold {0}, Train samples:{1}, val samples:{2}".format( foldNum, len(train_set), len(val_set))) # define train loader and val loader trainSet = Freesound_logmel(config=config, frame=train_set, transform=transforms.Compose([ToTensor()]), mode="train") train_loader = nc.SafeDataLoader(nc.SafeDataset(trainSet), batch_size=config.batch_size, shuffle=True, num_workers=0, pin_memory=True) valSet = Freesound_logmel(config=config, frame=val_set, transform=transforms.Compose([ToTensor()]), mode="train") val_loader = nc.SafeDataLoader(nc.SafeDataset(valSet), batch_size=config.batch_size, shuffle=False, num_workers=0, pin_memory=True) model = run_method_by_string(config.arch)(pretrained=config.pretrain) # define loss function (criterion) and optimizer if config.mixup: train_criterion = cross_entropy_onehot else: train_criterion = nn.CrossEntropyLoss().cuda() val_criterion = nn.CrossEntropyLoss().cuda() optimizer = optim.SGD(model.parameters(), lr=config.lr, momentum=config.momentum, weight_decay=config.weight_decay) cudnn.benchmark = True train_on_fold(model, train_criterion, val_criterion, optimizer, train_loader, val_loader, config, foldNum) time_on_fold = time.strftime('%Hh:%Mm:%Ss', time.gmtime(time.time() - end)) logging.info( "--------------Time on fold {}: {}--------------\n".format( foldNum, time_on_fold))
g_model_path = g_model_path[-1] start_epoch = int( g_model_path.replace( '\\', '/').split('/')[-1].split('.')[0].split('-')[1]) if USE_ADVERSARIAL: d_model_path = sorted(glob(D_MODEL_PATH, recursive=True)) if len(d_model_path) == 0: LOAD_D = False else: d_model_path = d_model_path[-1] os.makedirs(output_dir, exist_ok=True) dataset = nc.SafeDataset( MidiDataset(npy_glob_pattern=DATASET_PATH, num_samples=num_samples, train_step_multiplier=100)) dataloader = nc.SafeDataLoader(dataset=dataset, batch_size=batch_size, shuffle=True, num_workers=4) writer = SummaryWriter('logs') G = M.VAE(num_samples, height, width, h_dim, z_dim) if USE_ADVERSARIAL: D = M.Discriminator(num_samples, height, width) if LOAD_G: G.load_state_dict(torch.load(g_model_path))
def main(args): global best_acc global idx # idx is the index of joints used to compute accuracy if args.dataset in ['mpii', 'lsp']: idx = [1, 2, 3, 4, 5, 6, 11, 12, 15, 16] elif args.dataset == 'coco': idx = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] else: print("Unknown dataset: {}".format(args.dataset)) assert False # create checkpoint dir if not isdir(args.checkpoint): mkdir_p(args.checkpoint) # create model njoints = datasets.__dict__[args.dataset].njoints print("==> creating model '{}', stacks={}, blocks={}".format( args.arch, args.stacks, args.blocks)) model = models.__dict__[args.arch](num_stacks=args.stacks, num_blocks=args.blocks, num_classes=njoints, resnet_layers=args.resnet_layers) model = torch.nn.DataParallel(model).to(device) # define loss function (criterion) and optimizer criterion = losses.JointsMSELoss().to(device) if args.solver == 'rms': optimizer = torch.optim.RMSprop(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) elif args.solver == 'adam': optimizer = torch.optim.Adam( model.parameters(), lr=args.lr, ) else: print('Unknown solver: {}'.format(args.solver)) assert False # optionally resume from a checkpoint title = args.dataset + ' ' + args.arch if args.resume: if isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_acc = checkpoint['best_acc'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) logger = Logger(join(args.checkpoint, 'log.txt'), title=title, resume=True) else: print("=> no checkpoint found at '{}'".format(args.resume)) else: logger = Logger(join(args.checkpoint, 'log.txt'), title=title) logger.set_names( ['Epoch', 'LR', 'Train Loss', 'Val Loss', 'Train Acc', 'Val Acc']) print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) # create data loader train_dataset = datasets.__dict__[args.dataset](is_train=True, **vars(args)) train_dataset = nc.SafeDataset(train_dataset) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.train_batch, shuffle=True, num_workers=args.workers, pin_memory=True) val_dataset = datasets.__dict__[args.dataset](is_train=False, **vars(args)) val_dataset = nc.SafeDataset(val_dataset) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=True) # evaluation only if args.evaluate: print('\nEvaluation only') loss, acc, predictions = validate(val_loader, model, criterion, njoints, args.debug, args.flip) print("loss: " + str(loss), " accuracy: " + str(acc)) save_pred(predictions, checkpoint=args.checkpoint) return # train and eval lr = args.lr for epoch in range(args.start_epoch, args.epochs): lr = adjust_learning_rate(optimizer, epoch, lr, args.schedule, args.gamma) print('\nEpoch: %d | LR: %.8f' % (epoch + 1, lr)) # decay sigma if args.sigma_decay > 0: train_loader.dataset.sigma *= args.sigma_decay val_loader.dataset.sigma *= args.sigma_decay # train for one epoch train_loss, train_acc = train(train_loader, model, criterion, optimizer, args.debug, args.flip) # evaluate on validation set valid_loss, valid_acc, predictions = validate(val_loader, model, criterion, njoints, args.debug, args.flip) # append logger file logger.append( [epoch + 1, lr, train_loss, valid_loss, train_acc, valid_acc]) # remember best acc and save checkpoint is_best = valid_acc > best_acc best_acc = max(valid_acc, best_acc) save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_acc': best_acc, 'optimizer': optimizer.state_dict(), }, predictions, is_best, checkpoint=args.checkpoint, snapshot=args.snapshot) logger.close() logger.plot(['Train Acc', 'Val Acc']) savefig(os.path.join(args.checkpoint, 'log.eps'))
def train(content_set, style_set, batch_size=1, learning_rate=0.005, num_epochs=1000): iteration = 20000 betas = { 'conv1_1': 1., 'conv2_1': 0.8, 'conv3_1': 0.3, 'conv4_1': 0.25, 'conv5_1': 0.2 } alpha = 1 beta = 1500000 np.random.seed(1000) content_img = content_set[1600][0].unsqueeze(0).to("cpu").detach() transformed_img = content_img.clone().requires_grad_(True) style_set = nc.SafeDataset(style_set) style_loader = nc.SafeDataLoader(style_set, batch_size=batch_size, shuffle=True, num_workers=1) optimizer = optim.Adam([transformed_img], lr=learning_rate) train_loss = [] for i in range(num_epochs): content_batch = content_img content_rep = get_content_rep(content_batch) for style_steps, (style_imgs, __) in enumerate(style_loader): target_reps = get_target_rep(transformed_img) s_loss = 0 c_loss = get_content_loss(content_rep['conv4_2'], target_reps['conv4_2']) style_rep = get_style_rep(style_imgs) style_gs = { layer: gram_matrix(style_rep[layer]) for layer in style_rep } for layer in betas: target_rep = target_reps[layer] target_g = gram_matrix(target_rep) style_g = style_gs[layer] s_loss_temp = betas[layer] * get_style_loss(style_g, target_g) s_loss += s_loss_temp loss = alpha * c_loss + beta * s_loss loss.backward(retain_graph=True) optimizer.step() optimizer.zero_grad() if i % 50 == 0: print('EPOCH:{} current loss:{} '.format(i, loss.item())) img = content_img.to("cpu").detach() img = img[0].numpy() img = img.transpose(1, 2, 0) img = img * np.array((0.229, 0.224, 0.225)) + np.array( (0.485, 0.456, 0.406)) img = img.clip(0, 1) plt.imshow(img) plt.show() img = transformed_img.to("cpu").detach() img = img[0].numpy() img = img.transpose(1, 2, 0) img = img * np.array((0.229, 0.224, 0.225)) + np.array( (0.485, 0.456, 0.406)) img = img.clip(0, 1) plt.imshow(img) plt.show() if i % 100 == 0: train_loss.append(loss.item()) n = len(train_loss) plt.title("Train Loss") plt.plot(range(1, n + 1), train_loss, label="Train") plt.xlabel("Interation") plt.ylabel("Loss") plt.legend(loc='best') plt.show()
def train(transform_model, content_set, train_indices, val_indices, style_set, batch_size=1, learning_rate=0.005, num_epochs=1000, save_name='model_graphite'): iteration = 20000 betas = { 'conv1_1': 1., 'conv2_1': 0.8, 'conv3_1': 0.3, 'conv4_1': 0.25, 'conv5_1': 0.2 } alpha = 1 beta = 1500000 np.random.seed(1000) train_sampler = SubsetRandomSampler(train_indices) content_loader = torch.utils.data.DataLoader(content_set, batch_size=batch_size, num_workers=1, sampler=train_sampler) val_sampler = SubsetRandomSampler(val_indices) content_val_loader = torch.utils.data.DataLoader(content_set, batch_size=batch_size, num_workers=1, sampler=val_sampler) style_set = nc.SafeDataset(style_set) style_loader = nc.SafeDataLoader(style_set, batch_size=batch_size, shuffle=True, num_workers=1) optimizer = optim.Adam(transform_model.parameters(), lr=learning_rate) transform_model.train() train_loss = [] for i in range(num_epochs): for j, (content_img, __) in enumerate(content_loader): content_batch = content_img target_batch = content_batch.clone().requires_grad_(True) content_rep = get_content_rep(content_batch) for style_steps, (style_imgs, __) in enumerate(style_loader): transformed_img = transform_model(target_batch.cuda()) target_reps = get_target_rep(transformed_img) s_loss = 0 c_loss = get_content_loss(content_rep['conv4_2'], target_reps['conv4_2']) style_rep = get_style_rep(style_imgs) style_gs = { layer: gram_matrix(style_rep[layer]) for layer in style_rep } for layer in betas: target_rep = target_reps[layer] target_g = gram_matrix(target_rep) style_g = style_gs[layer] s_loss_temp = betas[layer] * get_style_loss( style_g, target_g) s_loss += s_loss_temp loss = alpha * c_loss + beta * s_loss loss.backward(retain_graph=True) optimizer.step() optimizer.zero_grad() if j % 50 == 0: print('EPOCH:{} current loss:{} '.format(i, loss.item())) torch.save( transform_model.state_dict(), '/content/gdrive/My Drive/APS360_Style_Transfer/Saved Models/' + save_name) img = content_img.to("cpu").detach() img = img[0].numpy() img = img.transpose(1, 2, 0) img = img * np.array((0.229, 0.224, 0.225)) + np.array( (0.485, 0.456, 0.406)) img = img.clip(0, 1) plt.imshow(img) plt.show() img = transformed_img.to("cpu").detach() img = img[0].numpy() img = img.transpose(1, 2, 0) img = img * np.array((0.229, 0.224, 0.225)) + np.array( (0.485, 0.456, 0.406)) img = img.clip(0, 1) plt.imshow(img) plt.show() if j % 100 == 0: train_loss.append(loss.item()) n = len(train_loss) plt.title("Train Loss") plt.plot(range(1, n + 1), train_loss, label="Train") plt.xlabel("Interation") plt.ylabel("Loss") plt.legend(loc='best') plt.show()
import torchvision as tv import math import matplotlib.pyplot as plt from torchvision import transforms from torch.utils.data import DataLoader as dataloader import nonechucks as nc from voc_seg import my_data, label_acc_score, voc_colormap, seg_target vgg = tv.models.vgg19_bn(pretrained=True) image_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) train_data = my_data((240, 320), transform=image_transform) test_data = my_data((240, 320), image_set='val', transform=image_transform) trainset = nc.SafeDataset(train_data) testset = nc.SafeDataset(test_data) # trainload=nc.SafeDataLoader(trainset,batch_size=8) testload = nc.SafeDataLoader(testset, batch_size=8) mask_transform = transforms.Compose( [seg_target()]) # to_tensor will make it from nhwc to nchw train_voc = tv.datasets.VOCSegmentation( '/home/llm/PycharmProjects/seg_1224/data/', image_set='train', transform=image_transform, target_transform=mask_transform) trainload = torch.utils.data.DataLoader(train_voc, shuffle=True) device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
def __init__(self, data_folder): # initialize CUDA self.device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") print(f'Pytorch will utilize the following device: {self.device}') self.batch_size = 5 self.learning_rate = 0.00001 # self.learning_rate = 0.025 # self.lr_decay = 0.85 # The transformation to be performed on every input image # We crop, resize, and then turn our numpy array (0-255) to a tensor (0.0-1.0) trans = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((240, 240)), #data augmentation transforms.RandomRotation(45), transforms.RandomCrop((150, 150)), transforms.RandomHorizontalFlip(), #end of data augmentation # transforms.CenterCrop((150, 150)), # We lower the resolution to 110*110, according to the paper transforms.Resize((110, 110)), transforms.ToTensor(), # These numbers were roughly approximated from a randomly chosen sample ]) full_dataset = nc.SafeDataset(HeartDataSet(data_folder, trans)) train_dataset, test_dataset = torch.utils.data.random_split( full_dataset, [675, 135]) # train_dataset, test_dataset = sklearn.model_selection.train_test_split(full_dataset, 0.25, 0.75, random_state=1, stratify=) # train_dataset = nc.SafeDataset(HeartDataSet(train_folder, trans)) # test_dataset = nc.SafeDataset(HeartDataSet(test_folder, trans)) self.train_loader = DataLoader(dataset=train_dataset, batch_size=self.batch_size, shuffle=True) self.test_loader = DataLoader(dataset=test_dataset, batch_size=self.batch_size, shuffle=False) # More information about the model: # https://www.nature.com/articles/s41746-018-0065-x # The learning rate and decay is defined under 'Left Ventricular Hypertrophy Classification' self.model = CNN().to(self.device) self.criterion = nn.BCELoss( ) # The way we calculate the loss is defined here self.optimizer = torch.optim.Adam( self.model.parameters(), lr=self.learning_rate, ) # self.scheduler = torch.optim.lr_scheduler.ExponentialLR(self.optimizer, gamma=self.lr_decay) # variables defined here so we preserve data between validation self.validate_loss_list = [] self.validate_acc_list = [] self.validate_f1score_list = []
def main(): device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu:0') configuration = Configuration('project.config') config = configuration.get_config_options() # create_vocabulary_from_dataset(config) # make_target_vocab(config) word2idx, dataset_vectors = load_target_vocab(config) use_safe_dataset = True dataset = TextDataset(word2idx, dataset_vectors, config=config) if use_safe_dataset: dataset = nc.SafeDataset(dataset) data_loader = nc.SafeDataLoader(dataset=dataset, batch_size=config.globals.BATCH_SIZE, num_workers=0, shuffle=True) else: data_loader = datautil.DataLoader(dataset=dataset, batch_size=config.globals.BATCH_SIZE, num_workers=0, shuffle=False) # model = SentenceEncoder(target_vocab = word2idx.keys(), vectors = dataset_vectors, config = config) # doc_enc = DocumentEncoder(config=config) policy_net = DQN(target_vocab=word2idx.keys(), vectors=dataset_vectors, config=config).to(device) target_net = DQN(target_vocab=word2idx.keys(), vectors=dataset_vectors, config=config).to(device) target_net.load_state_dict(policy_net.state_dict()) target_net.eval() reward_func = Reward() h = reward_func.get_reward([['hello']], [[['this is a good hello']]]) print(h) def select_action(config, doc, state): # TODO: fix the function to handle the full batchsize # TODO: send all tensors to GPU sample = np.random.random() # article = '\n'.join(doc['raw']) # article = article.split('\n\n') doc_tensor = doc['tensor'][:, :len(doc['raw']) - 1] # Putting this here as we need q_values one way or the other q_values = policy_net(doc_tensor, get_q_approx=True, sum_i=state['sum_i']) # Decay the epsilon per EPS_DECAY_ITER iterations if iter % config.dqn.EPS_DECAY_ITER == 0: config.dqn.EPS_START -= config.dqn.EPS_DECAY print('EPSILON Decayed to : ', config.dqn.EPS_START) if sample < config.dqn.EPS_START: i = np.random.randint(low=0, high=len(doc['raw']) - 1) else: # actions are sentences i = torch.argmax(q_values, dim=1) a_i = (i, doc['raw'][i]) return a_i, q_values optimizer = torch.optim.RMSprop(policy_net.parameters()) memory = ReplayMemory(config.dqn.REPLAY_MEM_SIZE) epoch = 0 iter = 0 for epoch in tqdm(range(epoch, config.globals.NUM_EPOCHS)): policy_net.train() for i, (story, highlights) in tqdm(enumerate(data_loader)): state = { 'curr_summary_ids': [], 'curr_summary': [], 'sum_i': torch.zeros((100)) } next_state = state prev_r_i, r_i = 0 # locking to 10 for simplicity purposes for i in count(config.dqn.SUMMARY_LENGTH): iter = iter + 1 # if i>20 : break story['tensor'] = story['tensor'].to(device) highlights['tensor'] = highlights['tensor'].to(device) # sentence representation are calculated as no grad because we dont want to disturb / update the weights with torch.no_grad(): H_i, D_i, x = policy_net( story['tensor'][:, :len(story['raw']) - 1]) a_i, q_values = select_action(config, story, state) next_state['curr_summary_ids'].append(int(a_i[0])) next_state['curr_summary'].append(a_i[1]) next_state['sum_i'] = Sum_i(H_i, state['curr_summary_ids'], q_values) r_i = reward_func.get_reward([next_state['curr_summary']], gold_summ=[[highlights['raw']]], **{ 'prev_score': prev_r_i, 'config': config }) prev_r_i = r_i # checks if we are close to the summ length part done = check_done(config, next_state) if done: next_state = None # TODO: check which a_i has to be loaded , a_i[0] or a_i[1] or just a_i memory.push(state, H_i[a_i[0]], next_state, r_i) state = next_state optimize_model(config) if done: break
if __name__ == '__main__': transform = transforms.Compose([ transforms.CenterCrop(84), transforms.ToTensor(), ]) import nonechucks as nc dataset = Charades( root='/vision/group/Charades_RGB/Charades_v1_rgb', split='train', labelpath='/vision/group/Charades/annotations/Charades_v1_train.csv', cachedir= '/vision2/u/rhsieh91/pytorch-i3d/charades_experiments/charades_cache', clip_size=16, is_val=False, transform=transform) dataset = nc.SafeDataset(dataset) # train_loader_1 = torch.utils.data.DataLoader(dataset, # batch_size=8, # shuffle=True, # num_workers=0, # pin_memory=True) train_loader_2 = nc.SafeDataLoader(dataset, batch_size=8, shuffle=True, num_workers=0, pin_memory=True) # pdb.set_trace() for i, a in enumerate(train_loader): print(a[0].shape) # data
self.transform = transform def __getitem__(self, index): lmdb_value = None with self.lmdb_connection.begin(write=False) as txn: lmdb_value = txn.get(self.keys[index]) assert lmdb_value is not None, f"Read empty record for key: {self.keys[index]}" img_name, img_arr, img_shape = LMDBDataset.decompress_and_deserialize(lmdb_value=lmdb_value) image = np.frombuffer(img_arr, dtype=np.uint8).reshape(img_shape) if image.size == 0: raise InvalidFileException("Invalid file found, skipping") return image @staticmethod def decompress_and_deserialize(lmdb_value: Any): return pyarrow.deserialize(lz4framed.decompress(lmdb_value)) def __len__(self): return self.length if __name__ == '__main__': dataset = nc.SafeDataset(LMDBDataset('./data/lmdb-tmp.db')) batch_size = 64 data_loader = DataLoader(dataset, shuffle=True, batch_size=batch_size, num_workers=4, pin_memory=False) n_epochs = 50 for _ in range(n_epochs): for batch in data_loader: assert len(batch) > 0