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
