def get_train_loader():
train_loader = TripletImageLoader(
'data/FID-300/',
'train.txt',
[0, 250],
transform=transforms.Compose([
transforms.Resize((224, 112)),
transforms.CenterCrop((224, 112)),
transforms.ToTensor(),
#normalize,
transforms.Normalize(mean=[0.5], std=[1])
]))
train_loader.real_mode_prob = 0.3
return train_loader
def __make_default_dataloader(self, split: str, augment: bool,
num_triplets: int):
transforms = self.__get_transforms(augment)
dataset = TripletImageLoader(root='data',
base_path='ut-zap50k-images',
filenames_filename='filenames.json',
conditions=[0, 1, 2, 3],
split=split,
n_triplets=num_triplets,
transform=Compose(transforms))
return self.__make_dataloader_from_dataset(dataset)
def get_ref_loader():
# Ref Loader
ref_loader = TripletImageLoader('data/FID-300/',
'ref.txt', [0, 2000],
transform=transforms.Compose([
transforms.Resize((224, 112)),
transforms.CenterCrop((224, 112)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5],
std=[1])
]))
ref_loader.real_mode_prob = 1
ref_loader.angle_mod = 0
ref_loader.scale_mod = 0
ref_loader.trans_mod = 0
ref_loader.flip_mod = 0
ref_loader.load_ref = True
return ref_loader
def get_val_loader():
# Val Loader
#val_loader = TripletImageLoader('data/FID-300/', 'train.txt', [0,50],
val_loader = TripletImageLoader('data/FID-300/',
'val.txt', [0, 250],
transform=transforms.Compose([
transforms.Resize((224, 112)),
transforms.CenterCrop((224, 112)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5],
std=[1])
]))
val_loader.real_mode_prob = 1
val_loader.angle_mod = 0
val_loader.scale_mod = 0
val_loader.trans_mod = 0
val_loader.flip_mod = 0
return val_loader
def main():
global args, best_acc
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
if args.visdom:
global plotter
plotter = VisdomLinePlotter(env_name=args.name)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
global conditions
if args.conditions is not None:
conditions = args.conditions
else:
conditions = [0, 1, 2, 3]
kwargs = {'num_workers': 8, 'pin_memory': True} if args.cuda else {}
print('Loading Train Dataset')
train_loader = torch.utils.data.DataLoader(TripletImageLoader(
'data',
'ut-zap50k-images',
'filenames.json',
conditions,
'train',
n_triplets=args.num_traintriplets,
transform=transforms.Compose([
transforms.Resize(112),
transforms.CenterCrop(112),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
print('Loading Test Dataset')
test_loader = torch.utils.data.DataLoader(TripletImageLoader(
'data',
'ut-zap50k-images',
'filenames.json',
conditions,
'test',
n_triplets=160000,
transform=transforms.Compose([
transforms.Resize(112),
transforms.CenterCrop(112),
transforms.ToTensor(),
normalize,
])),
batch_size=16,
shuffle=True,
**kwargs)
print('Loading Val Dataset')
val_loader = torch.utils.data.DataLoader(TripletImageLoader(
'data',
'ut-zap50k-images',
'filenames.json',
conditions,
'val',
n_triplets=80000,
transform=transforms.Compose([
transforms.Resize(112),
transforms.CenterCrop(112),
transforms.ToTensor(),
normalize,
])),
batch_size=16,
shuffle=True,
**kwargs)
model = Resnet_models.resnext50_32x4d()
csn_model = ConditionalSimNet(model,
n_conditions=args.num_concepts,
embedding_size=args.dim_embed,
learnedmask=args.learned,
prein=args.prein)
global mask_var
mask_var = csn_model.masks.weight
tnet = CS_Tripletnet(csn_model, args.num_concepts)
if args.cuda:
tnet.cuda()
# 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']
tnet.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
parameters = filter(lambda p: p.requires_grad, tnet.parameters())
optimizer = optim.Adam(parameters, lr=args.lr)
n_parameters = sum([p.data.nelement() for p in tnet.parameters()])
print(' + Number of params: {}'.format(n_parameters))
if args.test:
checkpoint = torch.load('runs/%s/' % ('new_context_4/') +
'model_best.pth.tar')
tnet.load_state_dict(checkpoint['state_dict'])
test_acc = test(test_loader, tnet, criterion, 1)
sys.exit()
for epoch in range(args.start_epoch, args.epochs + 1):
# update learning rate
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, tnet, criterion, optimizer, epoch)
# evaluate on validation set
acc = test(val_loader, tnet, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': tnet.state_dict(),
'best_prec1': best_acc,
}, is_best)
checkpoint = torch.load('runs/%s/' % (args.name) + 'model_best.pth.tar')
tnet.load_state_dict(checkpoint['state_dict'])
test_acc = test(test_loader, tnet, criterion, 1)
def main():
parser = argparse.ArgumentParser(description='This is a WIP program')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--epochs', type=int, default=200, metavar='N',
help='number of epochs to train (default: 200)')
parser.add_argument('--start_epoch', type=int, default=1, metavar='N',
help='number of start epoch (default: 1)')
parser.add_argument('--lr', type=float, default=5e-5, metavar='LR',
help='learning rate (default: 5e-5)')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='enables CUDA training')
parser.add_argument('--log-interval', type=int, default=20, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--margin', type=float, default=0.2, metavar='M',
help='margin for triplet loss (default: 0.2)')
parser.add_argument('--resume', default='', type=str,
help='path to latest checkpoint (default: none)')
parser.add_argument('--name', default='Conditional_Similarity_Network', type=str,
help='name of experiment')
parser.add_argument('--embed_loss', type=float, default=5e-3, metavar='M',
help='parameter for loss for embedding norm')
parser.add_argument('--mask_loss', type=float, default=5e-4, metavar='M',
help='parameter for loss for mask norm')
parser.add_argument('--num_traintriplets', type=int, default=100000, metavar='N',
help='how many unique training triplets (default: 100000)')
parser.add_argument('--dim_embed', type=int, default=64, metavar='N',
help='how many dimensions in embedding (default: 64)')
parser.add_argument('--test', dest='test', action='store_true',
help='To only run inference on test set')
parser.add_argument('--learned', dest='learned', action='store_true',
help='To learn masks from random initialization')
parser.add_argument('--prein', dest='prein', action='store_true',
help='To initialize masks to be disjoint')
parser.add_argument('--conditions', nargs='*', type=int,
help='Set of similarity notions')
parser.add_argument('--out', type=str, default='result',
help='dir to save models and log')
parser.set_defaults(test=False)
parser.set_defaults(learned=False)
parser.set_defaults(prein=False)
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
normalize = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if args.conditions is not None:
conditions = args.conditions
else:
conditions = list(range(4))
kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else dict()
train_loader = torch.utils.data.DataLoader(
TripletImageLoader('data', 'ut-zap50k-images', 'filenames.json',
conditions, 'train', n_triplets=args.num_traintriplets,
transform=T.Compose([
T.Scale(112),
T.CenterCrop(112),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
TripletImageLoader('data', 'ut-zap50k-images', 'filenames.json',
conditions, 'test', n_triplets=160000,
transform=T.Compose([
T.Scale(112),
T.CenterCrop(112),
T.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
val_loader = torch.utils.data.DataLoader(
TripletImageLoader('data', 'ut-zap50k-images', 'filenames.json',
conditions, 'val', n_triplets=80000,
transform=T.Compose([
T.Scale(112),
T.CenterCrop(112),
T.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
model = resnet_18.resnet18(pretrained=True, embedding_size=args.dim_embed)
csn_model = ConditionalSimNet(model, n_conditions=len(conditions),
embedding_size=args.dim_embed,
learnedmask=args.learned, prein=args.prein)
mask_var = csn_model.masks.weight
triplet_net = CS_Tripletnet(csn_model)
if args.cuda:
triplet_net.cuda()
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']
triplet_net.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
parameters = filter(lambda p: p.requires_grad, triplet_net.parameters())
optimizer = optim.Adam(parameters, lr=args.lr)
n_param = sum([p.data.nelement() for p in triplet_net.parameters()])
print('# of parameters: {}'.format(n_param))
print('\n\n')
if args.test:
import sys
test_loss, test_acc = test(test_loader, triplet_net, args.epochs + 1)
print('accuracy: {}, loss: {}'.format(test_acc.avg, test_loss.avg))
sys.exit()
root = os.path.join(args.out, dt.now().strftime('%m%d_%H%M'))
if not os.path.exists(root):
os.makedirs(root)
best_acc = .0
log = dict()
start_time = dt.now()
for epoch in tqdm(range(args.start_epoch, args.epochs + 1), desc='total'):
adjust_lr(args, optimizer, epoch)
loss_acc_log = train(args, train_loader, triplet_net,
criterion, optimizer, epoch)
log['epoch_{}_train'.format(epoch)] = loss_acc_log
losses, accs = test(args, val_loader, triplet_net, criterion, epoch)
log['epoch_{}_val'.format(epoch)] = {
'loss': losses.avg, 'acc': 100. * accs.avg}
tqdm.write('[validation]\nloss: {:.4f}\tacc: {:.2f}%\n'.format(
losses.avg, 100. * accs.avg))
is_best = accs.avg > best_acc
best_acc = max(accs.avg, best_acc)
save_ckpt(root, triplet_net.state_dict(), is_best)
end_time = dt.now()
print('\ntraining finished.')
print('started at {}, ended at {}, duration is {} hours'.format(
start_time.strftime('%m%d, %H:%M'), end_time.strftime('%m%d, %H:%M'),
(end_time - start_time).total_seconds() / 3600.))
save_ckpt(root, triplet_net.state_dict(), filename='model.pth')
log_filepath = os.path.join(root, 'log.pkl')
with open(log_filepath, 'wb') as f:
pickle.dump(log, f)
print('log files saved at {}'.format(log_filepath))
def main():
global args, best_acc
global log_interval
log_interval = 30
args = parser.parse_args()
print(args)
nz = int(args.dim_embed)
nef = int(args.nef)
ndf = int(args.ndf)
ngpu = int(args.ngpu)
nc = int(args.nc)
out_size = args.image_size // 16
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
normalize = transforms.Normalize(mean=[0.0, 0.0, 0.0],
std=[1, 1, 1])
out_size = args.image_size // 16
kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(
TripletImageLoader('../data', '', 'train/train_data.json',
'train', n_triplets=args.num_traintriplets,
transform=transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.train_batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
TripletImageLoader('../data', '', 'test/test_data.json',
'test', n_triplets=args.num_testtriplets,
transform=transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
val_loader = torch.utils.data.DataLoader(
TripletImageLoader('../data', '', 'val/val_data.json',
'val', n_triplets=args.num_valtriplets,
transform=transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
encoder = _Encoder(ngpu,nc,nef,out_size,nz)
encoder.apply(weights_init)
print(encoder)
if args.cuda:
encoder = encoder.cuda()
tnet = Tripletnet(encoder)
if args.cuda:
tnet.cuda()
decoder = _Decoder(ngpu,nc,ndf,out_size,nz)
decoder.apply(weights_init)
print(decoder)
if args.cuda:
decoder = decoder.cuda()
descriptor = _VGG(ngpu)
if args.cuda:
descriptor = descriptor.cuda()
print(descriptor)
global train_loss_metric,train_loss_VAE,train_acc_metric,test_loss_metric,test_loss_VAE,test_acc_metric
train_loss_metric = []
train_loss_VAE = []
train_acc_metric = []
test_loss_metric = []
test_loss_VAE = []
test_acc_metric = []
# 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']
train_loss_metric = checkpoint['train_loss_metric']
train_loss_VAE = checkpoint['train_loss_VAE']
train_acc_metric = checkpoint['train_acc_metric']
test_loss_metric = checkpoint['test_loss_metric']
test_loss_VAE = checkpoint['test_loss_VAE']
test_acc_metric = checkpoint['test_acc_metric']
tnet.load_state_dict(checkpoint['state_dict'])
encoder.load_state_dict(checkpoint['encoder_state_dict'])
decoder.load_state_dict(checkpoint['decoder_state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = False
criterion = torch.nn.MarginRankingLoss(margin = args.margin)
parameters = list(tnet.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(parameters, lr=args.lr, betas=(args.beta1, args.beta2))
n_parameters = sum([p.data.nelement() for p in tnet.parameters()])
print(' + Number of params in tnet: {}'.format(n_parameters))
if args.test:
test_acc = test(test_loader, tnet,decoder,descriptor, criterion, 1)
sys.exit()
for epoch in range(args.start_epoch, args.epochs + 1):
# update learning rate
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, tnet,decoder,descriptor, criterion, optimizer, epoch)
# evaluate on validation set
acc = test(val_loader, tnet,decoder,descriptor, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': tnet.state_dict(),
'encoder_state_dict': encoder.state_dict(),
'decoder_state_dict': decoder.state_dict(),
'best_prec1': best_acc,
'train_loss_metric':train_loss_metric,
'train_loss_VAE':train_loss_VAE,
'train_acc_metric':train_acc_metric,
'test_loss_metric':test_loss_metric,
'test_loss_VAE':test_loss_VAE,
'test_acc_metric':test_acc_metric,
}, is_best)
def main():
global args, best_acc
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
#global plotter
#plotter = VisdomLinePlotter(env_name=args.name)
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(TripletImageLoader(
'.',
'./filenames_filename.txt',
'./triplets_train_name.txt',
transform=transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
valid_loader = torch.utils.data.DataLoader(TripletImageLoader(
'.',
'./filenames_filename.txt',
'./triplets_valid_name.txt',
transform=transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 10, kernel_size=5)
self.conv1_drop = nn.Dropout2d()
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(16820, 128)
self.fc2 = nn.Linear(128, 20)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 16820)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
return self.fc2(x)
model = Net()
tnet = Tripletnet(model)
if args.cuda:
tnet.cuda()
# 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']
tnet.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
#optimizer = optim.SGD(tnet.parameters(), lr=args.lr, momentum=args.momentum)
def make_optimizer(model, opt, lr, weight_decay, momentum, nesterov=True):
if opt == 'SGD':
optimizer = getattr(torch.optim, opt)(model.parameters(),
lr=lr,
weight_decay=weight_decay,
momentum=momentum,
nesterov=nesterov)
elif opt == 'AMSGRAD':
optimizer = getattr(torch.optim, 'Adam')(model.parameters(),
lr=lr,
weight_decay=weight_decay,
amsgrad=True)
elif opt == 'Ranger':
optimizer = Ranger(params=filter(lambda p: p.requires_grad,
model.parameters()),
lr=lr)
elif opt == 'RMS':
optimizer = torch.optim.RMSprop(model.parameters(),
lr=lr,
alpha=0.99,
eps=1e-08,
weight_decay=weight_decay,
momentum=momentum,
centered=False)
return optimizer
optimizer = make_optimizer(tnet,
opt=args.opt,
lr=args.lr,
weight_decay=args.weight_decay,
momentum=args.momentum,
nesterov=True)
n_parameters = sum([p.data.nelement() for p in tnet.parameters()])
print(' + Number of params: {}'.format(n_parameters))
for epoch in range(1, args.epochs + 1):
# train for one epoch
train(train_loader, tnet, criterion, optimizer, epoch)
# evaluate on validation set
acc = test(valid_loader, tnet, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': tnet.state_dict(),
'best_prec1': best_acc,
}, is_best)
def main():
global args, best_acc
global log_interval
log_interval = 30
args = parser.parse_args()
print(args)
nz = int(args.dim_embed)
nef = int(args.nef)
ndf = int(args.ndf)
ngpu = int(args.ngpu)
nc = 3
out_size = args.image_size // 16
# Normalize = nn.BatchNorm2d
args.cuda = not args.no_cuda and torch.cuda.is_available()
#cuda = args.cuda
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# if args.visdom:
# global plotter
# plotter = VisdomLinePlotter(env_name=args.name)
#VGG!!!!
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
# transform = transforms.Compose([
# transforms.Scale(args.image_size),
# #transforms.CenterCrop(args.image_size),
# transforms.ToTensor(),
# transforms.Normalize(mean=(0.485, 0.456, 0.406),
# std=(0.229, 0.224, 0.225))])
global conditions
#'Set of similarity notions'
if args.conditions is not None:
conditions = args.conditions
else:
conditions = [0, 1, 2, 3]
print("#" * 20)
print('conditions are ', conditions)
print("#" * 20)
# out_size = args.image_size // 2**5 #5 is because in vgg19 there are 5 pool layers
out_size = args.image_size // 16 # from garbage.py: Encoder makes x/2*4 w/ 4 conv/max layer
kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(TripletImageLoader(
'data',
'ut-zap50k-images',
'filenames.json',
conditions,
'train',
n_triplets=args.num_traintriplets,
transform=transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(TripletImageLoader(
'data',
'ut-zap50k-images',
'filenames.json',
conditions,
'test',
n_triplets=args.num_testtriplets,
transform=transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(TripletImageLoader(
'data',
'ut-zap50k-images',
'filenames.json',
conditions,
'val',
n_triplets=args.num_valtriplets,
transform=transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
# model = Resnet_18.resnet18(pretrained=True, embedding_size=args.dim_embed)
# model = Vgg_19.vgg19(pretrained=True, embedding_size=args.dim_embed,out_size =out_size)
#embedding_size=64,output_size =8
#### putting encoder instead of model
encoder = _Encoder(ngpu, nc, nef, out_size, nz)
encoder.apply(weights_init)
# if args.encoder != '':
# encoder.load_state_dict(torch.load(args.encoder))
print(encoder)
if args.cuda:
encoder = encoder.cuda()
#changing csn input to encoder from model(vgg))
tnet = Tripletnet(encoder)
if args.cuda:
tnet.cuda()
decoder = _Decoder(ngpu, nc, ndf, out_size, nz)
decoder.apply(weights_init)
# if args.decoder != '':
# decoder.load_state_dict(torch.load(args.decoder))
print(decoder)
if args.cuda:
decoder = decoder.cuda()
descriptor = _VGG(ngpu)
if args.cuda:
descriptor = descriptor.cuda()
print(descriptor)
global train_loss_metric, train_loss_VAE, train_acc_metric, test_loss_metric, test_loss_VAE, test_acc_metric
train_loss_metric = []
train_loss_VAE = []
train_acc_metric = []
test_loss_metric = []
test_loss_VAE = []
test_acc_metric = []
# 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']
train_loss_metric = checkpoint['train_loss_metric']
train_loss_VAE = checkpoint['train_loss_VAE']
train_acc_metric = checkpoint['train_acc_metric']
test_loss_metric = checkpoint['test_loss_metric']
test_loss_VAE = checkpoint['test_loss_VAE']
test_acc_metric = checkpoint['test_acc_metric']
tnet.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = False
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
# parameters = filter(lambda p: p.requires_grad, tnet.parameters())
parameters = list(tnet.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(parameters,
lr=args.lr,
betas=(args.beta1, args.beta2))
n_parameters = sum([p.data.nelement() for p in tnet.parameters()])
print(' + Number of params in tnet: {}'.format(n_parameters))
#####
#####
######
if args.test:
test_acc = test(test_loader, tnet, decoder, descriptor, criterion, 1)
sys.exit()
for epoch in range(args.start_epoch, args.epochs + 1):
# update learning rate
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, tnet, decoder, descriptor, criterion, optimizer,
epoch)
# evaluate on validation set
acc = test(val_loader, tnet, decoder, descriptor, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': tnet.state_dict(),
'best_prec1': best_acc,
'train_loss_metric': train_loss_metric,
'train_loss_VAE': train_loss_VAE,
'train_acc_metric': train_acc_metric,
'test_loss_metric': test_loss_metric,
'test_loss_VAE': test_loss_VAE,
'test_acc_metric': test_acc_metric,
}, is_best)
def main():
global args, best_acc
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(TripletImageLoader(
base_path='',
filenames_filename="C:/Users/DELL/ds_info.txt",
triplets_file_name=
"C:/Users/DELL/triplet-network-pytorch-master/ds_distant.txt",
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=1,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(TripletImageLoader(
base_path='',
filenames_filename="C:/Users/DELL/ds_info/ds_info(10, 14)_62.txt",
triplets_file_name=
"C:/Users/DELL/triplet-network-pytorch-master/ds_distant.txt",
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=1,
shuffle=True,
**kwargs)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(10, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(50, x.size(0) * 10)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
return self.fc2(x)
model = Net()
tnet = Tripletnet(model)
if args.cuda:
tnet.cuda()
# 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']
tnet.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
optimizer = optim.SGD(tnet.parameters(),
lr=args.lr,
momentum=args.momentum)
n_parameters = sum([p.data.nelement() for p in tnet.parameters()])
print(' + Number of params: {}'.format(n_parameters))
for epoch in range(1, args.epochs + 1):
# train for one epoch
train(train_loader, tnet, criterion, optimizer, epoch)
# evaluate on validation set
acc = test(test_loader, tnet, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': tnet.state_dict(),
'best_prec1': 100,
}, is_best)
test(test_loader, tnet, criterion, epoch)
def main():
global args, best_acc
global log_interval
log_interval = 30
args = parser.parse_args()
print(args)
nz = int(args.dim_embed)
nef = int(args.nef)
ndf = int(args.ndf)
ngpu = int(args.ngpu)
nc = int(args.nc)
out_size = args.image_size // 16
# Data Loaders
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
normalize = transforms.Normalize(mean=[0.0, 0.0, 0.0], std=[1, 1, 1])
out_size = args.image_size // 16
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(
TripletImageLoader('data/FID-300/', [0, 250],
transform=transforms.Compose([
transforms.Resize((224, 112)),
transforms.CenterCrop((224, 112)),
transforms.ToTensor(),
normalize,
])),
batch_size=args.train_batch_size,
shuffle=True,
**kwargs)
# Encoder Network
encoder = _Encoder(ngpu, nc, nef, out_size, nz)
encoder.apply(weights_init)
if args.cuda:
encoder = encoder.cuda()
tnet = Tripletnet(encoder)
if args.cuda:
tnet.cuda()
# Decoder
decoder = _Decoder(ngpu, nc, ndf, out_size, nz)
decoder.apply(weights_init)
# Global Storage
global train_loss_metric, train_loss_VAE, train_acc_metric, test_loss_metric, test_loss_VAE, test_acc_metric
train_loss_metric = []
train_loss_VAE = []
train_acc_metric = []
test_loss_metric = []
test_loss_VAE = []
test_acc_metric = []
# Loss Functions and Params
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
parameters = list(tnet.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(parameters,
lr=args.lr,
betas=(args.beta1, args.beta2))
# Half points
half_points = [50, 100, 150]
for epoch in range(args.start_epoch, args.epochs + 1):
# Half the LR based on above interval
if epoch in half_points:
half_lr(optimizer)
# Print
print(epoch)
print("LR: " + str(optimizer.param_groups[0]['lr']))
# Train
train(train_loader, tnet, decoder, criterion, optimizer, epoch)
print("OK")
def main():
global args, best_acc
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# global plotter
# plotter = VisdomLinePlotter(env_name=args.name)
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
root_dir = "../caltech-data/"
triplet_data_dir = os.path.join(root_dir, "triplet_data")
train_triplet_path_file = os.path.join(triplet_data_dir,
"triplet_paths_train.txt")
train_triplet_idx_file = os.path.join(triplet_data_dir,
"triplet_index_train.txt")
val_triplet_path_file = os.path.join(triplet_data_dir,
"triplet_paths_val.txt")
val_triplet_idx_file = os.path.join(triplet_data_dir,
"triplet_index_val.txt")
train_loader = torch.utils.data.DataLoader(TripletImageLoader(
filenames_filename=train_triplet_path_file,
triplets_file_name=train_triplet_idx_file,
transform=transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(TripletImageLoader(
filenames_filename=val_triplet_path_file,
triplets_file_name=val_triplet_idx_file,
transform=transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
embedingnet = Vgg_Net()
tnet = Tripletnet(embedingnet)
print(tnet)
if args.cuda:
tnet.cuda()
# 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']
tnet.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
criterion = torch.nn.MarginRankingLoss(margin=args.margin)
optimizer = optim.SGD(tnet.parameters(),
lr=args.lr,
momentum=args.momentum)
n_parameters = sum([p.data.nelement() for p in tnet.parameters()])
print(' + Number of params: {}'.format(n_parameters))
for epoch in range(1, args.epochs + 1):
# train for one epoch
train(train_loader, tnet, criterion, optimizer, epoch)
# evaluate on validation set
acc = test(test_loader, tnet, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': tnet.state_dict(),
'best_prec1': best_acc,
}, is_best)
